pimd/pim_igmpv2.c

   1 /*
   2  * PIM for Quagga
   3  * Copyright (C) 2016 Cumulus Networks, Inc.
   4  * Daniel Walton
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "zebra.h"
  22
  23 #include "pimd.h"
  24 #include "pim_igmp.h"
  25 #include "pim_igmpv2.h"
  26 #include "pim_igmpv3.h"
  27 #include "pim_str.h"
  28 #include "pim_time.h"
  29 #include "pim_util.h"
  30
  31
  32 static void on_trace(const char *label, struct interface *ifp,
  33                      struct in_addr from)
  34 {
  35         if (PIM_DEBUG_IGMP_TRACE) {
  36                 char from_str[INET_ADDRSTRLEN];
  37                 pim_inet4_dump("<from?>", from, from_str, sizeof(from_str));
  38                 zlog_debug("%s: from %s on %s", label, from_str, ifp->name);
  39         }
  40 }
  41
  42 void igmp_v2_send_query(struct igmp_group *group, int fd, const char *ifname,
  43                         char *query_buf, struct in_addr dst_addr,
  44                         struct in_addr group_addr,
  45                         int query_max_response_time_dsec)
  46 {
  47         ssize_t msg_size = 8;
  48         uint8_t max_resp_code;
  49         ssize_t sent;
  50         struct sockaddr_in to;
  51         socklen_t tolen;
  52         uint16_t checksum;
  53
  54         /* max_resp_code must be non-zero else this will look like an IGMP v1
  55          * query */
  56         max_resp_code = igmp_msg_encode16to8(query_max_response_time_dsec);
  57         zassert(max_resp_code > 0);
  58
  59         query_buf[0] = PIM_IGMP_MEMBERSHIP_QUERY;
  60         query_buf[1] = max_resp_code;
  61         *(uint16_t *)(query_buf + IGMP_CHECKSUM_OFFSET) =
  62                 0; /* for computing checksum */
  63         memcpy(query_buf + 4, &group_addr, sizeof(struct in_addr));
  64
  65         checksum = in_cksum(query_buf, msg_size);
  66         *(uint16_t *)(query_buf + IGMP_CHECKSUM_OFFSET) = checksum;
  67
  68         if (PIM_DEBUG_IGMP_PACKETS) {
  69                 char dst_str[INET_ADDRSTRLEN];
  70                 char group_str[INET_ADDRSTRLEN];
  71                 pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
  72                 pim_inet4_dump("<group?>", group_addr, group_str,
  73                                sizeof(group_str));
  74                 zlog_debug("Send IGMPv2 QUERY to %s on %s for group %s",
  75                            dst_str, ifname, group_str);
  76         }
  77
  78         memset(&to, 0, sizeof(to));
  79         to.sin_family = AF_INET;
  80         to.sin_addr = dst_addr;
  81         tolen = sizeof(to);
  82
  83         sent = sendto(fd, query_buf, msg_size, MSG_DONTWAIT,
  84                       (struct sockaddr *)&to, tolen);
  85         if (sent != (ssize_t)msg_size) {
  86                 char dst_str[INET_ADDRSTRLEN];
  87                 char group_str[INET_ADDRSTRLEN];
  88                 pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
  89                 pim_inet4_dump("<group?>", group_addr, group_str,
  90                                sizeof(group_str));
  91                 if (sent < 0) {
  92                         zlog_warn(
  93                                 "Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: errno=%d: %s",
  94                                 dst_str, ifname, group_str, msg_size, errno,
  95                                 safe_strerror(errno));
  96                 } else {
  97                         zlog_warn(
  98                                 "Send IGMPv2 QUERY failed due to %s on %s: group=%s msg_size=%zd: sent=%zd",
  99                                 dst_str, ifname, group_str, msg_size, sent);
 100                 }
 101                 return;
 102         }
 103 }
 104
 105 int igmp_v2_recv_report(struct igmp_sock *igmp, struct in_addr from,
 106                         const char *from_str, char *igmp_msg, int igmp_msg_len)
 107 {
 108         struct interface *ifp = igmp->interface;
 109         struct in_addr group_addr;
 110         char group_str[INET_ADDRSTRLEN];
 111
 112         on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
 113
 114         if (igmp->mtrace_only)
 115                 return 0;
 116
 117         if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
 118                 zlog_warn(
 119                         "Recv IGMPv2 REPORT from %s on %s: size=%d other than correct=%d",
 120                         from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
 121                 return -1;
 122         }
 123
 124         memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
 125
 126         if (PIM_DEBUG_IGMP_PACKETS) {
 127                 pim_inet4_dump("<dst?>", group_addr, group_str,
 128                                sizeof(group_str));
 129                 zlog_debug("Recv IGMPv2 REPORT from %s on %s for %s", from_str,
 130                            ifp->name, group_str);
 131         }
 132
 133         /*
 134          * RFC 3376
 135          * 7.3.2. In the Presence of Older Version Group Members
 136          *
 137          * When Group Compatibility Mode is IGMPv2, a router internally
 138          * translates the following IGMPv2 messages for that group to their
 139          * IGMPv3 equivalents:
 140          *
 141          * IGMPv2 Message                IGMPv3 Equivalent
 142          * --------------                -----------------
 143          * Report                        IS_EX( {} )
 144          * Leave                         TO_IN( {} )
 145          */
 146         igmpv3_report_isex(igmp, from, group_addr, 0, NULL, 1);
 147
 148         return 0;
 149 }
 150
 151 int igmp_v2_recv_leave(struct igmp_sock *igmp, struct in_addr from,
 152                        const char *from_str, char *igmp_msg, int igmp_msg_len)
 153 {
 154         struct interface *ifp = igmp->interface;
 155         struct in_addr group_addr;
 156         char group_str[INET_ADDRSTRLEN];
 157
 158         on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
 159
 160         if (igmp->mtrace_only)
 161                 return 0;
 162
 163         if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
 164                 zlog_warn(
 165                         "Recv IGMPv2 LEAVE from %s on %s: size=%d other than correct=%d",
 166                         from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
 167                 return -1;
 168         }
 169
 170         memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
 171
 172         if (PIM_DEBUG_IGMP_PACKETS) {
 173                 pim_inet4_dump("<dst?>", group_addr, group_str,
 174                                sizeof(group_str));
 175                 zlog_debug("Recv IGMPv2 LEAVE from %s on %s for %s", from_str,
 176                            ifp->name, group_str);
 177         }
 178
 179         /*
 180          * RFC 3376
 181          * 7.3.2. In the Presence of Older Version Group Members
 182          *
 183          * When Group Compatibility Mode is IGMPv2, a router internally
 184          * translates the following IGMPv2 messages for that group to their
 185          * IGMPv3 equivalents:
 186          *
 187          * IGMPv2 Message                IGMPv3 Equivalent
 188          * --------------                -----------------
 189          * Report                        IS_EX( {} )
 190          * Leave                         TO_IN( {} )
 191          */
 192         igmpv3_report_toin(igmp, from, group_addr, 0, NULL);
 193
 194         return 0;
 195 }