mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
166 lines
5.6 KiB
Go
166 lines
5.6 KiB
Go
![]() |
package opts
|
||
|
|
||
|
import (
|
||
|
"fmt"
|
||
|
"net"
|
||
|
"net/url"
|
||
|
"strconv"
|
||
|
"strings"
|
||
|
)
|
||
|
|
||
|
var (
|
||
|
// DefaultHTTPPort Default HTTP Port used if only the protocol is provided to -H flag e.g. dockerd -H tcp://
|
||
|
// These are the IANA registered port numbers for use with Docker
|
||
|
// see http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml?search=docker
|
||
|
DefaultHTTPPort = 2375 // Default HTTP Port
|
||
|
// DefaultTLSHTTPPort Default HTTP Port used when TLS enabled
|
||
|
DefaultTLSHTTPPort = 2376 // Default TLS encrypted HTTP Port
|
||
|
// DefaultUnixSocket Path for the unix socket.
|
||
|
// Docker daemon by default always listens on the default unix socket
|
||
|
DefaultUnixSocket = "/var/run/docker.sock"
|
||
|
// DefaultTCPHost constant defines the default host string used by docker on Windows
|
||
|
DefaultTCPHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultHTTPPort)
|
||
|
// DefaultTLSHost constant defines the default host string used by docker for TLS sockets
|
||
|
DefaultTLSHost = fmt.Sprintf("tcp://%s:%d", DefaultHTTPHost, DefaultTLSHTTPPort)
|
||
|
// DefaultNamedPipe defines the default named pipe used by docker on Windows
|
||
|
DefaultNamedPipe = `//./pipe/docker_engine`
|
||
|
)
|
||
|
|
||
|
// ValidateHost validates that the specified string is a valid host and returns it.
|
||
|
func ValidateHost(val string) (string, error) {
|
||
|
host := strings.TrimSpace(val)
|
||
|
// The empty string means default and is not handled by parseDockerDaemonHost
|
||
|
if host != "" {
|
||
|
_, err := parseDockerDaemonHost(host)
|
||
|
if err != nil {
|
||
|
return val, err
|
||
|
}
|
||
|
}
|
||
|
// Note: unlike most flag validators, we don't return the mutated value here
|
||
|
// we need to know what the user entered later (using ParseHost) to adjust for TLS
|
||
|
return val, nil
|
||
|
}
|
||
|
|
||
|
// ParseHost and set defaults for a Daemon host string
|
||
|
func ParseHost(defaultToTLS bool, val string) (string, error) {
|
||
|
host := strings.TrimSpace(val)
|
||
|
if host == "" {
|
||
|
if defaultToTLS {
|
||
|
host = DefaultTLSHost
|
||
|
} else {
|
||
|
host = DefaultHost
|
||
|
}
|
||
|
} else {
|
||
|
var err error
|
||
|
host, err = parseDockerDaemonHost(host)
|
||
|
if err != nil {
|
||
|
return val, err
|
||
|
}
|
||
|
}
|
||
|
return host, nil
|
||
|
}
|
||
|
|
||
|
// parseDockerDaemonHost parses the specified address and returns an address that will be used as the host.
|
||
|
// Depending of the address specified, this may return one of the global Default* strings defined in hosts.go.
|
||
|
func parseDockerDaemonHost(addr string) (string, error) {
|
||
|
addrParts := strings.SplitN(addr, "://", 2)
|
||
|
if len(addrParts) == 1 && addrParts[0] != "" {
|
||
|
addrParts = []string{"tcp", addrParts[0]}
|
||
|
}
|
||
|
|
||
|
switch addrParts[0] {
|
||
|
case "tcp":
|
||
|
return ParseTCPAddr(addrParts[1], DefaultTCPHost)
|
||
|
case "unix":
|
||
|
return parseSimpleProtoAddr("unix", addrParts[1], DefaultUnixSocket)
|
||
|
case "npipe":
|
||
|
return parseSimpleProtoAddr("npipe", addrParts[1], DefaultNamedPipe)
|
||
|
case "fd":
|
||
|
return addr, nil
|
||
|
default:
|
||
|
return "", fmt.Errorf("Invalid bind address format: %s", addr)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// parseSimpleProtoAddr parses and validates that the specified address is a valid
|
||
|
// socket address for simple protocols like unix and npipe. It returns a formatted
|
||
|
// socket address, either using the address parsed from addr, or the contents of
|
||
|
// defaultAddr if addr is a blank string.
|
||
|
func parseSimpleProtoAddr(proto, addr, defaultAddr string) (string, error) {
|
||
|
addr = strings.TrimPrefix(addr, proto+"://")
|
||
|
if strings.Contains(addr, "://") {
|
||
|
return "", fmt.Errorf("Invalid proto, expected %s: %s", proto, addr)
|
||
|
}
|
||
|
if addr == "" {
|
||
|
addr = defaultAddr
|
||
|
}
|
||
|
return fmt.Sprintf("%s://%s", proto, addr), nil
|
||
|
}
|
||
|
|
||
|
// ParseTCPAddr parses and validates that the specified address is a valid TCP
|
||
|
// address. It returns a formatted TCP address, either using the address parsed
|
||
|
// from tryAddr, or the contents of defaultAddr if tryAddr is a blank string.
|
||
|
// tryAddr is expected to have already been Trim()'d
|
||
|
// defaultAddr must be in the full `tcp://host:port` form
|
||
|
func ParseTCPAddr(tryAddr string, defaultAddr string) (string, error) {
|
||
|
if tryAddr == "" || tryAddr == "tcp://" {
|
||
|
return defaultAddr, nil
|
||
|
}
|
||
|
addr := strings.TrimPrefix(tryAddr, "tcp://")
|
||
|
if strings.Contains(addr, "://") || addr == "" {
|
||
|
return "", fmt.Errorf("Invalid proto, expected tcp: %s", tryAddr)
|
||
|
}
|
||
|
|
||
|
defaultAddr = strings.TrimPrefix(defaultAddr, "tcp://")
|
||
|
defaultHost, defaultPort, err := net.SplitHostPort(defaultAddr)
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
// url.Parse fails for trailing colon on IPv6 brackets on Go 1.5, but
|
||
|
// not 1.4. See https://github.com/golang/go/issues/12200 and
|
||
|
// https://github.com/golang/go/issues/6530.
|
||
|
if strings.HasSuffix(addr, "]:") {
|
||
|
addr += defaultPort
|
||
|
}
|
||
|
|
||
|
u, err := url.Parse("tcp://" + addr)
|
||
|
if err != nil {
|
||
|
return "", err
|
||
|
}
|
||
|
host, port, err := net.SplitHostPort(u.Host)
|
||
|
if err != nil {
|
||
|
// try port addition once
|
||
|
host, port, err = net.SplitHostPort(net.JoinHostPort(u.Host, defaultPort))
|
||
|
}
|
||
|
if err != nil {
|
||
|
return "", fmt.Errorf("Invalid bind address format: %s", tryAddr)
|
||
|
}
|
||
|
|
||
|
if host == "" {
|
||
|
host = defaultHost
|
||
|
}
|
||
|
if port == "" {
|
||
|
port = defaultPort
|
||
|
}
|
||
|
p, err := strconv.Atoi(port)
|
||
|
if err != nil && p == 0 {
|
||
|
return "", fmt.Errorf("Invalid bind address format: %s", tryAddr)
|
||
|
}
|
||
|
|
||
|
return fmt.Sprintf("tcp://%s%s", net.JoinHostPort(host, port), u.Path), nil
|
||
|
}
|
||
|
|
||
|
// ValidateExtraHost validates that the specified string is a valid extrahost and returns it.
|
||
|
// ExtraHost is in the form of name:ip where the ip has to be a valid ip (IPv4 or IPv6).
|
||
|
func ValidateExtraHost(val string) (string, error) {
|
||
|
// allow for IPv6 addresses in extra hosts by only splitting on first ":"
|
||
|
arr := strings.SplitN(val, ":", 2)
|
||
|
if len(arr) != 2 || len(arr[0]) == 0 {
|
||
|
return "", fmt.Errorf("bad format for add-host: %q", val)
|
||
|
}
|
||
|
if _, err := ValidateIPAddress(arr[1]); err != nil {
|
||
|
return "", fmt.Errorf("invalid IP address in add-host: %q", arr[1])
|
||
|
}
|
||
|
return val, nil
|
||
|
}
|