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_msg_len != IGMP_V12_MSG_SIZE) {
 115                 zlog_warn(
 116                         "Recv IGMPv2 REPORT from %s on %s: size=%d other than correct=%d",
 117                         from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
 118                 return -1;
 119         }
 120
 121         memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
 122
 123         if (PIM_DEBUG_IGMP_PACKETS) {
 124                 pim_inet4_dump("<dst?>", group_addr, group_str,
 125                                sizeof(group_str));
 126                 zlog_debug("Recv IGMPv2 REPORT from %s on %s for %s", from_str,
 127                            ifp->name, group_str);
 128         }
 129
 130         /*
 131          * RFC 3376
 132          * 7.3.2. In the Presence of Older Version Group Members
 133          *
 134          * When Group Compatibility Mode is IGMPv2, a router internally
 135          * translates the following IGMPv2 messages for that group to their
 136          * IGMPv3 equivalents:
 137          *
 138          * IGMPv2 Message                IGMPv3 Equivalent
 139          * --------------                -----------------
 140          * Report                        IS_EX( {} )
 141          * Leave                         TO_IN( {} )
 142          */
 143         igmpv3_report_isex(igmp, from, group_addr, 0, NULL, 1);
 144
 145         return 0;
 146 }
 147
 148 int igmp_v2_recv_leave(struct igmp_sock *igmp, struct in_addr from,
 149                        const char *from_str, char *igmp_msg, int igmp_msg_len)
 150 {
 151         struct interface *ifp = igmp->interface;
 152         struct in_addr group_addr;
 153         char group_str[INET_ADDRSTRLEN];
 154
 155         on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
 156
 157         if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
 158                 zlog_warn(
 159                         "Recv IGMPv2 LEAVE from %s on %s: size=%d other than correct=%d",
 160                         from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
 161                 return -1;
 162         }
 163
 164         memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
 165
 166         if (PIM_DEBUG_IGMP_PACKETS) {
 167                 pim_inet4_dump("<dst?>", group_addr, group_str,
 168                                sizeof(group_str));
 169                 zlog_debug("Recv IGMPv2 LEAVE from %s on %s for %s", from_str,
 170                            ifp->name, group_str);
 171         }
 172
 173         /*
 174          * RFC 3376
 175          * 7.3.2. In the Presence of Older Version Group Members
 176          *
 177          * When Group Compatibility Mode is IGMPv2, a router internally
 178          * translates the following IGMPv2 messages for that group to their
 179          * IGMPv3 equivalents:
 180          *
 181          * IGMPv2 Message                IGMPv3 Equivalent
 182          * --------------                -----------------
 183          * Report                        IS_EX( {} )
 184          * Leave                         TO_IN( {} )
 185          */
 186         igmpv3_report_toin(igmp, from, group_addr, 0, NULL);
 187
 188         return 0;
 189 }