github.com/itscaro/cli@v0.0.0-20190705081621-c9db0fe93829/opts/hosts.go (about) 1 package opts 2 3 import ( 4 "fmt" 5 "net" 6 "net/url" 7 "strconv" 8 "strings" 9 ) 10 11 var ( 12 // DefaultHTTPPort Default HTTP Port used if only the protocol is provided to -H flag e.g. dockerd -H tcp:// 13 // These are the IANA registered port numbers for use with Docker 14 // see http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=docker 15 DefaultHTTPPort = 2375 // Default HTTP Port 16 // DefaultTLSHTTPPort Default HTTP Port used when TLS enabled 17 DefaultTLSHTTPPort = 2376 // Default TLS encrypted HTTP Port 18 // DefaultUnixSocket Path for the unix socket. 19 // Docker daemon by default always listens on the default unix socket 20 DefaultUnixSocket = "/var/run/docker.sock" 21 // DefaultTCPHost constant defines the default host string used by docker on Windows 22 DefaultTCPHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultHTTPPort) 23 // DefaultTLSHost constant defines the default host string used by docker for TLS sockets 24 DefaultTLSHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultTLSHTTPPort) 25 // DefaultNamedPipe defines the default named pipe used by docker on Windows 26 DefaultNamedPipe = `//./pipe/docker_engine` 27 ) 28 29 // ValidateHost validates that the specified string is a valid host and returns it. 30 func ValidateHost(val string) (string, error) { 31 host := strings.TrimSpace(val) 32 // The empty string means default and is not handled by parseDockerDaemonHost 33 if host != "" { 34 _, err := parseDockerDaemonHost(host) 35 if err != nil { 36 return val, err 37 } 38 } 39 // Note: unlike most flag validators, we don't return the mutated value here 40 // we need to know what the user entered later (using ParseHost) to adjust for TLS 41 return val, nil 42 } 43 44 // ParseHost and set defaults for a Daemon host string 45 func ParseHost(defaultToTLS bool, val string) (string, error) { 46 host := strings.TrimSpace(val) 47 if host == "" { 48 if defaultToTLS { 49 host = DefaultTLSHost 50 } else { 51 host = DefaultHost 52 } 53 } else { 54 var err error 55 host, err = parseDockerDaemonHost(host) 56 if err != nil { 57 return val, err 58 } 59 } 60 return host, nil 61 } 62 63 // parseDockerDaemonHost parses the specified address and returns an address that will be used as the host. 64 // Depending of the address specified, this may return one of the global Default* strings defined in hosts.go. 65 func parseDockerDaemonHost(addr string) (string, error) { 66 addrParts := strings.SplitN(addr, "://", 2) 67 if len(addrParts) == 1 && addrParts[0] != "" { 68 addrParts = []string{"tcp", addrParts[0]} 69 } 70 71 switch addrParts[0] { 72 case "tcp": 73 return ParseTCPAddr(addrParts[1], DefaultTCPHost) 74 case "unix": 75 return parseSimpleProtoAddr("unix", addrParts[1], DefaultUnixSocket) 76 case "npipe": 77 return parseSimpleProtoAddr("npipe", addrParts[1], DefaultNamedPipe) 78 case "fd": 79 return addr, nil 80 case "ssh": 81 return addr, nil 82 default: 83 return "", fmt.Errorf("Invalid bind address format: %s", addr) 84 } 85 } 86 87 // parseSimpleProtoAddr parses and validates that the specified address is a valid 88 // socket address for simple protocols like unix and npipe. It returns a formatted 89 // socket address, either using the address parsed from addr, or the contents of 90 // defaultAddr if addr is a blank string. 91 func parseSimpleProtoAddr(proto, addr, defaultAddr string) (string, error) { 92 addr = strings.TrimPrefix(addr, proto+"://") 93 if strings.Contains(addr, "://") { 94 return "", fmt.Errorf("Invalid proto, expected %s: %s", proto, addr) 95 } 96 if addr == "" { 97 addr = defaultAddr 98 } 99 return fmt.Sprintf("%s://%s", proto, addr), nil 100 } 101 102 // ParseTCPAddr parses and validates that the specified address is a valid TCP 103 // address. It returns a formatted TCP address, either using the address parsed 104 // from tryAddr, or the contents of defaultAddr if tryAddr is a blank string. 105 // tryAddr is expected to have already been Trim()'d 106 // defaultAddr must be in the full `tcp://host:port` form 107 func ParseTCPAddr(tryAddr string, defaultAddr string) (string, error) { 108 if tryAddr == "" || tryAddr == "tcp://" { 109 return defaultAddr, nil 110 } 111 addr := strings.TrimPrefix(tryAddr, "tcp://") 112 if strings.Contains(addr, "://") || addr == "" { 113 return "", fmt.Errorf("Invalid proto, expected tcp: %s", tryAddr) 114 } 115 116 defaultAddr = strings.TrimPrefix(defaultAddr, "tcp://") 117 defaultHost, defaultPort, err := net.SplitHostPort(defaultAddr) 118 if err != nil { 119 return "", err 120 } 121 // url.Parse fails for trailing colon on IPv6 brackets on Go 1.5, but 122 // not 1.4. See https://github.com/golang/go/issues/12200 and 123 // https://github.com/golang/go/issues/6530. 124 if strings.HasSuffix(addr, "]:") { 125 addr += defaultPort 126 } 127 128 u, err := url.Parse("tcp://" + addr) 129 if err != nil { 130 return "", err 131 } 132 host, port, err := net.SplitHostPort(u.Host) 133 if err != nil { 134 // try port addition once 135 host, port, err = net.SplitHostPort(net.JoinHostPort(u.Host, defaultPort)) 136 } 137 if err != nil { 138 return "", fmt.Errorf("Invalid bind address format: %s", tryAddr) 139 } 140 141 if host == "" { 142 host = defaultHost 143 } 144 if port == "" { 145 port = defaultPort 146 } 147 p, err := strconv.Atoi(port) 148 if err != nil && p == 0 { 149 return "", fmt.Errorf("Invalid bind address format: %s", tryAddr) 150 } 151 152 return fmt.Sprintf("tcp://%s%s", net.JoinHostPort(host, port), u.Path), nil 153 } 154 155 // ValidateExtraHost validates that the specified string is a valid extrahost and returns it. 156 // ExtraHost is in the form of name:ip where the ip has to be a valid ip (IPv4 or IPv6). 157 func ValidateExtraHost(val string) (string, error) { 158 // allow for IPv6 addresses in extra hosts by only splitting on first ":" 159 arr := strings.SplitN(val, ":", 2) 160 if len(arr) != 2 || len(arr[0]) == 0 { 161 return "", fmt.Errorf("bad format for add-host: %q", val) 162 } 163 if _, err := ValidateIPAddress(arr[1]); err != nil { 164 return "", fmt.Errorf("invalid IP address in add-host: %q", arr[1]) 165 } 166 return val, nil 167 }