back to topotato report
topotato coverage report
Current view: top level - lib - mlag.c (source / functions) Hit Total Coverage
Test: test_bgp_ecmp_enhe.py::BGP_Unnumbered_ECMP Lines: 0 96 0.0 %
Date: 2023-11-16 17:19:14 Functions: 0 16 0.0 %

          Line data    Source code
       1             : // SPDX-License-Identifier: GPL-2.0-or-later
       2             : /* mlag generic code.
       3             :  * Copyright (C) 2018 Cumulus Networks, Inc.
       4             :  *                    Donald Sharp
       5             :  */
       6             : #include <zebra.h>
       7             : 
       8             : #include <mlag.h>
       9             : 
      10           0 : char *mlag_role2str(enum mlag_role role, char *buf, size_t size)
      11             : {
      12           0 :         switch (role) {
      13           0 :         case MLAG_ROLE_NONE:
      14           0 :                 snprintf(buf, size, "NONE");
      15           0 :                 break;
      16           0 :         case MLAG_ROLE_PRIMARY:
      17           0 :                 snprintf(buf, size, "PRIMARY");
      18           0 :                 break;
      19           0 :         case MLAG_ROLE_SECONDARY:
      20           0 :                 snprintf(buf, size, "SECONDARY");
      21           0 :                 break;
      22             :         }
      23             : 
      24           0 :         return buf;
      25             : }
      26             : 
      27           0 : char *mlag_lib_msgid_to_str(enum mlag_msg_type msg_type, char *buf, size_t size)
      28             : {
      29           0 :         switch (msg_type) {
      30           0 :         case MLAG_REGISTER:
      31           0 :                 snprintf(buf, size, "Register");
      32           0 :                 break;
      33           0 :         case MLAG_DEREGISTER:
      34           0 :                 snprintf(buf, size, "De-Register");
      35           0 :                 break;
      36           0 :         case MLAG_MROUTE_ADD:
      37           0 :                 snprintf(buf, size, "Mroute add");
      38           0 :                 break;
      39           0 :         case MLAG_MROUTE_DEL:
      40           0 :                 snprintf(buf, size, "Mroute del");
      41           0 :                 break;
      42           0 :         case MLAG_DUMP:
      43           0 :                 snprintf(buf, size, "Mlag Replay");
      44           0 :                 break;
      45           0 :         case MLAG_MROUTE_ADD_BULK:
      46           0 :                 snprintf(buf, size, "Mroute Add Batch");
      47           0 :                 break;
      48           0 :         case MLAG_MROUTE_DEL_BULK:
      49           0 :                 snprintf(buf, size, "Mroute Del Batch");
      50           0 :                 break;
      51           0 :         case MLAG_STATUS_UPDATE:
      52           0 :                 snprintf(buf, size, "Mlag Status");
      53           0 :                 break;
      54           0 :         case MLAG_VXLAN_UPDATE:
      55           0 :                 snprintf(buf, size, "Mlag vxlan update");
      56           0 :                 break;
      57           0 :         case MLAG_PEER_FRR_STATUS:
      58           0 :                 snprintf(buf, size, "Mlag Peer FRR Status");
      59           0 :                 break;
      60           0 :         case MLAG_PIM_CFG_DUMP:
      61           0 :                 snprintf(buf, size, "Mlag Pim Configuration Dump");
      62           0 :                 break;
      63           0 :         case MLAG_MSG_NONE:
      64           0 :                 snprintf(buf, size, "Unknown %d", msg_type);
      65           0 :                 break;
      66             :         }
      67           0 :         return buf;
      68             : }
      69             : 
      70             : 
      71           0 : int mlag_lib_decode_mlag_hdr(struct stream *s, struct mlag_msg *msg,
      72             :                              size_t *length)
      73             : {
      74             : #define LIB_MLAG_HDR_LENGTH 8
      75           0 :         if (s == NULL || msg == NULL)
      76             :                 return -1;
      77             : 
      78           0 :         *length = stream_get_endp(s);
      79             : 
      80           0 :         if (*length < LIB_MLAG_HDR_LENGTH)
      81             :                 return -1;
      82             : 
      83           0 :         *length -= LIB_MLAG_HDR_LENGTH;
      84             : 
      85           0 :         STREAM_GETL(s, msg->msg_type);
      86           0 :         STREAM_GETW(s, msg->data_len);
      87           0 :         STREAM_GETW(s, msg->msg_cnt);
      88             : 
      89           0 :         return 0;
      90             : stream_failure:
      91             :         return -1;
      92             : }
      93             : 
      94             : #define MLAG_MROUTE_ADD_LENGTH                                                 \
      95             :         (VRF_NAMSIZ + INTERFACE_NAMSIZ + 4 + 4 + 4 + 4 + 1 + 1 + 4)
      96             : 
      97           0 : int mlag_lib_decode_mroute_add(struct stream *s, struct mlag_mroute_add *msg,
      98             :                                size_t *length)
      99             : {
     100           0 :         if (s == NULL || msg == NULL || *length < MLAG_MROUTE_ADD_LENGTH)
     101             :                 return -1;
     102             : 
     103           0 :         STREAM_GET(msg->vrf_name, s, VRF_NAMSIZ);
     104           0 :         STREAM_GETL(s, msg->source_ip);
     105           0 :         STREAM_GETL(s, msg->group_ip);
     106           0 :         STREAM_GETL(s, msg->cost_to_rp);
     107           0 :         STREAM_GETL(s, msg->owner_id);
     108           0 :         STREAM_GETC(s, msg->am_i_dr);
     109           0 :         STREAM_GETC(s, msg->am_i_dual_active);
     110           0 :         STREAM_GETL(s, msg->vrf_id);
     111           0 :         STREAM_GET(msg->intf_name, s, INTERFACE_NAMSIZ);
     112             : 
     113             :         return 0;
     114             : stream_failure:
     115             :         return -1;
     116             : }
     117             : 
     118             : #define MLAG_MROUTE_DEL_LENGTH (VRF_NAMSIZ + INTERFACE_NAMSIZ + 4 + 4 + 4 + 4)
     119             : 
     120           0 : int mlag_lib_decode_mroute_del(struct stream *s, struct mlag_mroute_del *msg,
     121             :                                size_t *length)
     122             : {
     123           0 :         if (s == NULL || msg == NULL || *length < MLAG_MROUTE_DEL_LENGTH)
     124             :                 return -1;
     125             : 
     126           0 :         STREAM_GET(msg->vrf_name, s, VRF_NAMSIZ);
     127           0 :         STREAM_GETL(s, msg->source_ip);
     128           0 :         STREAM_GETL(s, msg->group_ip);
     129           0 :         STREAM_GETL(s, msg->owner_id);
     130           0 :         STREAM_GETL(s, msg->vrf_id);
     131           0 :         STREAM_GET(msg->intf_name, s, INTERFACE_NAMSIZ);
     132             : 
     133             :         return 0;
     134             : stream_failure:
     135             :         return -1;
     136             : }
     137             : 
     138           0 : int mlag_lib_decode_mlag_status(struct stream *s, struct mlag_status *msg)
     139             : {
     140           0 :         if (s == NULL || msg == NULL)
     141             :                 return -1;
     142             : 
     143           0 :         STREAM_GET(msg->peerlink_rif, s, INTERFACE_NAMSIZ);
     144           0 :         STREAM_GETL(s, msg->my_role);
     145           0 :         STREAM_GETL(s, msg->peer_state);
     146           0 :         return 0;
     147             : stream_failure:
     148             :         return -1;
     149             : }
     150             : 
     151           0 : int mlag_lib_decode_vxlan_update(struct stream *s, struct mlag_vxlan *msg)
     152             : {
     153           0 :         if (s == NULL || msg == NULL)
     154             :                 return -1;
     155             : 
     156           0 :         STREAM_GETL(s, msg->anycast_ip);
     157           0 :         STREAM_GETL(s, msg->local_ip);
     158           0 :         return 0;
     159             : 
     160             : stream_failure:
     161             :         return -1;
     162             : }
     163             : 
     164           0 : int mlag_lib_decode_frr_status(struct stream *s, struct mlag_frr_status *msg)
     165             : {
     166           0 :         if (s == NULL || msg == NULL)
     167             :                 return -1;
     168             : 
     169           0 :         STREAM_GETL(s, msg->frr_state);
     170           0 :         return 0;
     171           0 : stream_failure:
     172           0 :         return -1;
     173             : }

Generated by: LCOV version v1.16-topotato