package sctp import ( "net" "os" "sync" "syscall" ) //from https://github.com/golang/go // Boolean to int. func boolint(b bool) int { if b { return 1 } return 0 } //from https://github.com/golang/go func ipToSockaddr(family int, ip net.IP, port int, zone string) (syscall.Sockaddr, error) { switch family { case syscall.AF_INET: if len(ip) == 0 { ip = net.IPv4zero } ip4 := ip.To4() if ip4 == nil { return nil, &net.AddrError{Err: "non-IPv4 address", Addr: ip.String()} } sa := &syscall.SockaddrInet4{Port: port} copy(sa.Addr[:], ip4) return sa, nil case syscall.AF_INET6: // In general, an IP wildcard address, which is either // "0.0.0.0" or "::", means the entire IP addressing // space. For some historical reason, it is used to // specify "any available address" on some operations // of IP node. // // When the IP node supports IPv4-mapped IPv6 address, // we allow an listener to listen to the wildcard // address of both IP addressing spaces by specifying // IPv6 wildcard address. if len(ip) == 0 || ip.Equal(net.IPv4zero) { ip = net.IPv6zero } // We accept any IPv6 address including IPv4-mapped // IPv6 address. ip6 := ip.To16() if ip6 == nil { return nil, &net.AddrError{Err: "non-IPv6 address", Addr: ip.String()} } //we set ZoneId to 0, as currently we use this functon only to probe the IP capabilities of the host //if real Zone handling is required, the zone cache implementation in golang/net should be pulled here sa := &syscall.SockaddrInet6{Port: port, ZoneId: 0} copy(sa.Addr[:], ip6) return sa, nil } return nil, &net.AddrError{Err: "invalid address family", Addr: ip.String()} } //from https://github.com/golang/go func sockaddr(a *net.TCPAddr, family int) (syscall.Sockaddr, error) { if a == nil { return nil, nil } return ipToSockaddr(family, a.IP, a.Port, a.Zone) } //from https://github.com/golang/go type ipStackCapabilities struct { sync.Once // guards following ipv4Enabled bool ipv6Enabled bool ipv4MappedIPv6Enabled bool } //from https://github.com/golang/go var ipStackCaps ipStackCapabilities //from https://github.com/golang/go // supportsIPv4 reports whether the platform supports IPv4 networking // functionality. func supportsIPv4() bool { ipStackCaps.Once.Do(ipStackCaps.probe) return ipStackCaps.ipv4Enabled } //from https://github.com/golang/go // supportsIPv6 reports whether the platform supports IPv6 networking // functionality. func supportsIPv6() bool { ipStackCaps.Once.Do(ipStackCaps.probe) return ipStackCaps.ipv6Enabled } //from https://github.com/golang/go // supportsIPv4map reports whether the platform supports mapping an // IPv4 address inside an IPv6 address at transport layer // protocols. See RFC 4291, RFC 4038 and RFC 3493. func supportsIPv4map() bool { ipStackCaps.Once.Do(ipStackCaps.probe) return ipStackCaps.ipv4MappedIPv6Enabled } //from https://github.com/golang/go // Probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication // capabilities which are controlled by the IPV6_V6ONLY socket option // and kernel configuration. // // Should we try to use the IPv4 socket interface if we're only // dealing with IPv4 sockets? As long as the host system understands // IPv4-mapped IPv6, it's okay to pass IPv4-mapeed IPv6 addresses to // the IPv6 interface. That simplifies our code and is most // general. Unfortunately, we need to run on kernels built without // IPv6 support too. So probe the kernel to figure it out. func (p *ipStackCapabilities) probe() { s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP) switch err { case syscall.EAFNOSUPPORT, syscall.EPROTONOSUPPORT: case nil: syscall.Close(s) p.ipv4Enabled = true } var probes = []struct { laddr net.TCPAddr value int }{ // IPv6 communication capability {laddr: net.TCPAddr{IP: net.IPv6loopback}, value: 1}, // IPv4-mapped IPv6 address communication capability {laddr: net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)}, value: 0}, } for i := range probes { s, err := syscall.Socket(syscall.AF_INET6, syscall.SOCK_STREAM, syscall.IPPROTO_TCP) if err != nil { continue } defer syscall.Close(s) syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, probes[i].value) sa, err := sockaddr(&(probes[i].laddr), syscall.AF_INET6) if err != nil { continue } if err := syscall.Bind(s, sa); err != nil { continue } if i == 0 { p.ipv6Enabled = true } else { p.ipv4MappedIPv6Enabled = true } } } //from https://github.com/golang/go //Change: we check the first IP address in the list of candidate SCTP IP addresses func (a *SCTPAddr) isWildcard() bool { if a == nil { return true } if 0 == len(a.IPAddrs) { return true } return a.IPAddrs[0].IP.IsUnspecified() } func (a *SCTPAddr) family() int { if a != nil { for _, ip := range a.IPAddrs { if ip.IP.To4() == nil { return syscall.AF_INET6 } } } return syscall.AF_INET } //from https://github.com/golang/go func favoriteAddrFamily(network string, laddr *SCTPAddr, raddr *SCTPAddr, mode string) (family int, ipv6only bool) { switch network[len(network)-1] { case '4': return syscall.AF_INET, false case '6': return syscall.AF_INET6, true } if mode == "listen" && (laddr == nil || laddr.isWildcard()) { if supportsIPv4map() || !supportsIPv4() { return syscall.AF_INET6, false } if laddr == nil { return syscall.AF_INET, false } return laddr.family(), false } if (laddr == nil || laddr.family() == syscall.AF_INET) && (raddr == nil || raddr.family() == syscall.AF_INET) { return syscall.AF_INET, false } return syscall.AF_INET6, false } //from https://github.com/golang/go //Changes: it is for SCTP only func setDefaultSockopts(s int, family int, ipv6only bool) error { if family == syscall.AF_INET6 { // Allow both IP versions even if the OS default // is otherwise. Note that some operating systems // never admit this option. syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, boolint(ipv6only)) } // Allow broadcast. return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)) }