code review 4826056: syscall: update routing message support for BSD variants

src/pkg/syscall/route_bsd.go

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Routing sockets and messages
 
 package syscall
 
 import (
         "unsafe"
@@ skipping 47 matching lines @@
 }
 
 const anyMessageLen = int(unsafe.Sizeof(anyMessage{}))
 
 type anyMessage struct {
         Msglen  uint16
         Version uint8
         Type    uint8
 }
 
-func (any *anyMessage) toRoutingMessage(buf []byte) RoutingMessage {
-        switch any.Type {
-        case RTM_ADD, RTM_DELETE, RTM_CHANGE, RTM_GET, RTM_LOSING, RTM_REDIRECT, RTM_MISS, RTM_LOCK, RTM_RESOLVE:
-                p := (*RouteMessage)(unsafe.Pointer(any))
-                rtm := &RouteMessage{}
-                rtm.Header = p.Header
-                rtm.Data = buf[SizeofRtMsghdr:any.Msglen]
-                return rtm
-        case RTM_IFINFO:
-                p := (*InterfaceMessage)(unsafe.Pointer(any))
-                ifm := &InterfaceMessage{}
-                ifm.Header = p.Header
-                ifm.Data = buf[SizeofIfMsghdr:any.Msglen]
-                return ifm
-        case RTM_NEWADDR, RTM_DELADDR:
-                p := (*InterfaceAddrMessage)(unsafe.Pointer(any))
-                ifam := &InterfaceAddrMessage{}
-                ifam.Header = p.Header
-                ifam.Data = buf[SizeofIfaMsghdr:any.Msglen]
-                return ifam
-        case RTM_NEWMADDR, RTM_DELMADDR:
-                // TODO: implement this in the near future
-        }
-        return nil
-}
-
 // RouteMessage represents a routing message containing routing
 // entries.
 type RouteMessage struct {
         Header RtMsghdr
         Data   []byte
 }
 
 func (m *RouteMessage) sockaddr() (sas []Sockaddr) {
         // TODO: implement this in the near future
         return nil
@@ skipping 17 matching lines @@
         return append(sas, sa)
 }
 
 // InterfaceAddrMessage represents a routing message containing
 // network interface address entries.
 type InterfaceAddrMessage struct {
         Header IfaMsghdr
         Data   []byte
 }
 
-const rtaMask = RTA_IFA | RTA_NETMASK | RTA_BRD
+const rtaIfaMask = RTA_IFA | RTA_NETMASK | RTA_BRD
 
 func (m *InterfaceAddrMessage) sockaddr() (sas []Sockaddr) {
-        if m.Header.Addrs&rtaMask == 0 {
+        if m.Header.Addrs&rtaIfaMask == 0 {
                 return nil
         }
 
         buf := m.Data[:]
         for i := uint(0); i < RTAX_MAX; i++ {
-                if m.Header.Addrs&rtaMask&(1<<i) == 0 {
+                if m.Header.Addrs&rtaIfaMask&(1<<i) == 0 {
                         continue
                 }
                 rsa := (*RawSockaddr)(unsafe.Pointer(&buf[0]))
                 switch i {
                 case RTAX_IFA:
                         sa, e := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
                         if e != 0 {
                                 return nil
                         }
                         sas = append(sas, sa)
                 case RTAX_NETMASK, RTAX_BRD:
                         // nothing to do
                 }
                 buf = buf[rsaAlignOf(int(rsa.Len)):]
         }
 
         return sas
 }
 
+const rtaIfmaMask = RTA_GATEWAY | RTA_IFP | RTA_IFA
+
+func (m *InterfaceMulticastAddrMessage) sockaddr() (sas []Sockaddr) {
+        if m.Header.Addrs&rtaIfmaMask == 0 {
+                return nil
+        }
+
+        buf := m.Data[:]
+        for i := uint(0); i < RTAX_MAX; i++ {
+                if m.Header.Addrs&rtaIfmaMask&(1<<i) == 0 {
+                        continue
+                }
+                rsa := (*RawSockaddr)(unsafe.Pointer(&buf[0]))
+                switch i {
+                case RTAX_IFA:
+                        sa, e := anyToSockaddr((*RawSockaddrAny)(unsafe.Pointer(rsa)))
+                        if e != 0 {
+                                return nil
+                        }
+                        sas = append(sas, sa)
+                case RTAX_GATEWAY, RTAX_IFP:
+                        // nothing to do
+                }
+                buf = buf[rsaAlignOf(int(rsa.Len)):]
+        }
+
+        return sas
+}
+
 // ParseRoutingMessage parses buf as routing messages and returns
 // the slice containing the RoutingMessage interfaces.
 func ParseRoutingMessage(buf []byte) (msgs []RoutingMessage, errno int) {
         for len(buf) >= anyMessageLen {
                 any := (*anyMessage)(unsafe.Pointer(&buf[0]))
                 if any.Version != RTM_VERSION {
                         return nil, EINVAL
                 }
                 msgs = append(msgs, any.toRoutingMessage(buf))
                 buf = buf[any.Msglen:]
         }
         return msgs, 0
 }
 
 // ParseRoutingMessage parses msg's payload as raw sockaddrs and
 // returns the slice containing the Sockaddr interfaces.
 func ParseRoutingSockaddr(msg RoutingMessage) (sas []Sockaddr, errno int) {
         return append(sas, msg.sockaddr()...), 0
 }