senf/Socket/Protocols/INet/MulticastSocketProtocol.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2007
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief MulticastSocketProtocol non-inline non-template implementation */
  25
  26 #include "MulticastSocketProtocol.hh"
  27 //#include "MulticastSocketProtocol.ih"
  28
  29 // Custom includes
  30 #include <sys/socket.h>
  31 #include <netinet/in.h>
  32 #include <net/if.h> // for if_nametoindex
  33 #include <senf/Utils/Exception.hh>
  34
  35 //#include "MulticastSocketProtocol.mpp"
  36 #define prefix_
  37 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  38
  39 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  40 // senf::MulticastSocketProtocol
  41
  42 prefix_ void senf::MulticastSocketProtocol::broadcastEnabled(bool v)
  43     const
  44 {
  45     int ivalue (v);
  46     if (::setsockopt(fd(), SOL_SOCKET, SO_BROADCAST, &ivalue, sizeof(ivalue)) < 0)
  47         SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(SO_BROADCAST)");
  48 }
  49
  50 prefix_ bool senf::MulticastSocketProtocol::broadcastEnabled()
  51     const
  52 {
  53     int value (0);
  54     ::socklen_t len (sizeof(value));
  55     if (::getsockopt(fd(), SOL_SOCKET, SO_BROADCAST, &value, &len) < 0)
  56         SENF_THROW_SYSTEM_EXCEPTION("::getsockopt(SO_BROADCAST)");
  57     return value;
  58 }
  59
  60 prefix_ bool senf::MulticastSocketProtocol::mcLoop()
  61     const
  62 {
  63     int value (0);
  64     socklen_t len (sizeof(value));
  65     if (::getsockopt(fd(),SOL_IP,IP_MULTICAST_LOOP,&value,&len) < 0)
  66         SENF_THROW_SYSTEM_EXCEPTION("");
  67     return value;
  68 }
  69
  70 prefix_ void senf::MulticastSocketProtocol::mcLoop(bool value)
  71     const
  72 {
  73     int ivalue (value);
  74     if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_LOOP,&ivalue,sizeof(ivalue)) < 0)
  75         SENF_THROW_SYSTEM_EXCEPTION("");
  76 }
  77
  78 prefix_ void senf::MulticastSocketProtocol::mcIface(std::string const & iface)
  79     const
  80 {
  81     struct ip_mreqn mreqn;
  82     ::memset(&mreqn, 0, sizeof(mreqn));
  83     if (!iface.empty()) {
  84         mreqn.imr_ifindex = if_nametoindex(iface.c_str());
  85         if (mreqn.imr_ifindex == 0)
  86             throw SystemException(EINVAL SENF_EXC_DEBUGINFO);
  87     }
  88     if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_IF,&mreqn,sizeof(mreqn)) < 0)
  89         SENF_THROW_SYSTEM_EXCEPTION("");
  90 }
  91
  92 prefix_ unsigned senf::MulticastSocketProtocol::mcTTL()
  93     const
  94 {
  95     int value (0);
  96     socklen_t len (sizeof(value));
  97     if (::getsockopt(fd(),SOL_IP,IP_MULTICAST_TTL,&value,&len) < 0)
  98         SENF_THROW_SYSTEM_EXCEPTION("");
  99     return value;
 100 }
 101
 102 prefix_ void senf::MulticastSocketProtocol::mcTTL(unsigned value)
 103     const
 104 {
 105     if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_TTL,&value,sizeof(value)) < 0)
 106         SENF_THROW_SYSTEM_EXCEPTION("");
 107 }
 108
 109 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 110 // senf::INet4MulticastSocketProtocol
 111
 112 prefix_ void senf::INet4MulticastSocketProtocol::mcAddMembership(INet4Address const & mcAddr)
 113     const
 114 {
 115     struct ip_mreqn mreqn;
 116     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 117     mreqn.imr_address.s_addr = htons(INADDR_ANY);
 118     mreqn.imr_ifindex = 0;
 119     if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 120         SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IP_ADD_MEMBERSHIP)");
 121 }
 122
 123 prefix_ void senf::INet4MulticastSocketProtocol::mcAddMembership(INet4Address const & mcAddr,
 124                                                                  INet4Address const & localAddr)
 125     const
 126 {
 127     struct ip_mreqn mreqn;
 128     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 129     mreqn.imr_address.s_addr = localAddr.inaddr();
 130     mreqn.imr_ifindex = 0;
 131     if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 132         SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IP_ADD_MEMBERSHIP");
 133 }
 134
 135 prefix_ void senf::INet4MulticastSocketProtocol::mcAddMembership(INet4Address const & mcAddr,
 136                                                                  std::string const & iface)
 137     const
 138 {
 139     struct ip_mreqn mreqn;
 140     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 141     mreqn.imr_address.s_addr = htons(INADDR_ANY);
 142     mreqn.imr_ifindex = if_nametoindex(iface.c_str());
 143     if (mreqn.imr_ifindex == 0)
 144         throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 145     if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 146         SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IP_ADD_MEMBERSHIP");
 147 }
 148
 149 prefix_ void senf::INet4MulticastSocketProtocol::mcDropMembership(INet4Address const & mcAddr)
 150     const
 151 {
 152     struct ip_mreqn mreqn;
 153     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 154     mreqn.imr_address.s_addr = htons(INADDR_ANY);
 155     mreqn.imr_ifindex = 0;
 156     if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 157         SENF_THROW_SYSTEM_EXCEPTION("");
 158 }
 159
 160 prefix_ void senf::INet4MulticastSocketProtocol::mcDropMembership(INet4Address const & mcAddr,
 161                                                                   INet4Address const & localAddr)
 162     const
 163 {
 164     struct ip_mreqn mreqn;
 165     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 166     mreqn.imr_address.s_addr = localAddr.inaddr();
 167     mreqn.imr_ifindex = 0;
 168     if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 169         SENF_THROW_SYSTEM_EXCEPTION("");
 170 }
 171
 172 prefix_ void senf::INet4MulticastSocketProtocol::mcDropMembership(INet4Address const & mcAddr,
 173                                                                   std::string const & iface)
 174     const
 175 {
 176     struct ip_mreqn mreqn;
 177     mreqn.imr_multiaddr.s_addr = mcAddr.inaddr();
 178     mreqn.imr_address.s_addr = htons(INADDR_ANY);
 179     mreqn.imr_ifindex = if_nametoindex(iface.c_str());
 180     if (mreqn.imr_ifindex == 0)
 181         throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 182     if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 183         SENF_THROW_SYSTEM_EXCEPTION("");
 184 }
 185
 186 namespace {
 187     void mc4SSMSourceRequest(int operation, int fd, senf::INet4Address const & group,
 188                               senf::INet4Address const & source, std::string const & iface)
 189     {
 190         struct group_source_req req;
 191         ::memset(&req, 0, sizeof(req));
 192         req.gsr_interface = if_nametoindex(iface.c_str());
 193         if (req.gsr_interface == 0)
 194             throw senf::SystemException("::if_nametoindex()", ENOENT SENF_EXC_DEBUGINFO);
 195         req.gsr_group.ss_family = AF_INET;
 196         reinterpret_cast<struct sockaddr_in&>(req.gsr_group).sin_addr.s_addr = group.inaddr();
 197         req.gsr_source.ss_family = AF_INET;
 198         reinterpret_cast<struct sockaddr_in&>(req.gsr_source).sin_addr.s_addr = source.inaddr();
 199         if (::setsockopt(fd, SOL_IP, MCAST_JOIN_SOURCE_GROUP, &req, sizeof(req)) < 0)
 200             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt()");
 201     }
 202 }
 203
 204 prefix_ void senf::INet4MulticastSocketProtocol::mcJoinSSMSource(INet4Address const & group,
 205                                                                  INet4Address const & source,
 206                                                                  std::string const & iface)
 207     const
 208 {
 209     mc4SSMSourceRequest(MCAST_JOIN_SOURCE_GROUP, fd(), group, source, iface);
 210 }
 211
 212 prefix_ void senf::INet4MulticastSocketProtocol::mcLeaveSSMSource(INet4Address const & group,
 213                                                                   INet4Address const & source,
 214                                                                   std::string const & iface)
 215     const
 216 {
 217     mc4SSMSourceRequest(MCAST_LEAVE_SOURCE_GROUP, fd(), group, source, iface);
 218 }
 219
 220 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 221 // senf::INet6MulticastSocketProtocol
 222
 223 prefix_ void senf::INet6MulticastSocketProtocol::mcAddMembership(INet6Address const & mcAddr)
 224     const
 225 {
 226     if (mcAddr.inet4Mapped()) {
 227         struct ip_mreqn mreqn;
 228         mreqn.imr_multiaddr.s_addr = mcAddr.inet4address().inaddr();
 229         mreqn.imr_address.s_addr = htons(INADDR_ANY);
 230         mreqn.imr_ifindex = 0;
 231         if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 232             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IP_ADD_MEMBERSHIP)");
 233     }
 234     else {
 235         struct ipv6_mreq mreqn;
 236         std::copy(mcAddr.begin(), mcAddr.end(), mreqn.ipv6mr_multiaddr.s6_addr);
 237         mreqn.ipv6mr_interface = 0;
 238         if (::setsockopt(fd(),SOL_IPV6,IPV6_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 239             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IPV6_ADD_MEMBERSHIP");
 240     }
 241 }
 242
 243 prefix_ void senf::INet6MulticastSocketProtocol::mcAddMembership(INet6Address const & mcAddr,
 244                                                                  std::string const & iface)
 245     const
 246 {
 247     if (mcAddr.inet4Mapped()) {
 248         struct ip_mreqn mreqn;
 249         mreqn.imr_multiaddr.s_addr = mcAddr.inet4address().inaddr();
 250         mreqn.imr_address.s_addr = htons(INADDR_ANY);
 251         mreqn.imr_ifindex = if_nametoindex(iface.c_str());
 252         if (mreqn.imr_ifindex == 0)
 253             throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 254         if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 255             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IP_ADD_MEMBERSHIP");
 256     }
 257     else {
 258         struct ipv6_mreq mreqn;
 259         std::copy(mcAddr.begin(), mcAddr.end(), mreqn.ipv6mr_multiaddr.s6_addr);
 260         mreqn.ipv6mr_interface = if_nametoindex(iface.c_str());
 261         if (mreqn.ipv6mr_interface == 0)
 262             throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 263         if (::setsockopt(fd(),SOL_IPV6,IPV6_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 264             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt(IPV6_ADD_MEMBERSHIP");
 265     }
 266 }
 267
 268 prefix_ void senf::INet6MulticastSocketProtocol::mcDropMembership(INet6Address const & mcAddr)
 269     const
 270 {
 271     if (mcAddr.inet4Mapped()) {
 272         struct ip_mreqn mreqn;
 273         mreqn.imr_multiaddr.s_addr = mcAddr.inet4address().inaddr();
 274         mreqn.imr_address.s_addr = htons(INADDR_ANY);
 275         mreqn.imr_ifindex = 0;
 276         if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 277             SENF_THROW_SYSTEM_EXCEPTION("");
 278     }
 279     else {
 280         struct ipv6_mreq mreqn;
 281         std::copy(mcAddr.begin(), mcAddr.end(), mreqn.ipv6mr_multiaddr.s6_addr);
 282         mreqn.ipv6mr_interface = 0;
 283         if (::setsockopt(fd(),SOL_IPV6,IPV6_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 284             SENF_THROW_SYSTEM_EXCEPTION("");
 285     }
 286 }
 287
 288 prefix_ void
 289 senf::INet6MulticastSocketProtocol::mcDropMembership(INet6Address const & mcAddr,
 290                                                      std::string const & iface)
 291     const
 292 {
 293     if (mcAddr.inet4Mapped()) {
 294         struct ip_mreqn mreqn;
 295         mreqn.imr_multiaddr.s_addr = mcAddr.inet4address().inaddr();
 296         mreqn.imr_address.s_addr = htons(INADDR_ANY);
 297         mreqn.imr_ifindex = if_nametoindex(iface.c_str());
 298         if (mreqn.imr_ifindex == 0)
 299             throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 300         if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 301             SENF_THROW_SYSTEM_EXCEPTION("");
 302     }
 303     else {
 304         struct ipv6_mreq mreqn;
 305         std::copy(mcAddr.begin(), mcAddr.end(), mreqn.ipv6mr_multiaddr.s6_addr);
 306         mreqn.ipv6mr_interface = if_nametoindex(iface.c_str());
 307         if (mreqn.ipv6mr_interface == 0)
 308             throw SystemException("::if_nametoindex()",ENOENT SENF_EXC_DEBUGINFO);
 309         if (::setsockopt(fd(),SOL_IPV6,IPV6_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
 310             SENF_THROW_SYSTEM_EXCEPTION("");
 311     }
 312 }
 313
 314 namespace {
 315
 316     void mc6SSMSourceRequest(int operation, int fd, senf::INet6Address const & group,
 317                              senf::INet6Address const & source, int ifacei)
 318     {
 319         struct group_source_req req;
 320         ::memset(&req, 0, sizeof(req));
 321         req.gsr_interface = ifacei;
 322         req.gsr_group.ss_family = AF_INET6;
 323         std::copy(group.begin(), group.end(),
 324                   reinterpret_cast<struct sockaddr_in6&>(req.gsr_group).sin6_addr.s6_addr);
 325         req.gsr_source.ss_family = AF_INET6;
 326         std::copy(source.begin(), source.end(),
 327                   reinterpret_cast<struct sockaddr_in6&>(req.gsr_source).sin6_addr.s6_addr);
 328         if (::setsockopt(fd, SOL_IPV6, MCAST_JOIN_SOURCE_GROUP, &req, sizeof(req)) < 0)
 329             SENF_THROW_SYSTEM_EXCEPTION("::setsockopt()");
 330     }
 331
 332     void mc6SSMSourceRequest(int operation, int fd, senf::INet6Address const & group,
 333                              senf::INet6Address const & source, std::string const & iface)
 334     {
 335         int ifacei (0);
 336         if (! iface.empty()) {
 337             ifacei = if_nametoindex(iface.c_str());
 338             if (ifacei == 0)
 339                 throw senf::SystemException("::if_nametoindex()", ENOENT SENF_EXC_DEBUGINFO);
 340         }
 341         mc6SSMSourceRequest(operation, fd, group, source, ifacei);
 342     }
 343
 344 }
 345
 346 prefix_ void senf::INet6MulticastSocketProtocol::mcJoinSSMSource(INet6Address const & group,
 347                                                                  INet6Address const & source,
 348                                                                  std::string const & iface)
 349     const
 350 {
 351     mc6SSMSourceRequest(MCAST_JOIN_SOURCE_GROUP, fd(), group, source, iface);
 352 }
 353
 354 prefix_ void senf::INet6MulticastSocketProtocol::mcJoinSSMSource(INet6Address const & group,
 355                                                                  INet6Address const & source,
 356                                                                  int ifacei)
 357     const
 358 {
 359     mc6SSMSourceRequest(MCAST_JOIN_SOURCE_GROUP, fd(), group, source, ifacei);
 360 }
 361
 362 prefix_ void senf::INet6MulticastSocketProtocol::mcLeaveSSMSource(INet6Address const & group,
 363                                                                   INet6Address const & source,
 364                                                                   std::string const & iface)
 365     const
 366 {
 367     mc6SSMSourceRequest(MCAST_LEAVE_SOURCE_GROUP, fd(), group, source, iface);
 368 }
 369
 370
 371 //-/////////////////////////////////////////////////////////////////////////////////////////////////
 372 #undef prefix_
 373 //#include "MulticastSocketProtocol.mpp"
 374
 375 \f
 376 // Local Variables:
 377 // mode: c++
 378 // fill-column: 100
 379 // comment-column: 40
 380 // c-file-style: "senf"
 381 // indent-tabs-mode: nil
 382 // ispell-local-dictionary: "american"
 383 // compile-command: "scons -u test"
 384 // End: