vendor: github.com/moby/moby/api, github.com/moby/moby/client master

full diff: moby/moby@4ca8aed...694e30a

Signed-off-by: Sebastiaan van Stijn <[email protected]>

Author: thaJeztah

cli/command/builder/prune.go

@@ -87,15 +87,15 @@ func runPrune(ctx context.Context, dockerCli command.Cli, options pruneOptions)
 		}
 	}
 
-	report, err := dockerCli.Client().BuildCachePrune(ctx, client.BuildCachePruneOptions{
+	resp, err := dockerCli.Client().BuildCachePrune(ctx, client.BuildCachePruneOptions{
 		All:           options.all,
 		ReservedSpace: options.reservedSpace.Value(),
 		Filters:       pruneFilters,
 	})
 	if err != nil {
 		return 0, "", err
 	}
-
+	report := resp.Report
 	if len(report.CachesDeleted) > 0 {
 		var sb strings.Builder
 		sb.WriteString("Deleted build cache objects:\n")

cli/command/container/create.go

@@ -7,7 +7,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"net/netip"
 	"os"
 	"path"
 	"strings"
@@ -25,7 +24,6 @@ import (
 	"github.com/docker/cli/cli/trust"
 	"github.com/docker/cli/internal/jsonstream"
 	"github.com/docker/cli/opts"
-	"github.com/moby/moby/api/types/container"
 	"github.com/moby/moby/api/types/mount"
 	"github.com/moby/moby/api/types/versions"
 	"github.com/moby/moby/client"
@@ -361,10 +359,6 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerCfg *c
 		}
 	}
 
-	if warn := localhostDNSWarning(*hostConfig); warn != "" {
-		response.Warnings = append(response.Warnings, warn)
-	}
-
 	containerID = response.ID
 	for _, w := range response.Warnings {
 		_, _ = fmt.Fprintln(dockerCli.Err(), "WARNING:", w)
@@ -385,19 +379,6 @@ func createContainer(ctx context.Context, dockerCli command.Cli, containerCfg *c
 	return containerID, err
 }
 
-// check the DNS settings passed via --dns against localhost regexp to warn if
-// they are trying to set a DNS to a localhost address.
-//
-// TODO(thaJeztah): move this to the daemon, which can make a better call if it will work or not (depending on networking mode).
-func localhostDNSWarning(hostConfig container.HostConfig) string {
-	for _, dnsIP := range hostConfig.DNS {
-		if addr, err := netip.ParseAddr(dnsIP); err == nil && addr.IsLoopback() {
-			return fmt.Sprintf("Localhost DNS (%s) may fail in containers.", addr)
-		}
-	}
-	return ""
-}
-
 func validatePullOpt(val string) error {
 	switch val {
 	case PullImageAlways, PullImageMissing, PullImageNever, "":

cli/command/container/opts.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/netip"
 	"os"
 	"path"
 	"path/filepath"
@@ -425,22 +426,46 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
 		entrypoint = []string{""}
 	}
 
-	publishOpts := copts.publish.GetSlice()
-	var (
-		ports         map[container.PortRangeProto]struct{}
-		portBindings  map[container.PortRangeProto][]container.PortBinding
-		convertedOpts []string
-	)
-
-	convertedOpts, err = convertToStandardNotation(publishOpts)
+	// TODO(thaJeztah): remove uses of go-connections/nat here.
+	convertedOpts, err := convertToStandardNotation(copts.publish.GetSlice())
 	if err != nil {
 		return nil, err
 	}
 
-	ports, portBindings, err = nat.ParsePortSpecs(convertedOpts)
+	ports, natPortBindings, err := nat.ParsePortSpecs(convertedOpts)
 	if err != nil {
 		return nil, err
 	}
+	portBindings := network.PortMap{}
+	for port, bindings := range natPortBindings {
+		p, err := network.ParsePort(string(port))
+		if err != nil {
+			return nil, err
+		}
+		portBindings[p] = []network.PortBinding{}
+		for _, b := range bindings {
+			var hostIP netip.Addr
+			if b.HostIP != "" {
+				hostIP, err = netip.ParseAddr(b.HostIP)
+				if err != nil {
+					return nil, err
+				}
+			}
+			portBindings[p] = append(portBindings[p], network.PortBinding{
+				HostIP:   hostIP,
+				HostPort: b.HostPort,
+			})
+		}
+	}
+
+	exposedPorts := network.PortSet{}
+	for port := range ports {
+		p, err := network.ParsePort(string(port))
+		if err != nil {
+			return nil, err
+		}
+		exposedPorts[p] = struct{}{}
+	}
 
 	// Merge in exposed ports to the map of published ports
 	for _, e := range copts.expose.GetSlice() {
@@ -636,7 +661,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
 	config := &container.Config{
 		Hostname:     copts.hostname,
 		Domainname:   copts.domainname,
-		ExposedPorts: ports,
+		ExposedPorts: exposedPorts,
 		User:         copts.user,
 		Tty:          copts.tty,
 		OpenStdin:    copts.stdin,
@@ -672,7 +697,7 @@ func parse(flags *pflag.FlagSet, copts *containerOptions, serverOS string) (*con
 		// but pre created containers can still have those nil values.
 		// See https://github.com/docker/docker/pull/17779
 		// for a more detailed explanation on why we don't want that.
-		DNS:            copts.dns.GetAllOrEmpty(),
+		DNS:            toNetipAddrSlice(copts.dns.GetAllOrEmpty()),
 		DNSSearch:      copts.dnsSearch.GetAllOrEmpty(),
 		DNSOptions:     copts.dnsOptions.GetAllOrEmpty(),
 		ExtraHosts:     copts.extraHosts.GetSlice(),
@@ -815,10 +840,10 @@ func applyContainerOptions(n *opts.NetworkAttachmentOpts, copts *containerOption
 	if len(n.Links) > 0 && copts.links.Len() > 0 {
 		return invalidParameter(errors.New("conflicting options: cannot specify both --link and per-network links"))
 	}
-	if n.IPv4Address != "" && copts.ipv4Address != "" {
+	if n.IPv4Address.IsValid() && copts.ipv4Address != "" {
 		return invalidParameter(errors.New("conflicting options: cannot specify both --ip and per-network IPv4 address"))
 	}
-	if n.IPv6Address != "" && copts.ipv6Address != "" {
+	if n.IPv6Address.IsValid() && copts.ipv6Address != "" {
 		return invalidParameter(errors.New("conflicting options: cannot specify both --ip6 and per-network IPv6 address"))
 	}
 	if n.MacAddress != "" && copts.macAddress != "" {
@@ -838,17 +863,24 @@ func applyContainerOptions(n *opts.NetworkAttachmentOpts, copts *containerOption
 		copy(n.Links, copts.links.GetSlice())
 	}
 	if copts.ipv4Address != "" {
-		n.IPv4Address = copts.ipv4Address
+		var err error
+		n.IPv4Address, err = netip.ParseAddr(copts.ipv4Address)
+		if err != nil {
+			return err
+		}
 	}
 	if copts.ipv6Address != "" {
-		n.IPv6Address = copts.ipv6Address
+		var err error
+		n.IPv6Address, err = netip.ParseAddr(copts.ipv6Address)
+		if err != nil {
+			return err
+		}
 	}
 	if copts.macAddress != "" {
 		n.MacAddress = copts.macAddress
 	}
 	if copts.linkLocalIPs.Len() > 0 {
-		n.LinkLocalIPs = make([]string, copts.linkLocalIPs.Len())
-		copy(n.LinkLocalIPs, copts.linkLocalIPs.GetSlice())
+		n.LinkLocalIPs = toNetipAddrSlice(copts.linkLocalIPs.GetSlice())
 	}
 	return nil
 }
@@ -877,7 +909,7 @@ func parseNetworkAttachmentOpt(ep opts.NetworkAttachmentOpts) (*network.Endpoint
 	if len(ep.Links) > 0 {
 		epConfig.Links = ep.Links
 	}
-	if ep.IPv4Address != "" || ep.IPv6Address != "" || len(ep.LinkLocalIPs) > 0 {
+	if ep.IPv4Address.IsValid() || ep.IPv6Address.IsValid() || len(ep.LinkLocalIPs) > 0 {
 		epConfig.IPAMConfig = &network.EndpointIPAMConfig{
 			IPv4Address:  ep.IPv4Address,
 			IPv6Address:  ep.IPv6Address,
@@ -1141,3 +1173,15 @@ func validateAttach(val string) (string, error) {
 	}
 	return val, errors.New("valid streams are STDIN, STDOUT and STDERR")
 }
+
+func toNetipAddrSlice(ips []string) []netip.Addr {
+	netips := make([]netip.Addr, 0, len(ips))
+	for _, ip := range ips {
+		addr, err := netip.ParseAddr(ip)
+		if err != nil {
+			continue
+		}
+		netips = append(netips, addr)
+	}
+	return netips
+}

cli/command/container/port.go

@@ -5,14 +5,13 @@ import (
 	"fmt"
 	"net"
 	"sort"
-	"strconv"
 	"strings"
 
 	"github.com/docker/cli/cli"
 	"github.com/docker/cli/cli/command"
 	"github.com/docker/cli/cli/command/completion"
 	"github.com/fvbommel/sortorder"
-	"github.com/moby/moby/api/types/container"
+	"github.com/moby/moby/api/types/network"
 	"github.com/spf13/cobra"
 )
 
@@ -60,24 +59,21 @@ func runPort(ctx context.Context, dockerCli command.Cli, opts *portOptions) erro
 
 	var out []string
 	if opts.port != "" {
-		port, proto, _ := strings.Cut(opts.port, "/")
-		if proto == "" {
-			proto = "tcp"
+		port, err := network.ParsePort(opts.port)
+		if err != nil {
+			return err
 		}
-		if _, err = strconv.ParseUint(port, 10, 16); err != nil {
-			return fmt.Errorf("invalid port (%s): %w", port, err)
-		}
-		frontends, exists := c.NetworkSettings.Ports[container.PortRangeProto(port+"/"+proto)]
+		frontends, exists := c.NetworkSettings.Ports[port]
 		if !exists || len(frontends) == 0 {
 			return fmt.Errorf("no public port '%s' published for %s", opts.port, opts.container)
 		}
 		for _, frontend := range frontends {
-			out = append(out, net.JoinHostPort(frontend.HostIP, frontend.HostPort))
+			out = append(out, net.JoinHostPort(frontend.HostIP.String(), frontend.HostPort))
 		}
 	} else {
 		for from, frontends := range c.NetworkSettings.Ports {
 			for _, frontend := range frontends {
-				out = append(out, fmt.Sprintf("%s -> %s", from, net.JoinHostPort(frontend.HostIP, frontend.HostPort)))
+				out = append(out, fmt.Sprintf("%s -> %s", from, net.JoinHostPort(frontend.HostIP.String(), frontend.HostPort)))
 			}
 		}
 	}

cli/command/formatter/container.go

@@ -360,13 +360,13 @@ func DisplayablePorts(ports []container.PortSummary) string {
 	for _, port := range ports {
 		current := port.PrivatePort
 		portKey := port.Type
-		if port.IP != "" {
+		if !port.IP.IsUnspecified() {
 			if port.PublicPort != current {
-				hAddrPort := net.JoinHostPort(port.IP, strconv.Itoa(int(port.PublicPort)))
+				hAddrPort := net.JoinHostPort(port.IP.String(), strconv.Itoa(int(port.PublicPort)))
 				hostMappings = append(hostMappings, fmt.Sprintf("%s->%d/%s", hAddrPort, port.PrivatePort, port.Type))
 				continue
 			}
-			portKey = port.IP + "/" + port.Type
+			portKey = port.IP.String() + "/" + port.Type
 		}
 		group := groupMap[portKey]
 
@@ -416,7 +416,7 @@ func comparePorts(i, j container.PortSummary) bool {
 	}
 
 	if i.IP != j.IP {
-		return i.IP < j.IP
+		return i.IP.String() < j.IP.String()
 	}
 
 	if i.PublicPort != j.PublicPort {

cli/command/network/connect.go

@@ -3,6 +3,8 @@ package network
 import (
 	"context"
 	"errors"
+	"net"
+	"net/netip"
 	"strings"
 
 	"github.com/docker/cli/cli"
@@ -17,11 +19,11 @@ import (
 type connectOptions struct {
 	network      string
 	container    string
-	ipaddress    string
-	ipv6address  string
+	ipaddress    net.IP // TODO(thaJeztah): we need a flag-type to handle netip.Addr directly
+	ipv6address  net.IP // TODO(thaJeztah): we need a flag-type to handle netip.Addr directly
 	links        opts.ListOpts
 	aliases      []string
-	linklocalips []string
+	linklocalips []net.IP // TODO(thaJeztah): we need a flag-type to handle []netip.Addr directly
 	driverOpts   []string
 	gwPriority   int
 }
@@ -51,11 +53,11 @@ func newConnectCommand(dockerCLI command.Cli) *cobra.Command {
 	}
 
 	flags := cmd.Flags()
-	flags.StringVar(&options.ipaddress, "ip", "", `IPv4 address (e.g., "172.30.100.104")`)
-	flags.StringVar(&options.ipv6address, "ip6", "", `IPv6 address (e.g., "2001:db8::33")`)
+	flags.IPVar(&options.ipaddress, "ip", nil, `IPv4 address (e.g., "172.30.100.104")`)
+	flags.IPVar(&options.ipv6address, "ip6", nil, `IPv6 address (e.g., "2001:db8::33")`)
 	flags.Var(&options.links, "link", "Add link to another container")
 	flags.StringSliceVar(&options.aliases, "alias", []string{}, "Add network-scoped alias for the container")
-	flags.StringSliceVar(&options.linklocalips, "link-local-ip", []string{}, "Add a link-local address for the container")
+	flags.IPSliceVar(&options.linklocalips, "link-local-ip", nil, "Add a link-local address for the container")
 	flags.StringSliceVar(&options.driverOpts, "driver-opt", []string{}, "driver options for the network")
 	flags.IntVar(&options.gwPriority, "gw-priority", 0, "Highest gw-priority provides the default gateway. Accepts positive and negative values.")
 	return cmd
@@ -69,9 +71,9 @@ func runConnect(ctx context.Context, apiClient client.NetworkAPIClient, options
 
 	return apiClient.NetworkConnect(ctx, options.network, options.container, &network.EndpointSettings{
 		IPAMConfig: &network.EndpointIPAMConfig{
-			IPv4Address:  options.ipaddress,
-			IPv6Address:  options.ipv6address,
-			LinkLocalIPs: options.linklocalips,
+			IPv4Address:  toNetipAddr(options.ipaddress),
+			IPv6Address:  toNetipAddr(options.ipv6address),
+			LinkLocalIPs: toNetipAddrSlice(options.linklocalips),
 		},
 		Links:      options.links.GetSlice(),
 		Aliases:    options.aliases,
@@ -93,3 +95,48 @@ func convertDriverOpt(options []string) (map[string]string, error) {
 	}
 	return driverOpt, nil
 }
+
+func toNetipAddrSlice(ips []net.IP) []netip.Addr {
+	netips := make([]netip.Addr, 0, len(ips))
+	for _, ip := range ips {
+		netips = append(netips, toNetipAddr(ip))
+	}
+	return netips
+}
+
+func toNetipAddr(ip net.IP) netip.Addr {
+	if len(ip) == 0 {
+		return netip.Addr{}
+	}
+	if ip4 := ip.To4(); ip4 != nil {
+		a, _ := netip.AddrFromSlice(ip4)
+		return a
+	}
+	if ip16 := ip.To16(); ip16 != nil {
+		a, _ := netip.AddrFromSlice(ip16)
+		return a
+	}
+	return netip.Addr{}
+}
+
+func ipNetToPrefix(n net.IPNet) netip.Prefix {
+	if n.IP == nil {
+		return netip.Prefix{}
+	}
+
+	ip := n.IP.To4()
+	if ip == nil {
+		ip = n.IP.To16()
+	}
+	if ip == nil {
+		return netip.Prefix{}
+	}
+
+	addr, ok := netip.AddrFromSlice(ip)
+	if !ok {
+		return netip.Prefix{}
+	}
+
+	ones, _ := n.Mask.Size()
+	return netip.PrefixFrom(addr, ones)
+}