diff options
Diffstat (limited to 'src/plugins/cdp')
| -rw-r--r-- | src/plugins/cdp/cdp.api | 36 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp.c | 222 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp.h | 154 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp.pg | 7 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_all_api_h.h | 19 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_input.c | 504 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_msg_enum.h | 31 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_node.c | 215 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_periodic.c | 515 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_protocol.h | 186 | ||||
| -rw-r--r-- | src/plugins/cdp/cdp_test.c | 179 |
11 files changed, 2068 insertions, 0 deletions
diff --git a/src/plugins/cdp/cdp.api b/src/plugins/cdp/cdp.api new file mode 100644 index 00000000000..34507025f42 --- /dev/null +++ b/src/plugins/cdp/cdp.api @@ -0,0 +1,36 @@ +/* + * Simple enable/disable API for the cdp protocol + * + * Copyright (c) 2011-2018 by 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. + */ + +option version = "1.0.0"; + +autoreply define cdp_enable_disable +{ + /* Client identifier, set from api_main.my_client_index */ + u32 client_index; + + /* Arbitrary context, so client can match reply to request */ + u32 context; + + /* Enable / disable the feature */ + u8 enable_disable; +}; + +/* + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp.c b/src/plugins/cdp/cdp.c new file mode 100644 index 00000000000..a88a06bc9c5 --- /dev/null +++ b/src/plugins/cdp/cdp.c @@ -0,0 +1,222 @@ +/* + * cdp.c - cdp protocol plug-in + * + * Copyright (c) 2011-2018 by 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 <vnet/vnet.h> +#include <vnet/plugin/plugin.h> +#include <cdp/cdp.h> + +#include <vlibapi/api.h> +#include <vlibmemory/api.h> +#include <vpp/app/version.h> + +/* define message IDs */ +#include <cdp/cdp_msg_enum.h> + +/* define message structures */ +#define vl_typedefs +#include <cdp/cdp_all_api_h.h> +#undef vl_typedefs + +/* define generated endian-swappers */ +#define vl_endianfun +#include <cdp/cdp_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) +#define vl_printfun +#include <cdp/cdp_all_api_h.h> +#undef vl_printfun + +/* Get the API version number */ +#define vl_api_version(n,v) static u32 api_version=(v); +#include <cdp/cdp_all_api_h.h> +#undef vl_api_version + +/* + * A handy macro to set up a message reply. + * Assumes that the following variables are available: + * mp - pointer to request message + * rmp - pointer to reply message type + * rv - return value + */ + +#define REPLY_MACRO(t) \ +do { \ + unix_shared_memory_queue_t * q = \ + vl_api_client_index_to_input_queue (mp->client_index); \ + if (!q) \ + return; \ + \ + rmp = vl_msg_api_alloc (sizeof (*rmp)); \ + rmp->_vl_msg_id = ntohs((t)+cm->msg_id_base); \ + rmp->context = mp->context; \ + rmp->retval = ntohl(rv); \ + \ + vl_msg_api_send_shmem (q, (u8 *)&rmp); \ +} while(0); + + +/* List of message types that this plugin understands */ + +#define foreach_cdp_plugin_api_msg \ +_(CDP_ENABLE_DISABLE, cdp_enable_disable) + +/* Action function shared between message handler and debug CLI */ + +int +cdp_enable_disable (cdp_main_t * cm, int enable_disable) +{ + int rv = 0; + + if (enable_disable) + vlib_process_signal_event (cm->vlib_main, cdp_process_node.index, + CDP_EVENT_ENABLE, 0); + else + vlib_process_signal_event (cm->vlib_main, cdp_process_node.index, + CDP_EVENT_DISABLE, 0); + cm->enabled = enable_disable; + + return rv; +} + +static clib_error_t * +cdp_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + cdp_main_t *cm = &cdp_main; + int enable_disable = 1; + + int rv; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "disable")) + enable_disable = 0; + else if (unformat (input, "enable")) + enable_disable = 1; + else + break; + } + + rv = cdp_enable_disable (cm, enable_disable); + + switch (rv) + { + case 0: + break; + + default: + return clib_error_return (0, "cdp_enable_disable returned %d", rv); + } + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cdp_command, static) = +{ + .path = "cdp", + .short_help = "cdp enable | disable", + .function = cdp_command_fn, +}; +/* *INDENT-ON* */ + +/* API message handler */ +static void vl_api_cdp_enable_disable_t_handler + (vl_api_cdp_enable_disable_t * mp) +{ + vl_api_cdp_enable_disable_reply_t *rmp; + cdp_main_t *cm = &cdp_main; + int rv; + + rv = cdp_enable_disable (cm, (int) (mp->enable_disable)); + + REPLY_MACRO (VL_API_CDP_ENABLE_DISABLE_REPLY); +} + +/* Set up the API message handling tables */ +static clib_error_t * +cdp_plugin_api_hookup (vlib_main_t * vm) +{ + cdp_main_t *cm = &cdp_main; +#define _(N,n) \ + vl_msg_api_set_handlers((VL_API_##N + cm->msg_id_base), \ + #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_cdp_plugin_api_msg; +#undef _ + + return 0; +} + +#define vl_msg_name_crc_list +#include <cdp/cdp_all_api_h.h> +#undef vl_msg_name_crc_list + +static void +setup_message_id_table (cdp_main_t * cm, api_main_t * am) +{ +#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n #crc, id + cm->msg_id_base); + foreach_vl_msg_name_crc_cdp; +#undef _ +} + +static clib_error_t * +cdp_init (vlib_main_t * vm) +{ + cdp_main_t *cm = &cdp_main; + clib_error_t *error = 0; + u8 *name; + + cm->vlib_main = vm; + + name = format (0, "cdp_%08x%c", api_version, 0); + + /* Ask for a correctly-sized block of API message decode slots */ + cm->msg_id_base = vl_msg_api_get_msg_ids + ((char *) name, VL_MSG_FIRST_AVAILABLE); + + error = cdp_plugin_api_hookup (vm); + + /* Add our API messages to the global name_crc hash table */ + setup_message_id_table (cm, &api_main); + + vec_free (name); + + return error; +} + +VLIB_INIT_FUNCTION (cdp_init); + +/* *INDENT-OFF* */ +VLIB_PLUGIN_REGISTER () = +{ + .version = VPP_BUILD_VER, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp.h b/src/plugins/cdp/cdp.h new file mode 100644 index 00000000000..32a07825ecb --- /dev/null +++ b/src/plugins/cdp/cdp.h @@ -0,0 +1,154 @@ + +/* + * cdp.h - cdp protocol plug-in + * + * Copyright (c) 2011-2018 by 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. + */ +#ifndef __included_cdp_h__ +#define __included_cdp_h__ + +#include <vlib/vlib.h> +#include <vlib/unix/unix.h> + +#include <vnet/snap/snap.h> +#include <vnet/hdlc/hdlc.h> +#include <vnet/hdlc/packet.h> + +#include <vppinfra/format.h> +#include <vppinfra/hash.h> + +#include "cdp_protocol.h" + +typedef enum +{ + CDP_PACKET_TEMPLATE_ETHERNET, + CDP_PACKET_TEMPLATE_HDLC, + CDP_PACKET_TEMPLATE_SRP, + CDP_N_PACKET_TEMPLATES, +} cdp_packet_template_id_t; + +typedef struct +{ + /* neighbor's vlib software interface index */ + u32 sw_if_index; + + /* Timers */ + f64 last_heard; + f64 last_sent; + + /* Neighbor time-to-live (usually 180s) */ + u8 ttl_in_seconds; + + /* "no cdp run" or similar */ + u8 disabled; + + /* tx packet template id for this neighbor */ + u8 packet_template_index; + + /* Jenkins hash optimization: avoid tlv scan, send short keepalive msg */ + u8 last_packet_signature_valid; + uword last_packet_signature; + + /* Info we actually keep about each neighbor */ + u8 *device_name; + u8 *version; + u8 *port_id; + u8 *platform; + + /* last received packet, for the J-hash optimization */ + u8 *last_rx_pkt; +} cdp_neighbor_t; + +#define foreach_neighbor_string_field \ +_(device_name) \ +_(version) \ +_(port_id) \ +_(platform) + +typedef struct +{ + /* pool of cdp neighbors */ + cdp_neighbor_t *neighbors; + + /* plugin message id base */ + u16 msg_id_base; + + /* tx pcap debug enable */ + u8 tx_pcap_debug; + + /* rapidly find a neighbor by vlib software interface index */ + uword *neighbor_by_sw_if_index; + + /* Background process node index */ + u32 cdp_process_node_index; + + /* top-level state */ + int enabled; + + /* Packet templates for different encap types */ + vlib_packet_template_t packet_templates[CDP_N_PACKET_TEMPLATES]; + + /* convenience variables */ + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; +} cdp_main_t; + +extern cdp_main_t cdp_main; +extern vlib_node_registration_t cdp_process_node; + +/* Packet counters */ +#define foreach_cdp_error \ +_ (NONE, "good cdp packets (processed)") \ +_ (CACHE_HIT, "good cdp packets (cache hit)") \ +_ (BAD_TLV, "cdp packets with bad TLVs") \ +_ (PROTOCOL_VERSION, "cdp packets with bad protocol versions") \ +_ (CHECKSUM, "cdp packets with bad checksums") \ +_ (DISABLED, "cdp packets received on disabled interfaces") + +typedef enum +{ +#define _(sym,str) CDP_ERROR_##sym, + foreach_cdp_error +#undef _ + CDP_N_ERROR, +} cdp_error_t; + +/* cdp packet trace capture */ +typedef struct +{ + u32 len; + u8 data[400]; +} cdp_input_trace_t; + +typedef enum +{ + CDP_EVENT_ENABLE, + CDP_EVENT_DISABLE, +} cdp_process_event_t; + +cdp_error_t cdp_input (vlib_main_t * vm, vlib_buffer_t * b0, u32 bi0); +void cdp_periodic (vlib_main_t * vm); +void cdp_keepalive (cdp_main_t * cm, cdp_neighbor_t * n); +u16 cdp_checksum (void *p, int count); +u8 *cdp_input_format_trace (u8 * s, va_list * args); + +#endif /* __included_cdp_h__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp.pg b/src/plugins/cdp/cdp.pg new file mode 100644 index 00000000000..b6ba18656c2 --- /dev/null +++ b/src/plugins/cdp/cdp.pg @@ -0,0 +1,7 @@ +packet-generator new { + name cdp + limit 1 + node cdp-input + size 374-374 + data { hex 0x02b46b96000100096978676265000500bf436973636f20494f5320536f6674776172652c2043333735304520536f66747761726520284333373530452d554e4956455253414c2d4d292c2056657273696f6e2031322e32283335295345352c2052454c4541534520534f4654574152452028666331290a436f707972696768742028632920313938362d3230303720627920436973636f2053797374656d732c20496e632e0a436f6d70696c6564205468752031392d4a756c2d30372031363a3137206279206e616368656e00060018636973636f2057532d4333373530452d3234544400020011000000010101cc0004000000000003001b54656e4769676162697445746865726e6574312f302f3100040008000000280008002400000c011200000000ffffffff010221ff000000000000001e7a50f000ff000000090004000a00060001000b0005010012000500001300050000160011000000010101cc000400000000001a00100000000100000000ffffffff } +} diff --git a/src/plugins/cdp/cdp_all_api_h.h b/src/plugins/cdp/cdp_all_api_h.h new file mode 100644 index 00000000000..cc0047e6399 --- /dev/null +++ b/src/plugins/cdp/cdp_all_api_h.h @@ -0,0 +1,19 @@ + +/* + * cdp_all_api_h.h - cdp plug-in api #include file + * + * Copyright (c) 2011-2018 by 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 the generated file, see BUILT_SOURCES in Makefile.am */ +#include <cdp/cdp.api.h> diff --git a/src/plugins/cdp/cdp_input.c b/src/plugins/cdp/cdp_input.c new file mode 100644 index 00000000000..fa993b84def --- /dev/null +++ b/src/plugins/cdp/cdp_input.c @@ -0,0 +1,504 @@ +/* + * Copyright (c) 2011-2016 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 <cdp/cdp.h> + +cdp_main_t cdp_main; + +#define DEBUG_TLV_DUMP 0 /* 1=> dump TLV's to stdout while processing them */ + +/* + * ported from an unspecified Cisco cdp implementation. + * Compute / return in HOST byte order. 0 => good checksum. + */ +u16 +cdp_checksum (void *p, int count) +{ + u32 sum; + u16 i, *data; + + data = p; + sum = 0; + while (count > 1) + { + sum += ntohs (*data); + data++; + count -= 2; + } + + if (count > 0) + sum += *(char *) data; + + while (sum >> 16) + { + sum = (sum & 0xFFFF) + (sum >> 16); + } + + i = (i16) sum; + return (~i); +} + +/* TLV handler table */ +typedef struct +{ + char *name; + u32 tlv_id; + void *format; + void *process; +} tlv_handler_t; + +static tlv_handler_t tlv_handlers[]; + +/* Display a generic TLV as a set of hex bytes */ +static u8 * +format_generic_tlv (u8 * s, va_list * va) +{ + cdp_tlv_t *t = va_arg (*va, cdp_tlv_t *); + tlv_handler_t *h = &tlv_handlers[t->t]; + + s = format (s, "%s(%d): %U\n", h->name, + t->t, format_hex_bytes, t->v, t->l - sizeof (*t)); + return s; +} + +/* Ignore / skip a TLV we don't support */ +static cdp_error_t +process_generic_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t) +{ +#if DEBUG_TLV_DUMP > 0 + fformat (stdout, "%U", format_generic_tlv, t); +#endif + + return CDP_ERROR_NONE; +} + +/* print a text tlv */ +static u8 * +format_text_tlv (u8 * s, va_list * va) +{ + cdp_tlv_t *t = va_arg (*va, cdp_tlv_t *); + tlv_handler_t *h = &tlv_handlers[t->t]; + int i; + + s = format (s, "%s(%d): ", h->name, t->t); + + for (i = 0; i < (t->l - sizeof (*t)); i++) + vec_add1 (s, t->v[i]); + + vec_add1 (s, '\n'); + return s; +} + +#if DEBUG_TLV_DUMP == 0 +/* gcc warning be gone */ +CLIB_UNUSED (static cdp_error_t + process_text_tlv (cdp_main_t * cm, cdp_neighbor_t * n, + cdp_tlv_t * t)); +#endif + +/* process / skip a generic text TLV that we don't support */ +static cdp_error_t +process_text_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t) +{ +#if DEBUG_TLV_DUMP > 0 + fformat (stdout, "%U\n", format_text_tlv, t); +#endif + + return CDP_ERROR_NONE; +} + +/* per-TLV format function definitions */ +#define format_unused_tlv format_generic_tlv +#define format_device_name_tlv format_text_tlv +#define format_address_tlv format_generic_tlv +#define format_port_id_tlv format_text_tlv +#define format_capabilities_tlv format_generic_tlv +#define format_version_tlv format_text_tlv +#define format_platform_tlv format_text_tlv +#define format_ipprefix_tlv format_generic_tlv +#define format_hello_tlv format_generic_tlv +#define format_vtp_domain_tlv format_generic_tlv +#define format_native_vlan_tlv format_generic_tlv +#define format_duplex_tlv format_generic_tlv +#define format_appl_vlan_tlv format_generic_tlv +#define format_trigger_tlv format_generic_tlv +#define format_power_tlv format_generic_tlv +#define format_mtu_tlv format_generic_tlv +#define format_trust_tlv format_generic_tlv +#define format_cos_tlv format_generic_tlv +#define format_sysname_tlv format_generic_tlv +#define format_sysobject_tlv format_generic_tlv +#define format_mgmt_addr_tlv format_generic_tlv +#define format_physical_loc_tlv format_generic_tlv +#define format_mgmt_addr2_tlv format_generic_tlv +#define format_power_requested_tlv format_generic_tlv +#define format_power_available_tlv format_generic_tlv +#define format_port_unidirectional_tlv format_generic_tlv +#define format_unknown_28_tlv format_generic_tlv +#define format_energywise_tlv format_generic_tlv +#define format_unknown_30_tlv format_generic_tlv +#define format_spare_poe_tlv format_generic_tlv + +/* tlv ID=0 is a mistake */ +static cdp_error_t +process_unused_tlv (cdp_main_t * cm, cdp_neighbor_t * n, cdp_tlv_t * t) +{ + return CDP_ERROR_BAD_TLV; +} + +/* list of text TLV's that we snapshoot */ +#define foreach_text_to_struct_tlv \ +_(device_name,DEBUG_TLV_DUMP) \ +_(version,DEBUG_TLV_DUMP) \ +_(platform,DEBUG_TLV_DUMP) \ +_(port_id,DEBUG_TLV_DUMP) + +#define _(z,dbg) \ +static \ +cdp_error_t process_##z##_tlv (cdp_main_t *cm, cdp_neighbor_t *n, \ + cdp_tlv_t *t) \ +{ \ + int i; \ + if (dbg) \ + fformat(stdout, "%U\n", format_text_tlv, t); \ + \ + if (n->z) \ + _vec_len(n->z) = 0; \ + \ + for (i = 0; i < (t->l - sizeof (*t)); i++) \ + vec_add1(n->z, t->v[i]); \ + \ + vec_add1(n->z, 0); \ + \ + return CDP_ERROR_NONE; \ +} + +foreach_text_to_struct_tlv +#undef _ +#define process_address_tlv process_generic_tlv +#define process_capabilities_tlv process_generic_tlv +#define process_ipprefix_tlv process_generic_tlv +#define process_hello_tlv process_generic_tlv +#define process_vtp_domain_tlv process_generic_tlv +#define process_native_vlan_tlv process_generic_tlv +#define process_duplex_tlv process_generic_tlv +#define process_appl_vlan_tlv process_generic_tlv +#define process_trigger_tlv process_generic_tlv +#define process_power_tlv process_generic_tlv +#define process_mtu_tlv process_generic_tlv +#define process_trust_tlv process_generic_tlv +#define process_cos_tlv process_generic_tlv +#define process_sysname_tlv process_generic_tlv +#define process_sysobject_tlv process_generic_tlv +#define process_mgmt_addr_tlv process_generic_tlv +#define process_physical_loc_tlv process_generic_tlv +#define process_mgmt_addr2_tlv process_generic_tlv +#define process_power_requested_tlv process_generic_tlv +#define process_power_available_tlv process_generic_tlv +#define process_port_unidirectional_tlv process_generic_tlv +#define process_unknown_28_tlv process_generic_tlv +#define process_energywise_tlv process_generic_tlv +#define process_unknown_30_tlv process_generic_tlv +#define process_spare_poe_tlv process_generic_tlv +static tlv_handler_t tlv_handlers[] = { +#define _(a) {#a, CDP_TLV_##a, format_##a##_tlv, process_##a##_tlv}, + foreach_cdp_tlv_type +#undef _ +}; + +#if DEBUG_TLV_DUMP == 0 +CLIB_UNUSED (static u8 * format_cdp_hdr (u8 * s, va_list * va)); +#endif + +static u8 * +format_cdp_hdr (u8 * s, va_list * va) +{ + cdp_hdr_t *h = va_arg (*va, cdp_hdr_t *); + + s = format (s, "version %d, ttl %d(secs), cksum 0x%04x\n", + h->version, h->ttl, h->checksum); + return s; +} + +static cdp_error_t +process_cdp_hdr (cdp_main_t * cm, cdp_neighbor_t * n, cdp_hdr_t * h) +{ +#if DEBUG_TLV_DUMP > 0 + fformat (stdout, "%U", format_cdp_hdr, h); +#endif + + if (h->version != 1 && h->version != 2) + return CDP_ERROR_PROTOCOL_VERSION; + + n->ttl_in_seconds = h->ttl; + + return CDP_ERROR_NONE; +} + +/* scan a cdp packet; header, then tlv's */ +static int +cdp_packet_scan (cdp_main_t * cm, cdp_neighbor_t * n) +{ + u8 *cur = n->last_rx_pkt; + cdp_hdr_t *h; + cdp_tlv_t *tlv; + cdp_error_t e = CDP_ERROR_NONE; + tlv_handler_t *handler; + cdp_error_t (*fp) (cdp_main_t *, cdp_neighbor_t *, cdp_tlv_t *); + u16 computed_checksum; + + computed_checksum = cdp_checksum (cur, vec_len (cur)); + + if (computed_checksum) + return CDP_ERROR_CHECKSUM; + + h = (cdp_hdr_t *) cur; + + e = process_cdp_hdr (cm, n, h); + if (e) + return e; + + cur = (u8 *) (h + 1); + + while (cur < n->last_rx_pkt + vec_len (n->last_rx_pkt) - 1) + { + tlv = (cdp_tlv_t *) cur; + tlv->t = ntohs (tlv->t); + tlv->l = ntohs (tlv->l); + if (tlv->t >= ARRAY_LEN (tlv_handlers)) + return CDP_ERROR_BAD_TLV; + handler = &tlv_handlers[tlv->t]; + fp = handler->process; + e = (*fp) (cm, n, tlv); + if (e) + return e; + /* tlv length includes (t, l) */ + cur += tlv->l; + } + + return CDP_ERROR_NONE; +} + +/* + * cdp input routine + */ +cdp_error_t +cdp_input (vlib_main_t * vm, vlib_buffer_t * b0, u32 bi0) +{ + cdp_main_t *cm = &cdp_main; + cdp_neighbor_t *n; + uword *p, nbytes; + cdp_error_t e; + uword last_packet_signature; + + /* find or create a neighbor pool entry for the (sw) interface + upon which we received this pkt */ + p = hash_get (cm->neighbor_by_sw_if_index, + vnet_buffer (b0)->sw_if_index[VLIB_RX]); + + if (p == 0) + { + pool_get (cm->neighbors, n); + memset (n, 0, sizeof (*n)); + n->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + n->packet_template_index = (u8) ~ 0; + hash_set (cm->neighbor_by_sw_if_index, n->sw_if_index, + n - cm->neighbors); + } + else + { + n = pool_elt_at_index (cm->neighbors, p[0]); + } + + /* + * typical clib idiom. Don't repeatedly allocate and free + * the per-neighbor rx buffer. Reset its apparent length to zero + * and reuse it. + */ + + if (n->last_rx_pkt) + _vec_len (n->last_rx_pkt) = 0; + + /* cdp disabled on this interface, we're done */ + if (n->disabled) + return CDP_ERROR_DISABLED; + + /* + * Make sure the per-neighbor rx buffer is big enough to hold + * the data we're about to copy + */ + vec_validate (n->last_rx_pkt, vlib_buffer_length_in_chain (vm, b0) - 1); + + /* + * Coalesce / copy e the buffer chain into the per-neighbor + * rx buffer + */ + nbytes = vlib_buffer_contents (vm, bi0, n->last_rx_pkt); + ASSERT (nbytes <= vec_len (n->last_rx_pkt)); + + /* + * Compute Jenkins hash of the new packet, decide if we need to + * actually parse through the TLV's. CDP packets are all identical, + * so unless we time out the peer, we don't need to process the packet. + */ + last_packet_signature = + hash_memory (n->last_rx_pkt, vec_len (n->last_rx_pkt), 0xd00b); + + if (n->last_packet_signature_valid && + n->last_packet_signature == last_packet_signature) + { + e = CDP_ERROR_CACHE_HIT; + } + else + { + /* Actually scan the packet */ + e = cdp_packet_scan (cm, n); + n->last_packet_signature_valid = 1; + n->last_packet_signature = last_packet_signature; + } + + if (e == CDP_ERROR_NONE) + { + n->last_heard = vlib_time_now (vm); + } + + return e; +} + +/* + * setup neighbor hash table + */ +static clib_error_t * +cdp_input_init (vlib_main_t * vm) +{ + clib_error_t *error; + cdp_main_t *cm = &cdp_main; + void vnet_cdp_node_reference (void); + + vnet_cdp_node_reference (); + + if ((error = vlib_call_init_function (vm, cdp_periodic_init))) + return error; + + cm->vlib_main = vm; + cm->vnet_main = vnet_get_main (); + cm->neighbor_by_sw_if_index = hash_create (0, sizeof (uword)); + + return 0; +} + +VLIB_INIT_FUNCTION (cdp_input_init); + + +static u8 * +format_cdp_neighbors (u8 * s, va_list * va) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *); + cdp_main_t *cm = va_arg (*va, cdp_main_t *); + vnet_main_t *vnm = &vnet_main; + cdp_neighbor_t *n; + vnet_hw_interface_t *hw; + + s = format (s, + "%=25s %=15s %=25s %=10s\n", + "Our Port", "Peer System", "Peer Port", "Last Heard"); + + /* *INDENT-OFF* */ + pool_foreach (n, cm->neighbors, + ({ + hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index); + + if (n->disabled == 0) + s = format (s, "%=25s %=15s %=25s %=10.1f\n", + hw->name, n->device_name, n->port_id, + n->last_heard); + })); + /* *INDENT-ON* */ + return s; +} + +static clib_error_t * +show_cdp (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + cdp_main_t *cm = &cdp_main; + + if (cm->enabled == 0) + vlib_cli_output (vm, "CDP is not enabled..."); + else + vlib_cli_output (vm, "%U\n", format_cdp_neighbors, vm, cm); + + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_cdp_command, static) = { + .path = "show cdp", + .short_help = "Show cdp command", + .function = show_cdp, +}; +/* *INDENT-ON* */ + + +/* + * packet trace format function, very similar to + * cdp_packet_scan except that we call the per TLV format + * functions instead of the per TLV processing functions + */ +u8 * +cdp_input_format_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + cdp_input_trace_t *t = va_arg (*args, cdp_input_trace_t *); + u8 *cur; + cdp_hdr_t *h; + cdp_tlv_t *tlv; + tlv_handler_t *handler; + u8 *(*fp) (cdp_tlv_t *); + + cur = t->data; + + h = (cdp_hdr_t *) cur; + s = format (s, "%U", format_cdp_hdr, h); + + cur = (u8 *) (h + 1); + + while (cur < t->data + t->len) + { + tlv = (cdp_tlv_t *) cur; + tlv->t = ntohs (tlv->t); + tlv->l = ntohs (tlv->l); + if (tlv->t >= ARRAY_LEN (tlv_handlers)) + { + s = format (s, "BAD_TLV\n"); + break; + } + handler = &tlv_handlers[tlv->t]; + fp = handler->format; + s = format (s, " %U", fp, tlv); + /* tlv length includes (t, l) */ + cur += tlv->l; + } + + return s; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp_msg_enum.h b/src/plugins/cdp/cdp_msg_enum.h new file mode 100644 index 00000000000..0a7bf063b67 --- /dev/null +++ b/src/plugins/cdp/cdp_msg_enum.h @@ -0,0 +1,31 @@ + +/* + * cdp_msg_enum.h - cdp plug-in message enumeration + * + * Copyright (c) 2011-2018 by 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. + */ +#ifndef included_cdp_msg_enum_h +#define included_cdp_msg_enum_h + +#include <vppinfra/byte_order.h> + +#define vl_msg_id(n,h) n, +typedef enum { +#include <cdp/cdp_all_api_h.h> + /* We'll want to know how many messages IDs we need... */ + VL_MSG_FIRST_AVAILABLE, +} vl_msg_id_t; +#undef vl_msg_id + +#endif /* included_cdp_msg_enum_h */ diff --git a/src/plugins/cdp/cdp_node.c b/src/plugins/cdp/cdp_node.c new file mode 100644 index 00000000000..1336c567287 --- /dev/null +++ b/src/plugins/cdp/cdp_node.c @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2011-2018 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 <cdp/cdp.h> +#include <vnet/ethernet/packet.h> + +/** \file + + 2 x CDP graph nodes: an "interior" node to process + incoming announcements, and a "process" node to periodically + send announcements. + + The interior node is neither pipelined nor dual-looped, because + it would be very unusual to see more than one CDP packet in + a given input frame. So, it's a very simple / straighforward + example. +*/ + +/* + * packet counter strings + * Dump these counters via the "show error" CLI command + */ +static char *cdp_error_strings[] = { +#define _(sym,string) string, + foreach_cdp_error +#undef _ +}; + +/* + * We actually send all cdp pkts to the "error" node after scanning + * them, so the graph node has only one next-index. The "error-drop" + * node automatically bumps our per-node packet counters for us. + */ +typedef enum +{ + CDP_INPUT_NEXT_NORMAL, + CDP_INPUT_N_NEXT, +} cdp_next_t; + +/* + * Process a frame of cdp packets + * Expect 1 packet / frame + */ +static uword +cdp_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) +{ + u32 n_left_from, *from; + cdp_input_trace_t *t0; + + from = vlib_frame_vector_args (frame); /* array of buffer indices */ + n_left_from = frame->n_vectors; /* number of buffer indices */ + + while (n_left_from > 0) + { + u32 bi0; + vlib_buffer_t *b0; + u32 next0, error0; + + bi0 = from[0]; + b0 = vlib_get_buffer (vm, bi0); + + next0 = CDP_INPUT_NEXT_NORMAL; + + /* scan this cdp pkt. error0 is the counter index to bump */ + error0 = cdp_input (vm, b0, bi0); + b0->error = node->errors[error0]; + + /* If this pkt is traced, snapshoot the data */ + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + int len; + t0 = vlib_add_trace (vm, node, b0, sizeof (*t0)); + len = (b0->current_length < sizeof (t0->data)) + ? b0->current_length : sizeof (t0->data); + t0->len = len; + clib_memcpy (t0->data, vlib_buffer_get_current (b0), len); + } + /* push this pkt to the next graph node, always error-drop */ + vlib_set_next_frame_buffer (vm, node, next0, bi0); + + from += 1; + n_left_from -= 1; + } + + return frame->n_vectors; +} + +/* + * cdp input graph node declaration + */ +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (cdp_input_node, static) = { + .function = cdp_node_fn, + .name = "cdp-input", + .vector_size = sizeof (u32), + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = CDP_N_ERROR, + .error_strings = cdp_error_strings, + + .format_trace = cdp_input_format_trace, + + .n_next_nodes = CDP_INPUT_N_NEXT, + .next_nodes = { + [CDP_INPUT_NEXT_NORMAL] = "error-drop", + }, +}; +/* *INDENT-ON* */ + +/* + * cdp periodic function + */ +static uword +cdp_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f) +{ + cdp_main_t *cm = &cdp_main; + f64 poll_time_remaining; + uword event_type, *event_data = 0; + + /* So we can send events to the cdp process */ + cm->cdp_process_node_index = cdp_process_node.index; + + /* Dynamically register the cdp input node with the snap classifier */ + snap_register_input_protocol (vm, "cdp-input", 0xC /* ieee_oui, Cisco */ , + 0x2000 /* protocol CDP */ , + cdp_input_node.index); + + snap_register_input_protocol (vm, "cdp-input", 0xC /* ieee_oui, Cisco */ , + 0x2004 /* protocol CDP */ , + cdp_input_node.index); + +#if 0 /* retain for reference */ + /* with the hdlc classifier */ + hdlc_register_input_protocol (vm, HDLC_PROTOCOL_cdp, cdp_input_node.index); +#endif + + /* with ethernet input (for SRP) */ + ethernet_register_input_type (vm, ETHERNET_TYPE_CDP /* CDP */ , + cdp_input_node.index); + + /* Start w/ cdp effectively disabled */ + poll_time_remaining = 86400.0; + + while (1) + { + /* sleep until next poll time, or msg serialize event occurs */ + poll_time_remaining = + vlib_process_wait_for_event_or_clock (vm, poll_time_remaining); + + event_type = vlib_process_get_events (vm, &event_data); + switch (event_type) + { + case ~0: /* no events => timeout */ + break; + + case CDP_EVENT_ENABLE: + poll_time_remaining = 10.0; + break; + + case CDP_EVENT_DISABLE: + poll_time_remaining = 86400.0; + break; + + default: + clib_warning ("BUG: event type 0x%wx", event_type); + break; + } + vec_reset_length (event_data); + + /* peer timeout scan, send announcements */ + if (vlib_process_suspend_time_is_zero (poll_time_remaining)) + { + cdp_periodic (vm); + poll_time_remaining = 10.0; + } + } + + return 0; +} + +/* + * cdp periodic node declaration + */ +/* *INDENT-OFF* */ +VLIB_REGISTER_NODE (cdp_process_node) = { + .function = cdp_process, + .type = VLIB_NODE_TYPE_PROCESS, + .name = "cdp-process", +}; +/* *INDENT-ON* */ + +void +vnet_cdp_node_reference (void) +{ +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp_periodic.c b/src/plugins/cdp/cdp_periodic.c new file mode 100644 index 00000000000..c67af00c7a5 --- /dev/null +++ b/src/plugins/cdp/cdp_periodic.c @@ -0,0 +1,515 @@ +/* + * Copyright (c) 2011-2018 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 <cdp/cdp.h> +#include <vppinfra/hash.h> +#include <vnet/unix/pcap.h> +#include <vnet/srp/srp.h> +#include <vnet/ppp/ppp.h> +#include <vnet/hdlc/hdlc.h> +#include <vnet/srp/packet.h> + +/* + * Generate a set of specific CDP TLVs. + * + * $$$ eventually these need to fish better data from + * other data structures; e.g. the hostname, software version info + * etc. + */ + +static void +add_device_name_tlv (vnet_hw_interface_t * hw, u8 ** t0p) +{ + cdp_tlv_t *t = (cdp_tlv_t *) * t0p; + + t->t = htons (CDP_TLV_device_name); + t->l = htons (3 + sizeof (*t)); + clib_memcpy (&t->v, "VPP", 3); + + *t0p += ntohs (t->l); +} + +static void +add_port_id_tlv (vnet_hw_interface_t * hw, u8 ** t0p) +{ + cdp_tlv_t *t = (cdp_tlv_t *) * t0p; + + t->t = htons (CDP_TLV_port_id); + t->l = htons (vec_len (hw->name) + sizeof (*t)); + clib_memcpy (&t->v, hw->name, vec_len (hw->name)); + *t0p += ntohs (t->l); +} + +static void +add_version_tlv (vnet_hw_interface_t * hw, u8 ** t0p) +{ + cdp_tlv_t *t = (cdp_tlv_t *) * t0p; + + t->t = htons (CDP_TLV_version); + t->l = htons (12 + sizeof (*t)); + clib_memcpy (&t->v, "VPP Software", 12); + *t0p += ntohs (t->l); +} + +static void +add_platform_tlv (vnet_hw_interface_t * hw, u8 ** t0p) +{ + cdp_tlv_t *t = (cdp_tlv_t *) * t0p; + + t->t = htons (CDP_TLV_platform); + t->l = htons (2 + sizeof (*t)); + clib_memcpy (&t->v, "SW", 2); + *t0p += ntohs (t->l); +} + +static void +add_capability_tlv (vnet_hw_interface_t * hw, u8 ** t0p) +{ + cdp_tlv_t *t = (cdp_tlv_t *) * t0p; + u32 capabilities; + + t->t = htons (CDP_TLV_capabilities); + t->l = htons (4 + sizeof (*t)); + capabilities = CDP_ROUTER_DEVICE; + capabilities = htonl (capabilities); + clib_memcpy (&t->v, &capabilities, sizeof (capabilities)); + *t0p += ntohs (t->l); +} + +static void +add_tlvs (cdp_main_t * cm, vnet_hw_interface_t * hw, u8 ** t0p) +{ + add_device_name_tlv (hw, t0p); + add_port_id_tlv (hw, t0p); + add_version_tlv (hw, t0p); + add_platform_tlv (hw, t0p); + add_capability_tlv (hw, t0p); +} + +/* + * send a cdp pkt on an ethernet interface + */ +static void +send_ethernet_hello (cdp_main_t * cm, cdp_neighbor_t * n, int count) +{ + u32 *to_next; + ethernet_llc_snap_and_cdp_header_t *h0; + vnet_hw_interface_t *hw; + u32 bi0; + vlib_buffer_t *b0; + u8 *t0; + u16 checksum; + int nbytes_to_checksum; + int i; + vlib_frame_t *f; + vlib_main_t *vm = cm->vlib_main; + vnet_main_t *vnm = cm->vnet_main; + + for (i = 0; i < count; i++) + { + /* + * see cdp_periodic_init() to understand what's already painted + * into the buffer by the packet template mechanism + */ + h0 = vlib_packet_template_get_packet + (vm, &cm->packet_templates[n->packet_template_index], &bi0); + + if (!h0) + break; + + /* Add the interface's ethernet source address */ + hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index); + + clib_memcpy (h0->ethernet.src_address, hw->hw_address, + vec_len (hw->hw_address)); + + t0 = (u8 *) & h0->cdp.data; + + /* add TLVs */ + add_tlvs (cm, hw, &t0); + + /* add the cdp packet checksum */ + nbytes_to_checksum = t0 - (u8 *) & h0->cdp; + checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum); + h0->cdp.checksum = htons (checksum); + + /* Set the outbound packet length */ + b0 = vlib_get_buffer (vm, bi0); + b0->current_length = nbytes_to_checksum + sizeof (*h0) + - sizeof (cdp_hdr_t); + + /* And the outbound interface */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = hw->sw_if_index; + + /* Set the 802.3 ethernet length */ + h0->ethernet.len = htons (b0->current_length + - sizeof (ethernet_802_3_header_t)); + + /* And output the packet on the correct interface */ + f = vlib_get_frame_to_node (vm, hw->output_node_index); + to_next = vlib_frame_vector_args (f); + to_next[0] = bi0; + f->n_vectors = 1; + + vlib_put_frame_to_node (vm, hw->output_node_index, f); + n->last_sent = vlib_time_now (vm); + } +} + +/* + * send a cdp pkt on an hdlc interface + */ +static void +send_hdlc_hello (cdp_main_t * cm, cdp_neighbor_t * n, int count) +{ + u32 *to_next; + hdlc_and_cdp_header_t *h0; + vnet_hw_interface_t *hw; + u32 bi0; + vlib_buffer_t *b0; + u8 *t0; + u16 checksum; + int nbytes_to_checksum; + int i; + vlib_frame_t *f; + vlib_main_t *vm = cm->vlib_main; + vnet_main_t *vnm = cm->vnet_main; + + for (i = 0; i < count; i++) + { + /* + * see cdp_periodic_init() to understand what's already painted + * into the buffer by the packet template mechanism + */ + h0 = vlib_packet_template_get_packet + (vm, &cm->packet_templates[n->packet_template_index], &bi0); + + hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index); + + t0 = (u8 *) & h0->cdp.data; + + /* add TLVs */ + add_tlvs (cm, hw, &t0); + + /* add the cdp packet checksum */ + nbytes_to_checksum = t0 - (u8 *) & h0->cdp; + checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum); + h0->cdp.checksum = htons (checksum); + + /* Set the outbound packet length */ + b0 = vlib_get_buffer (vm, bi0); + b0->current_length = nbytes_to_checksum + sizeof (*h0) + - sizeof (cdp_hdr_t); + + /* And output the packet on the correct interface */ + f = vlib_get_frame_to_node (vm, hw->output_node_index); + to_next = vlib_frame_vector_args (f); + to_next[0] = bi0; + f->n_vectors = 1; + + vlib_put_frame_to_node (vm, hw->output_node_index, f); + n->last_sent = vlib_time_now (vm); + } +} + +/* + * send a cdp pkt on an srp interface + */ +static void +send_srp_hello (cdp_main_t * cm, cdp_neighbor_t * n, int count) +{ + u32 *to_next; + srp_and_cdp_header_t *h0; + vnet_hw_interface_t *hw; + u32 bi0; + vlib_buffer_t *b0; + u8 *t0; + u16 checksum; + int nbytes_to_checksum; + int i; + vlib_frame_t *f; + vlib_main_t *vm = cm->vlib_main; + vnet_main_t *vnm = cm->vnet_main; + + for (i = 0; i < count; i++) + { + /* + * see cdp_periodic_init() to understand what's already painted + * into the buffer by the packet template mechanism + */ + h0 = vlib_packet_template_get_packet + (vm, &cm->packet_templates[n->packet_template_index], &bi0); + + hw = vnet_get_sup_hw_interface (vnm, n->sw_if_index); + + t0 = (u8 *) & h0->cdp.data; + + /* add TLVs */ + add_tlvs (cm, hw, &t0); + + /* Add the interface's ethernet source address */ + clib_memcpy (h0->ethernet.src_address, hw->hw_address, + vec_len (hw->hw_address)); + + /* add the cdp packet checksum */ + nbytes_to_checksum = t0 - (u8 *) & h0->cdp; + checksum = cdp_checksum (&h0->cdp, nbytes_to_checksum); + h0->cdp.checksum = htons (checksum); + + /* Set the outbound packet length */ + b0 = vlib_get_buffer (vm, bi0); + b0->current_length = nbytes_to_checksum + sizeof (*h0) + - sizeof (cdp_hdr_t); + + /* And output the packet on the correct interface */ + f = vlib_get_frame_to_node (vm, hw->output_node_index); + to_next = vlib_frame_vector_args (f); + to_next[0] = bi0; + f->n_vectors = 1; + + vlib_put_frame_to_node (vm, hw->output_node_index, f); + n->last_sent = vlib_time_now (vm); + } +} + +/* + * Decide which cdp packet template to use + */ +static int +pick_packet_template (cdp_main_t * cm, cdp_neighbor_t * n) +{ + n->packet_template_index = CDP_PACKET_TEMPLATE_ETHERNET; + + return 0; +} + +/* Send a cdp neighbor announcement */ +static void +send_hello (cdp_main_t * cm, cdp_neighbor_t * n, int count) +{ + if (n->packet_template_index == (u8) ~ 0) + { + /* If we don't know how to talk to this peer, don't try again */ + if (pick_packet_template (cm, n)) + { + n->last_sent = 1e70; + return; + } + } + + switch (n->packet_template_index) + { + case CDP_PACKET_TEMPLATE_ETHERNET: + send_ethernet_hello (cm, n, count); + break; + + case CDP_PACKET_TEMPLATE_HDLC: + send_hdlc_hello (cm, n, count); + break; + + case CDP_PACKET_TEMPLATE_SRP: + send_srp_hello (cm, n, count); + break; + + default: + ASSERT (0); + } + n->last_sent = vlib_time_now (cm->vlib_main); +} + +static void +delete_neighbor (cdp_main_t * cm, cdp_neighbor_t * n, int want_broadcast) +{ + hash_unset (cm->neighbor_by_sw_if_index, n->sw_if_index); + vec_free (n->device_name); + vec_free (n->version); + vec_free (n->port_id); + vec_free (n->platform); + vec_free (n->last_rx_pkt); + pool_put (cm->neighbors, n); +} + +void +cdp_periodic (vlib_main_t * vm) +{ + cdp_main_t *cm = &cdp_main; + cdp_neighbor_t *n; + f64 now = vlib_time_now (vm); + vnet_sw_interface_t *sw; + static u32 *delete_list = 0; + int i; + static cdp_neighbor_t **n_list = 0; + + /* *INDENT-OFF* */ + pool_foreach (n, cm->neighbors, + ({ + vec_add1 (n_list, n); + })); + /* *INDENT-ON* */ + + /* Across all cdp neighbors known to the system */ + for (i = 0; i < vec_len (n_list); i++) + { + n = n_list[i]; + + /* "no cdp run" provisioned on the interface? */ + if (n->disabled == 1) + continue; + + sw = vnet_get_sw_interface (cm->vnet_main, n->sw_if_index); + + /* Interface shutdown or rx timeout? */ + if (!(sw->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) + || (now > (n->last_heard + (f64) n->ttl_in_seconds))) + /* add to list of neighbors to delete */ + vec_add1 (delete_list, n - cm->neighbors); + else if (n->last_sent == 0.0) + /* First time, send 3 hellos */ + send_hello (cm, n, 3 /* three to begin with */ ); + else if (now > (n->last_sent + (((f64) n->ttl_in_seconds) / 6.0))) + /* Normal keepalive, send one */ + send_hello (cm, n, 1 /* one as a keepalive */ ); + } + + for (i = 0; i < vec_len (delete_list); i++) + { + n = vec_elt_at_index (cm->neighbors, delete_list[i]); + delete_neighbor (cm, n, 1); + } + if (delete_list) + _vec_len (delete_list) = 0; + if (n_list) + _vec_len (n_list) = 0; +} + +static clib_error_t * +cdp_periodic_init (vlib_main_t * vm) +{ + cdp_main_t *cm = &cdp_main; + + /* Create the ethernet cdp hello packet template */ + { + ethernet_llc_snap_and_cdp_header_t h; + + memset (&h, 0, sizeof (h)); + + /* Send to 01:00:0c:cc:cc */ + h.ethernet.dst_address[0] = 0x01; + /* h.ethernet.dst_address[1] = 0x00; (memset) */ + h.ethernet.dst_address[2] = 0x0C; + h.ethernet.dst_address[3] = 0xCC; + h.ethernet.dst_address[4] = 0xCC; + h.ethernet.dst_address[5] = 0xCC; + + /* leave src address blank (fill in at send time) */ + + /* leave length blank (fill in at send time) */ + + /* LLC */ + h.llc.dst_sap = h.llc.src_sap = 0xAA; /* SNAP */ + h.llc.control = 0x03; /* UI (no extended control bytes) */ + + /* SNAP */ + /* h.snap.oui[0] = 0x00; (memset) */ + /* h.snap.oui[1] = 0x00; (memset) */ + h.snap.oui[2] = 0x0C; /* Cisco = 0x00000C */ + h.snap.protocol = htons (0x2000); /* CDP = 0x2000 */ + + /* CDP */ + h.cdp.version = 2; + h.cdp.ttl = 180; + + vlib_packet_template_init + (vm, &cm->packet_templates[CDP_PACKET_TEMPLATE_ETHERNET], + /* data */ &h, + sizeof (h), + /* alloc chunk size */ 8, + "cdp-ethernet"); + } + +#if 0 /* retain for reference */ + + /* Create the hdlc cdp hello packet template */ + { + hdlc_and_cdp_header_t h; + + memset (&h, 0, sizeof (h)); + + h.hdlc.address = 0x0f; + /* h.hdlc.control = 0; (memset) */ + h.hdlc.protocol = htons (0x2000); /* CDP = 0x2000 */ + + /* CDP */ + h.cdp.version = 2; + h.cdp.ttl = 180; + + vlib_packet_template_init + (vm, &cm->packet_templates[CDP_PACKET_TEMPLATE_HDLC], + /* data */ &h, + sizeof (h), + /* alloc chunk size */ 8, + "cdp-hdlc"); + } + + /* Create the srp cdp hello packet template */ + { + srp_and_cdp_header_t h; + + memset (&h, 0, sizeof (h)); + + /* Send to 01:00:0c:cc:cc */ + h.ethernet.dst_address[0] = 0x01; + /* h.ethernet.dst_address[1] = 0x00; (memset) */ + h.ethernet.dst_address[2] = 0x0C; + h.ethernet.dst_address[3] = 0xCC; + h.ethernet.dst_address[4] = 0xCC; + h.ethernet.dst_address[5] = 0xCC; + + /* leave src address blank (fill in at send time) */ + + /* The srp header is filled in at xmt */ + h.srp.ttl = 1; + h.srp.priority = 7; + h.srp.mode = SRP_MODE_data; + srp_header_compute_parity (&h.srp); + + /* Inner ring and parity will be set at send time */ + + h.ethernet.type = htons (0x2000); /* CDP = 0x2000 */ + + /* CDP */ + h.cdp.version = 2; + h.cdp.ttl = 180; + + vlib_packet_template_init + (vm, &cm->packet_templates[CDP_PACKET_TEMPLATE_SRP], + /* data */ &h, + sizeof (h), + /* alloc chunk size */ 8, + "cdp-srp"); + } +#endif + + return 0; +} + +VLIB_INIT_FUNCTION (cdp_periodic_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp_protocol.h b/src/plugins/cdp/cdp_protocol.h new file mode 100644 index 00000000000..46a5603aa70 --- /dev/null +++ b/src/plugins/cdp/cdp_protocol.h @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2011-2018 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. + */ +#ifndef __included_cdp_protocol_h__ +#define __included_cdp_protocol_h__ + +#include <vnet/ethernet/ethernet.h> /* for ethernet_header_t */ +#include <vnet/llc/llc.h> +#include <vnet/snap/snap.h> +#include <vnet/srp/packet.h> + +typedef CLIB_PACKED (struct + { + u8 version; + u8 ttl; + u16 checksum; /* 1's complement of the 1's complement sum */ + u8 data[0]; + }) cdp_hdr_t; + +typedef struct +{ + u8 dst_address[6]; + u8 src_address[6]; + u16 len; +} ethernet_802_3_header_t; + +typedef CLIB_PACKED (struct + { + ethernet_802_3_header_t ethernet; + llc_header_t llc; snap_header_t snap; cdp_hdr_t cdp; + }) ethernet_llc_snap_and_cdp_header_t; + +typedef CLIB_PACKED (struct + { + hdlc_header_t hdlc; cdp_hdr_t cdp; + }) hdlc_and_cdp_header_t; + +typedef CLIB_PACKED (struct + { + srp_header_t srp; + ethernet_header_t ethernet; cdp_hdr_t cdp; + }) srp_and_cdp_header_t; + +typedef CLIB_PACKED (struct + { + u16 t; + u16 l; + u8 v[0]; + }) cdp_tlv_t; + +/* + * TLV codes. + */ +#define foreach_cdp_tlv_type \ +_(unused) \ +_(device_name) /* uniquely identifies the device */ \ +_(address) /* list of addresses this device has */ \ +_(port_id) /* port CDP packet was sent out on */ \ +_(capabilities) /* funct. capabilities of the device */ \ +_(version) /* version */ \ +_(platform) /* hardware platform of this device */ \ +_(ipprefix) /* An IP network prefix */ \ +_(hello) /* Pprotocol piggyback hello msg */ \ +_(vtp_domain) /* VTP management domain */ \ +_(native_vlan) /* Native VLAN number */ \ +_(duplex) /* The interface duplex mode */ \ +_(appl_vlan) /* Appliance VLAN-ID TLV */ \ +_(trigger) /* For sending trigger TLV msgs. */ \ +_(power) /* Power consumption of that device */ \ +_(mtu) /* MTU defined for sending intf. */ \ +_(trust) /* Extended trust TLV */ \ +_(cos) /* COS for Untrusted Port TLV */ \ +_(sysname) /* System name (FQDN of device) */ \ +_(sysobject) /* OID of sysObjectID MIB object */ \ +_(mgmt_addr) /* SNMP manageable addrs. of device */ \ +_(physical_loc) /* Physical Location of the device */ \ +_(mgmt_addr2) /* External Port-ID */ \ +_(power_requested) \ +_(power_available) \ +_(port_unidirectional) \ +_(unknown_28) \ +_(energywise) \ +_(unknown_30) \ +_(spare_poe) + +typedef enum +{ +#define _(t) CDP_TLV_##t, + foreach_cdp_tlv_type +#undef _ +} cdp_tlv_code_t; + +/* + The address TLV looks as follows: + + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Number of addresses | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | IDRP encoded address | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + An address is encoded in IDRP format: + + 0 1 2 3 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | PT | PT Length | Protocol (variable) ... + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Address length | Address (variable) ... + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + + PT: Protocol type + 1 = NLPID format + 2 = 802.2 format + + PT Length: + Length of protocol field, 1 for PT = 1, and either 3 or 8 for + 802.2 format depending if SNAP is used for PT = 2. + + The encodings for the other protocols have the following format: + + field: <SSAP><DSAP><CTRL><-------OUI------><protocl_TYPE> + | | | | | | | | | + bytes: 0 1 2 3 4 5 6 7 8 + + where the first 3 bytes are 0xAAAA03 for SNAP encoded addresses. + The OUI is 000000 for ethernet and <protocl_TYPE> + is the assigned Ethernet type code for the particular protocol. + e.g. for DECnet the encoding is AAAA03 000000 6003. + for IPv6 the encoding is AAAA03 000000 86DD +*/ + +/* + * Capabilities. + */ + +#define CDP_ROUTER_DEVICE 0x0001 +#define CDP_TB_DEVICE 0x0002 +#define CDP_SRB_DEVICE 0x0004 +#define CDP_SWITCH_DEVICE 0x0008 +#define CDP_HOST_DEVICE 0x0010 +#define CDP_IGMP_DEVICE 0x0020 +#define CDP_REPEATER_DEVICE 0x0040 + +/* + The protocol-hello TLV looks as follows: + + 0 1 2 3 + 012345678901234567890123456789012345678 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Type | Length | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | OUI | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Protocol ID | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | up to 27 bytes of message | + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +*/ + +/* + * These macros define the valid values for the Duplex TLV. + */ +#define CDP_DUPLEX_TLV_HALF 0x0 +#define CDP_DUPLEX_TLV_FULL 0x1 + +#endif /* __included_cdp_protocol_h__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/plugins/cdp/cdp_test.c b/src/plugins/cdp/cdp_test.c new file mode 100644 index 00000000000..33b54498f7f --- /dev/null +++ b/src/plugins/cdp/cdp_test.c @@ -0,0 +1,179 @@ +/* + * cdp.c - vpp-api-test cdp protocol plug-in + * + * Copyright (c) 2011-2018 by 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 <vat/vat.h> +#include <vlibapi/api.h> +#include <vlibmemory/api.h> +#include <vppinfra/error.h> + +uword unformat_sw_if_index (unformat_input_t * input, va_list * args); + +/* Declare message IDs */ +#include <cdp/cdp_msg_enum.h> + +/* define message structures */ +#define vl_typedefs +#include <cdp/cdp_all_api_h.h> +#undef vl_typedefs + +/* declare message handlers for each api */ + +#define vl_endianfun /* define message structures */ +#include <cdp/cdp_all_api_h.h> +#undef vl_endianfun + +/* instantiate all the print functions we know about */ +#define vl_print(handle, ...) +#define vl_printfun +#include <cdp/cdp_all_api_h.h> +#undef vl_printfun + +/* Get the API version number. */ +#define vl_api_version(n,v) static u32 api_version=(v); +#include <cdp/cdp_all_api_h.h> +#undef vl_api_version + + +typedef struct +{ + /* API message ID base */ + u16 msg_id_base; + vat_main_t *vat_main; +} cdp_test_main_t; + +cdp_test_main_t cdp_test_main; + +#define __plugin_msg_base cdp_test_main.msg_id_base +#include <vlibapi/vat_helper_macros.h> + +#define foreach_standard_reply_retval_handler \ +_(cdp_enable_disable_reply) + +#define _(n) \ + static void vl_api_##n##_t_handler \ + (vl_api_##n##_t * mp) \ + { \ + vat_main_t * vam = cdp_test_main.vat_main; \ + i32 retval = ntohl(mp->retval); \ + if (vam->async_mode) { \ + vam->async_errors += (retval < 0); \ + } else { \ + vam->retval = retval; \ + vam->result_ready = 1; \ + } \ + } +foreach_standard_reply_retval_handler; +#undef _ + +/* + * Table of message reply handlers, must include boilerplate handlers + * we just generated + */ +#define foreach_vpe_api_reply_msg \ +_(CDP_ENABLE_DISABLE_REPLY, cdp_enable_disable_reply) + +static int +api_cdp_enable_disable (vat_main_t * vam) +{ + unformat_input_t *i = vam->input; + int enable_disable = 1; + vl_api_cdp_enable_disable_t *mp; + int ret; + + /* Parse args required to build the message */ + while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) + { + if (unformat (i, "disable")) + enable_disable = 0; + else if (unformat (i, "enable")) + enable_disable = 1; + else + break; + } + + /* Construct the API message */ + M (CDP_ENABLE_DISABLE, mp); + mp->enable_disable = enable_disable; + + /* send it... */ + S (mp); + + /* Wait for a reply... */ + W (ret); + return ret; +} + +/* + * List of messages that the api test plugin sends, + * and that the data plane plugin processes + */ +#define foreach_vpe_api_msg \ +_(cdp_enable_disable, "enable | disable") + +static void +cdp_api_hookup (vat_main_t * vam) +{ + cdp_test_main_t *sm = &cdp_test_main; + /* Hook up handlers for replies from the data plane plug-in */ +#define _(N,n) \ + vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base), \ + #n, \ + vl_api_##n##_t_handler, \ + vl_noop_handler, \ + vl_api_##n##_t_endian, \ + vl_api_##n##_t_print, \ + sizeof(vl_api_##n##_t), 1); + foreach_vpe_api_reply_msg; +#undef _ + + /* API messages we can send */ +#define _(n,h) hash_set_mem (vam->function_by_name, #n, api_##n); + foreach_vpe_api_msg; +#undef _ + + /* Help strings */ +#define _(n,h) hash_set_mem (vam->help_by_name, #n, h); + foreach_vpe_api_msg; +#undef _ +} + +clib_error_t * +vat_plugin_register (vat_main_t * vam) +{ + cdp_test_main_t *sm = &cdp_test_main; + u8 *name; + + sm->vat_main = vam; + + /* Ask the vpp engine for the first assigned message-id */ + name = format (0, "cdp_%08x%c", api_version, 0); + sm->msg_id_base = vl_client_get_first_plugin_msg_id ((char *) name); + + if (sm->msg_id_base != (u16) ~ 0) + cdp_api_hookup (vam); + + vec_free (name); + + return 0; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |