Add support of IP_MULTICAST_IF in UDP sockets.

net/udp/udp_socket_libevent.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/udp/udp_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <netinet/in.h>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/stats_counters.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/udp/udp_net_log_parameters.h"
 
 namespace {
 
 const int kBindRetries = 10;
 const int kPortStart = 1024;
 const int kPortEnd = 65535;
 
+#if defined(OS_MACOSX)
+uint32 GetIPv4AddressFromIndex(int socket, uint32 index){

[szym, 2013/12/04 00:52:15]

Add comment:
// Returns IPv4 address in network order.

[Vitaly Buka (NO REVIEWS), 2013/12/04 09:39:36]

Done.

+  if (!index)
+    return htonl(INADDR_ANY);
+  ifreq ifr;
+  ifr.ifr_addr.sa_family = AF_INET;
+  if (!if_indextoname(index, ifr.ifr_name))
+    return htonl(INADDR_ANY);
+  if (ioctl(socket, SIOCGIFADDR, &ifr))
+    return htonl(INADDR_ANY);

[szym, 2013/12/04 00:52:15]

I am a bit concerned about this failure mode.

If the interface index is invalid (because for example the interface was turned
down), then we will end up binding to the default interface.

So, we might end up having multiple redundant sockets bound to the same
interface.

[Vitaly Buka (NO REVIEWS), 2013/12/04 01:00:49]

For current use-cases returning error is not a problem.
I'll update to return error so upper layer can decide what to do.

On 2013/12/04 00:52:15, szym wrote:

[Vitaly Buka (NO REVIEWS), 2013/12/04 09:39:36]

Done.

+  return reinterpret_cast<sockaddr_in*>(&ifr.ifr_addr)->sin_addr.s_addr;
+}
+#endif  // OS_MACOSX
+
 }  // namespace
 
 namespace net {
 
 UDPSocketLibevent::UDPSocketLibevent(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
     net::NetLog* net_log,
     const net::NetLog::Source& source)
         : socket_(kInvalidSocket),
           addr_family_(0),
           socket_options_(SOCKET_OPTION_MULTICAST_LOOP),
+          multicast_interface_(0),
           multicast_time_to_live_(1),
           bind_type_(bind_type),
           rand_int_cb_(rand_int_cb),
           read_watcher_(this),
           write_watcher_(this),
           read_buf_len_(0),
           recv_from_address_(NULL),
           write_buf_len_(0),
           net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_UDP_SOCKET)) {
   net_log_.BeginEvent(NetLog::TYPE_SOCKET_ALIVE,
@@ skipping 462 matching lines @@
     if (rv < 0)
       return MapSystemError(errno);
   }
   if (multicast_time_to_live_ != IP_DEFAULT_MULTICAST_TTL) {
     int rv;
     if (addr_family_ == AF_INET) {
       u_char ttl = multicast_time_to_live_;
       rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_TTL,
                       &ttl, sizeof(ttl));
     } else {
-      // Signed interger. -1 to use route default.
+      // Signed integer. -1 to use route default.
       int ttl = multicast_time_to_live_;
       rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
                       &ttl, sizeof(ttl));
     }
     if (rv < 0)
       return MapSystemError(errno);
   }
+  if (multicast_interface_ != 0) {
+    switch (addr_family_) {
+      case AF_INET: {
+#if !defined(OS_MACOSX)
+        ip_mreqn mreq;
+        mreq.imr_ifindex = multicast_interface_;
+        mreq.imr_address.s_addr = htonl(INADDR_ANY);
+#else
+        ip_mreq mreq;
+        mreq.imr_interface.s_addr =
+            GetIPv4AddressFromIndex(socket_, multicast_interface_);
+#endif
+        int rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_IF,
+                            reinterpret_cast<const char*>(&mreq), sizeof(mreq));
+        if (rv)
+          return MapSystemError(errno);
+        break;
+      }
+      case AF_INET6: {
+        uint32 interface_index = multicast_interface_;
+        int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_IF,
+                            reinterpret_cast<const char*>(&interface_index),
+                            sizeof(interface_index));
+        if (rv)
+          return MapSystemError(errno);
+        break;
+      }
+      default:
+        NOTREACHED() << "Invalid address family";
+        return ERR_ADDRESS_INVALID;
+    }
+  }
   return OK;
 }
 
 int UDPSocketLibevent::DoBind(const IPEndPoint& address) {
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))
     return ERR_ADDRESS_INVALID;
   int rv = bind(socket_, storage.addr, storage.addr_len);
   return rv < 0 ? MapSystemError(errno) : rv;
 }
@@ skipping 14 matching lines @@
 
 int UDPSocketLibevent::JoinGroup(const IPAddressNumber& group_address) const {
   DCHECK(CalledOnValidThread());
   if (!is_connected())
     return ERR_SOCKET_NOT_CONNECTED;
 
   switch (group_address.size()) {
     case kIPv4AddressSize: {
       if (addr_family_ != AF_INET)
         return ERR_ADDRESS_INVALID;
+
+#if !defined(OS_MACOSX)
+      ip_mreqn mreq;
+      mreq.imr_ifindex = multicast_interface_;
+      mreq.imr_address.s_addr = htonl(INADDR_ANY);
+#else
       ip_mreq mreq;
-      mreq.imr_interface.s_addr = INADDR_ANY;
+      mreq.imr_interface.s_addr =
+          GetIPv4AddressFromIndex(socket_, multicast_interface_);
+#endif
       memcpy(&mreq.imr_multiaddr, &group_address[0], kIPv4AddressSize);
       int rv = setsockopt(socket_, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                           &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     case kIPv6AddressSize: {
       if (addr_family_ != AF_INET6)
         return ERR_ADDRESS_INVALID;
       ipv6_mreq mreq;
-      mreq.ipv6mr_interface = 0;  // 0 indicates default multicast interface.
+      mreq.ipv6mr_interface = multicast_interface_;
       memcpy(&mreq.ipv6mr_multiaddr, &group_address[0], kIPv6AddressSize);
       int rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_JOIN_GROUP,
                           &mreq, sizeof(mreq));
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
@@ skipping 30 matching lines @@
       if (rv < 0)
         return MapSystemError(errno);
       return OK;
     }
     default:
       NOTREACHED() << "Invalid address family";
       return ERR_ADDRESS_INVALID;
   }
 }
 
+int UDPSocketLibevent::SetMulticastInterface(uint32 interface_index) {
+  DCHECK(CalledOnValidThread());
+  if (is_connected())
+    return ERR_SOCKET_IS_CONNECTED;
+  multicast_interface_ = interface_index;
+  return OK;
+}
+
 int UDPSocketLibevent::SetMulticastTimeToLive(int time_to_live) {
   DCHECK(CalledOnValidThread());
   if (is_connected())
     return ERR_SOCKET_IS_CONNECTED;
 
   if (time_to_live < 0 || time_to_live > 255)
     return ERR_INVALID_ARGUMENT;
   multicast_time_to_live_ = time_to_live;
   return OK;
 }
@@ skipping 23 matching lines @@
     rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_TCLASS,
                     &dscp_and_ecn, sizeof(dscp_and_ecn));
   }
   if (rv < 0)
     return MapSystemError(errno);
 
   return OK;
 }
 
 }  // namespace net