Line data    Source code

       1             : /*
       2             :  * Copyright 2019-2020 Rubicon Communications, LLC (Netgate)
       3             :  *
       4             :  * SPDX-License-Identifier: Apache-2.0
       5             :  *
       6             :  */
       7             : 
       8             : #include <vnet/vnet.h>
       9             : #include <vnet/api_errno.h>
      10             : #include <vnet/ip/ip.h>
      11             : #include <vnet/interface.h>
      12             : 
      13             : #include <plugins/vrrp/vrrp.h>
      14             : #include <plugins/vrrp/vrrp_packet.h>
      15             : 
      16             : u8 *
      17           0 : format_vrrp_vr_flags (u8 * s, va_list * args)
      18             : {
      19           0 :   vrrp_vr_flags_t flags = va_arg (*args, vrrp_vr_flags_t);
      20             : 
      21           0 :   s = format (s, "preempt %s accept %s unicast %s",
      22           0 :               (flags & VRRP_VR_PREEMPT) ? "yes" : "no",
      23           0 :               (flags & VRRP_VR_ACCEPT) ? "yes" : "no",
      24           0 :               (flags & VRRP_VR_UNICAST) ? "yes" : "no");
      25             : 
      26           0 :   return s;
      27             : }
      28             : 
      29             : u8 *
      30           0 : format_vrrp_vr_addrs (u8 * s, va_list * args)
      31             : {
      32           0 :   int is_ipv6 = va_arg (*args, int);
      33           0 :   ip46_address_t *addrs = va_arg (*args, ip46_address_t *);
      34             :   ip46_address_t *addr;
      35             : 
      36           0 :   vec_foreach (addr, addrs)
      37             :   {
      38           0 :     s = format (s, "%U ",
      39             :                 (is_ipv6) ? format_ip6_address : format_ip4_address,
      40             :                 (is_ipv6) ? (u8 *) & addr->ip6 : (u8 *) & addr->ip4);
      41             :   }
      42             : 
      43           0 :   return s;
      44             : }
      45             : 
      46             : u8 *
      47           4 : format_vrrp_vr_state (u8 * s, va_list * args)
      48             : {
      49           4 :   vrrp_vr_state_t state = va_arg (*args, vrrp_vr_state_t);
      50             : 
      51           4 :   switch (state)
      52             :     {
      53             : #define _(v,f,n) case VRRP_VR_STATE_##f: s = format (s, n); break;
      54           4 :       foreach_vrrp_vr_state
      55             : #undef _
      56           0 :     default:
      57           0 :       s = format (s, "Unknown");
      58           0 :       break;
      59             :     }
      60             : 
      61           4 :   return s;
      62             : }
      63             : 
      64             : u8 *
      65           4 : format_vrrp_vr_key (u8 * s, va_list * args)
      66             : {
      67           4 :   vrrp_main_t *vmp = &vrrp_main;
      68           4 :   vrrp_vr_t *vr = va_arg (*args, vrrp_vr_t *);
      69           4 :   vrrp_vr_config_t *vrc = &vr->config;
      70             : 
      71           4 :   s = format (s, "[%d] sw_if_index %u VR ID %u IPv%d",
      72           4 :               vr - vmp->vrs, vrc->sw_if_index,
      73           8 :               vrc->vr_id, (vrc->flags & VRRP_VR_IPV6) ? 6 : 4);
      74             : 
      75           4 :   return s;
      76             : }
      77             : 
      78             : u8 *
      79           0 : format_vrrp_vr_track_ifs (u8 * s, va_list * args)
      80             : {
      81           0 :   vrrp_vr_tracking_if_t *track_ifs = va_arg (*args, vrrp_vr_tracking_if_t *);
      82             :   vrrp_vr_tracking_if_t *track_if;
      83             : 
      84           0 :   vec_foreach (track_if, track_ifs)
      85           0 :     s = format (s, "sw_if_index %u priority %u ",
      86           0 :                 track_if->sw_if_index, track_if->priority);
      87             : 
      88           0 :   return s;
      89             : }
      90             : 
      91             : u8 *
      92           0 : format_vrrp_vr (u8 * s, va_list * args)
      93             : {
      94           0 :   vrrp_vr_t *vr = va_arg (*args, vrrp_vr_t *);
      95             : 
      96           0 :   s = format (s, "%U\n", format_vrrp_vr_key, vr);
      97             : 
      98           0 :   s = format (s, "   state %U flags: %U\n",
      99           0 :               format_vrrp_vr_state, vr->runtime.state,
     100           0 :               format_vrrp_vr_flags, vr->config.flags);
     101           0 :   s = format (s, "   priority: configured %u adjusted %u\n",
     102           0 :               vr->config.priority, vrrp_vr_priority (vr));
     103           0 :   s = format (s, "   timers: adv interval %u "
     104             :               "master adv %u skew %u master down %u\n",
     105           0 :               vr->config.adv_interval, vr->runtime.master_adv_int,
     106           0 :               vr->runtime.skew, vr->runtime.master_down_int);
     107             : 
     108           0 :   s = format (s, "   virtual MAC %U\n", format_ethernet_address,
     109             :               &vr->runtime.mac);
     110             : 
     111           0 :   s = format (s, "   addresses %U\n", format_vrrp_vr_addrs,
     112           0 :               (vr->config.flags & VRRP_VR_IPV6) != 0, vr->config.vr_addrs);
     113             : 
     114           0 :   s = format (s, "   peer addresses %U\n", format_vrrp_vr_addrs,
     115           0 :               (vr->config.flags & VRRP_VR_IPV6) != 0, vr->config.peer_addrs);
     116             : 
     117           0 :   s = format (s, "   tracked interfaces %U\n", format_vrrp_vr_track_ifs,
     118             :               vr->tracking.interfaces);
     119             : 
     120           0 :   return s;
     121             : }
     122             : 
     123             : u8 *
     124           0 : format_vrrp_packet_hdr (u8 * s, va_list * args)
     125             : {
     126           0 :   vrrp_header_t *pkt = va_arg (*args, vrrp_header_t *);
     127           0 :   u32 version = pkt->vrrp_version_and_type >> 4;
     128             : 
     129           0 :   s = format (s, "ver %u, type %u, VRID %u, prio %u, "
     130             :               "n_addrs %u, interval %u%ss, csum 0x%x",
     131           0 :               version, pkt->vrrp_version_and_type & 0xf,
     132           0 :               pkt->vr_id, pkt->priority, pkt->n_addrs,
     133           0 :               clib_net_to_host_u16 (pkt->rsvd_and_max_adv_int),
     134           0 :               (version == 3) ? "c" : "", pkt->checksum);
     135             : 
     136           0 :   return s;
     137             : }
     138             : 
     139             : 
     140             : /*
     141             :  * fd.io coding-style-patch-verification: ON
     142             :  *
     143             :  * Local Variables:
     144             :  * eval: (c-set-style "gnu")
     145             :  * End:
     146             :  */