| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // +build linux |
| |
| package netconfig |
| |
| // We connect to the Netlink Route socket and parse messages to |
| // look for network configuration changes. This is very Linux |
| // specific, hence the file name. |
| |
| import ( |
| "errors" |
| "fmt" |
| "net" |
| "syscall" |
| "unsafe" |
| |
| "v.io/x/lib/vlog" |
| ) |
| |
| /* |
| #include <linux/rtnetlink.h> |
| */ |
| import "C" |
| |
| // All rtnetlink attributes start with this header. |
| type rtAttrHdr C.struct_rtattr |
| |
| const rtAttrHdrLen = C.sizeof_struct_rtattr |
| |
| // The address change messages (RTM_NEWADDR, RTM_DELADDR, RTM_GETADDR). |
| type ifaddrMsgHdr C.struct_ifaddrmsg |
| |
| const ifaddrMsgHdrLen = C.sizeof_struct_ifaddrmsg |
| |
| type rtAttribute fmt.Stringer |
| |
| type rtAddressMessage struct { |
| name string |
| hdr ifaddrMsgHdr |
| attributes []rtAttribute |
| } |
| |
| // Attribute types (see rtnetlink(7)) |
| type ifaAddress net.IP |
| type ifaLocal net.IP |
| type ifaBroadcast net.IP |
| type ifaAnycast net.IP |
| type ifaMulticast net.IP |
| type ifaLabel string |
| type ifaCacheInfo C.struct_ifa_cacheinfo |
| |
| const ifaCacheInfoLen = C.sizeof_struct_ifa_cacheinfo |
| |
| // String routines to make debugging easier. |
| func (a ifaAddress) String() string { return "Address=" + net.IP(a).String() } |
| func (a ifaLocal) String() string { return "Local=" + net.IP(a).String() } |
| func (a ifaBroadcast) String() string { return "Braodcast=" + net.IP(a).String() } |
| func (a ifaAnycast) String() string { return "Anycast=" + net.IP(a).String() } |
| func (a ifaMulticast) String() string { return "Anycast=" + net.IP(a).String() } |
| func (a ifaLabel) String() string { return "Label=" + string(a) } |
| func (a ifaCacheInfo) String() string { |
| return fmt.Sprintf("CacheInfo[preferred %d valid %d cstamp %d tstamp %d]", a.ifa_prefered, a.ifa_valid, a.cstamp, a.tstamp) |
| } |
| func (m *rtAddressMessage) String() string { |
| return fmt.Sprintf("%s: index %d %v", m.name, m.hdr.ifa_index, m.attributes) |
| } |
| |
| // Address looks for the address attribute in an rtAddressMessage. If it isn't there, just assume the null address. |
| func (m *rtAddressMessage) Address() net.IP { |
| for _, a := range m.attributes { |
| switch a.(type) { |
| case ifaAddress: |
| return net.IP(a.(ifaAddress)) |
| } |
| } |
| return net.IPv4zero |
| } |
| |
| func parsertAddressAttribute(b []byte) (rtAttribute, []byte, error) { |
| if len(b) == 0 { |
| return nil, nil, nil |
| } |
| if len(b) < rtAttrHdrLen { |
| return nil, nil, errors.New("attribute too short") |
| } |
| ahdr := (*rtAttrHdr)(unsafe.Pointer(&b[0])) |
| rounded := ((ahdr.rta_len + 3) / 4) * 4 |
| if len(b) < int(rounded) { |
| return nil, nil, errors.New("attribute too short") |
| } |
| remaining := b[rounded:] |
| b = b[rtAttrHdrLen:ahdr.rta_len] |
| switch ahdr.rta_type { |
| case C.IFA_ADDRESS: |
| return rtAttribute(ifaAddress(net.IP(b))), remaining, nil |
| case C.IFA_LOCAL: |
| return rtAttribute(ifaLocal(b)), remaining, nil |
| case C.IFA_LABEL: |
| return rtAttribute(ifaLabel(b)), remaining, nil |
| case C.IFA_BROADCAST: |
| return rtAttribute(ifaBroadcast(b)), remaining, nil |
| case C.IFA_ANYCAST: |
| return rtAttribute(ifaAnycast(b)), remaining, nil |
| case C.IFA_CACHEINFO: |
| if len(b) < ifaCacheInfoLen { |
| return nil, nil, errors.New("attribute too short") |
| } |
| return rtAttribute(ifaCacheInfo(*(*C.struct_ifa_cacheinfo)(unsafe.Pointer(&b[0])))), remaining, nil |
| case C.IFA_MULTICAST: |
| return rtAttribute(ifaMulticast(b)), remaining, nil |
| } |
| return nil, remaining, errors.New("unknown attribute") |
| } |
| |
| func parsertAddressMessage(nlm syscall.NetlinkMessage) (*rtAddressMessage, error) { |
| var name string |
| switch nlm.Header.Type { |
| case C.RTM_NEWADDR: |
| name = "RTM_NEWADDR" |
| case C.RTM_DELADDR: |
| name = "RTM_DELADDR" |
| case C.RTM_GETADDR: |
| name = "RTM_GETADDR" |
| default: |
| return nil, fmt.Errorf("unknown message type") |
| } |
| if len(nlm.Data) < ifaddrMsgHdrLen { |
| return nil, errors.New("bad length") |
| } |
| m := &rtAddressMessage{name: name, hdr: *(*ifaddrMsgHdr)(unsafe.Pointer(&nlm.Data[0]))} |
| b := nlm.Data[ifaddrMsgHdrLen:] |
| for { |
| var a rtAttribute |
| var err error |
| a, b, err = parsertAddressAttribute(b) |
| if b == nil { |
| break |
| } |
| if err == nil { |
| m.attributes = append(m.attributes, a) |
| } |
| } |
| return m, nil |
| } |
| |
| // The link change messages (RTM_NEWLINK, RTM_DELLINK, RTM_GETLINK). |
| type ifInfoMsgHdr C.struct_ifinfomsg |
| |
| const ifInfoMsgHdrLen = C.sizeof_struct_ifinfomsg |
| |
| type rtLinkMessage struct { |
| name string |
| hdr ifInfoMsgHdr |
| attributes []rtAttribute |
| } |
| |
| // Attribute types (see rtnetlink(7)) |
| type iflaAddress []byte |
| type iflaBroadcast []byte |
| type iflaIFName string |
| type iflaMTU uint32 |
| type iflaLink int |
| type iflaQDisc string |
| type iflaOperstate int |
| type iflaStats C.struct_rtnl_link_stats |
| |
| const iflaStatsLen = C.sizeof_struct_rtnl_link_stats |
| |
| // String routines to make debugging easier. |
| func (a iflaAddress) String() string { return fmt.Sprintf("HWAddress=%v", []byte(a)) } |
| func (a iflaBroadcast) String() string { return fmt.Sprintf("HWBroadcast=%v", []byte(a)) } |
| func (a iflaIFName) String() string { return "Name=" + string(a) } |
| func (a iflaMTU) String() string { return fmt.Sprintf("MTU=%d", uint32(a)) } |
| func (a iflaLink) String() string { return fmt.Sprintf("Type=%d", int(a)) } |
| func (a iflaQDisc) String() string { return "Qdisc=" + string(a) } |
| func (a iflaStats) String() string { |
| return fmt.Sprintf("Stats[rx %d tx %d ...]", a.rx_packets, a.tx_packets) |
| } |
| func (a iflaOperstate) String() string { return fmt.Sprintf("Operstate=%d", int(a)) } |
| func (m *rtLinkMessage) String() string { |
| return fmt.Sprintf("%s: index %d %v", m.name, m.hdr.ifi_index, m.attributes) |
| } |
| |
| func parseRTLinkAttribute(b []byte) (rtAttribute, []byte, error) { |
| if len(b) == 0 { |
| return nil, nil, nil |
| } |
| if len(b) < rtAttrHdrLen { |
| return nil, nil, errors.New("attribute too short") |
| } |
| ahdr := (*rtAttrHdr)(unsafe.Pointer(&b[0])) |
| rounded := ((ahdr.rta_len + 3) / 4) * 4 |
| if len(b) < int(rounded) { |
| return nil, nil, errors.New("attribute too short") |
| } |
| remaining := b[rounded:] |
| b = b[rtAttrHdrLen:ahdr.rta_len] |
| switch ahdr.rta_type { |
| case C.IFLA_ADDRESS: |
| return rtAttribute(iflaAddress(b)), remaining, nil |
| case C.IFLA_BROADCAST: |
| return rtAttribute(iflaBroadcast(b)), remaining, nil |
| case C.IFLA_IFNAME: |
| return rtAttribute(iflaIFName(string(b))), remaining, nil |
| case C.IFLA_MTU: |
| return rtAttribute(iflaMTU(*(*C.uint)(unsafe.Pointer(&b[0])))), remaining, nil |
| case C.IFLA_LINK: |
| return rtAttribute(iflaMTU(*(*C.int)(unsafe.Pointer(&b[0])))), remaining, nil |
| case C.IFLA_QDISC: |
| return rtAttribute(iflaQDisc(string(b))), remaining, nil |
| case C.IFLA_STATS: |
| if len(b) < iflaStatsLen { |
| return nil, remaining, errors.New("attribute too short") |
| } |
| return rtAttribute(iflaStats(*(*C.struct_rtnl_link_stats)(unsafe.Pointer(&b[0])))), remaining, nil |
| case C.IFLA_OPERSTATE: |
| return rtAttribute(iflaOperstate(*(*C.int)(unsafe.Pointer(&b[0])))), remaining, nil |
| } |
| return nil, remaining, errors.New("unknown attribute") |
| } |
| |
| func parsertLinkMessage(nlm syscall.NetlinkMessage) (*rtLinkMessage, error) { |
| var name string |
| switch nlm.Header.Type { |
| case C.RTM_NEWLINK: |
| name = "RTM_NEWLINK" |
| case C.RTM_DELLINK: |
| name = "RTM_DELLINK" |
| case C.RTM_GETLINK: |
| name = "RTM_GETLINK" |
| default: |
| return nil, fmt.Errorf("unknown message type") |
| } |
| if len(nlm.Data) < ifInfoMsgHdrLen { |
| return nil, errors.New("bad length") |
| } |
| m := &rtLinkMessage{name: name, hdr: *(*ifInfoMsgHdr)(unsafe.Pointer(&nlm.Data[0]))} |
| b := nlm.Data[ifInfoMsgHdrLen:] |
| for { |
| var a rtAttribute |
| var err error |
| a, b, err = parseRTLinkAttribute(b) |
| if b == nil { |
| break |
| } |
| if err == nil { |
| m.attributes = append(m.attributes, a) |
| } |
| } |
| return m, nil |
| } |
| |
| const ( |
| GROUPS = C.RTMGRP_LINK | C.RTMGRP_IPV4_IFADDR | C.RTMGRP_IPV4_MROUTE | C.RTMGRP_IPV4_ROUTE | C.RTMGRP_IPV6_IFADDR | C.RTMGRP_IPV6_MROUTE | C.RTMGRP_IPV6_ROUTE | C.RTMGRP_NOTIFY |
| ) |
| |
| func (n *notifier) initLocked() error { |
| s, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_RAW, syscall.NETLINK_ROUTE) |
| if err != nil { |
| return fmt.Errorf("socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE) failed: %v", err) |
| } |
| |
| lsa := &syscall.SockaddrNetlink{Family: syscall.AF_NETLINK, Groups: GROUPS} |
| if err := syscall.Bind(s, lsa); err != nil { |
| syscall.Close(s) |
| return fmt.Errorf("bind(%d, {AF_NETLINK, 0x%x}) failed: %v", s, lsa.Groups) |
| } |
| go watcher(n, s) |
| return nil |
| } |
| |
| func watcher(n *notifier, sock int) { |
| defer syscall.Close(sock) |
| var newAddrs []net.IP |
| buf := make([]byte, 4096) |
| for { |
| nr, _, err := syscall.Recvfrom(sock, buf, 0) |
| if err != nil { |
| vlog.Infof("recvfrom(%d) on an AF_NETLINK socket failed: %v", sock, err) |
| return |
| } |
| msgs, err := syscall.ParseNetlinkMessage(buf[:nr]) |
| if err != nil { |
| vlog.Infof("ParseNetlinkMessage failed: %s", err) |
| continue |
| } |
| L: |
| for _, m := range msgs { |
| if am, err := parsertAddressMessage(m); err == nil { |
| // NOTE(p): We get continuous NEWADDR messages about some |
| // IPv6 addresses in Google corp. Just ignore duplicate back |
| // to back NEWADDRs about the same addresses. |
| if am.name == "RTM_NEWADDR" { |
| addr := am.Address() |
| for _, a := range newAddrs { |
| if addr.Equal(a) { |
| break L |
| } |
| } |
| newAddrs = append(newAddrs, addr) |
| } else { |
| newAddrs = nil |
| } |
| } else if _, err := parsertLinkMessage(m); err == nil { |
| newAddrs = nil |
| } else { |
| continue |
| } |
| n.ding() |
| } |
| } |
| } |
| |
| func toIP(a []byte) (net.IP, error) { |
| switch len(a) { |
| case 4: |
| return net.IPv4(a[0], a[1], a[2], a[3]), nil |
| case 16: |
| return net.IP(a), nil |
| } |
| return net.IPv6unspecified, errors.New("unknown ip address len") |
| } |
| |
| // IPRoutes returns all kernel known routes. If defaultOnly is set, only default routes |
| // are returned. |
| func GetIPRoutes(defaultOnly bool) []*IPRoute { |
| var iproutes []*IPRoute |
| rib, err := syscall.NetlinkRIB(syscall.RTM_GETROUTE, syscall.AF_UNSPEC) |
| if err != nil { |
| vlog.Infof("Couldn't read: %s", err) |
| return iproutes |
| } |
| msgs, err := syscall.ParseNetlinkMessage(rib) |
| if err != nil { |
| vlog.Infof("Couldn't parse: %s", err) |
| return iproutes |
| } |
| L: |
| for _, m := range msgs { |
| if m.Header.Type != syscall.RTM_NEWROUTE { |
| continue |
| } |
| attrs, err := syscall.ParseNetlinkRouteAttr(&m) |
| if err != nil { |
| continue |
| } |
| r := new(IPRoute) |
| for _, a := range attrs { |
| switch a.Attr.Type { |
| case syscall.RTA_DST: |
| if r.Net.IP, err = toIP(a.Value[:]); err != nil { |
| continue L |
| } |
| case syscall.RTA_GATEWAY: |
| if r.Gateway, err = toIP(a.Value[:]); err != nil { |
| continue L |
| } |
| case syscall.RTA_OIF: |
| r.IfcIndex = int(a.Value[0]) |
| case syscall.RTA_PREFSRC: |
| if r.PreferredSource, err = toIP(a.Value[:]); err != nil { |
| continue L |
| } |
| } |
| } |
| |
| // There is no RTA_DST attribute if destination is a default gateway. |
| // Set the destination IP with zero IP, if not set yet. |
| if r.Net.IP == nil { |
| if r.Gateway == nil { |
| continue |
| } |
| if r.Gateway.To4() != nil { |
| r.Net.IP = net.IPv4zero |
| } else { |
| r.Net.IP = net.IPv6zero |
| } |
| } |
| |
| addrLen := 128 |
| if r.Net.IP.To4() != nil { |
| addrLen = 32 |
| } |
| |
| b := m.Data[:syscall.SizeofRtMsg] |
| a := (*syscall.RtMsg)(unsafe.Pointer(&b[0])) |
| if int(a.Dst_len) > addrLen { |
| continue |
| } |
| r.Net.Mask = net.CIDRMask(int(a.Dst_len), addrLen) |
| if !defaultOnly || IsDefaultIPRoute(r) { |
| iproutes = append(iproutes, r) |
| } |
| } |
| return iproutes |
| } |
