1. package host
    3. import (
    4.     "fmt"
    5.     "net"
    6.     "strconv"
    7. )
    9. // ExtractHostPort from address
    10. func ExtractHostPort(addr string) (host string, port uint64, err error) {
    11.     var ports string
    12.     host, ports, err = net.SplitHostPort(addr)
    13.     if err != nil {
    14.         return
    15.     }
    16.     port, err = strconv.ParseUint(ports, 10, 16) //nolint:gomnd
    17.     if err != nil {
    18.         return
    19.     }
    20.     return
    21. }
    23. func isValidIP(addr string) bool {
    24.     ip := net.ParseIP(addr)
    25.     return ip.IsGlobalUnicast() && !ip.IsInterfaceLocalMulticast()
    26. }
    28. // Port return a real port.
    29. func Port(lis net.Listener) (int, bool) {
    30.     if addr, ok := lis.Addr().(*net.TCPAddr); ok {
    31.         return addr.Port, true
    32.     }
    33.     return 0, false
    34. }
    36. // Extract returns a private addr and port.
    37. func Extract(hostPort string, lis net.Listener) (string, error) {
    38.     addr, port, err := net.SplitHostPort(hostPort)
    39.     if err != nil && lis == nil {
    40.         return "", err
    41.     }
    42.     if lis != nil {
    43.         if p, ok := Port(lis); ok {
    44.             port = strconv.Itoa(p)
    45.         } else {
    46.             return "", fmt.Errorf("failed to extract port: %v", lis.Addr())
    47.         }
    48.     }
    49.     if len(addr) > 0 && (addr != "0.0.0.0" && addr != "[::]" && addr != "::") {
    50.         return net.JoinHostPort(addr, port), nil
    51.     }
    52.     ifaces, err := net.Interfaces()
    53.     if err != nil {
    54.         return "", err
    55.     }
    56.     lowest := int(^uint(0) >> 1)
    57.     var result net.IP
    58.     for _, iface := range ifaces {
    59.         if (iface.Flags & net.FlagUp) == 0 {
    60.             continue
    61.         }
    62.         if iface.Index < lowest || result == nil {
    63.             lowest = iface.Index
    64.         } else if result != nil {
    65.             continue
    66.         }
    67.         addrs, err := iface.Addrs()
    68.         if err != nil {
    69.             continue
    70.         }
    71.         for _, rawAddr := range addrs {
    72.             var ip net.IP
    73.             switch addr := rawAddr.(type) {
    74.             case *net.IPAddr:
    75.                 ip = addr.IP
    76.             case *net.IPNet:
    77.                 ip = addr.IP
    78.             default:
    79.                 continue
    80.             }
    81.             if isValidIP(ip.String()) {
    82.                 result = ip
    83.             }
    84.         }
    85.     }
    86.     if result != nil {
    87.         return net.JoinHostPort(result.String(), port), nil
    88.     }
    89.     return "", nil
    90. }