@@ -23,6 +23,7 @@ import (

 	"github.com/moby/buildkit/frontend/dockerfile/instructions"

 	"github.com/moby/buildkit/frontend/dockerfile/parser"

 	"github.com/moby/buildkit/frontend/dockerfile/shell"

+	"github.com/moby/moby/api/types/container"

 	"github.com/moby/moby/api/types/jsonstream"

 	"github.com/moby/sys/signal"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

@@ -530,7 +531,7 @@ func dispatchExpose(ctx context.Context, d dispatchRequest, c *instructions.Expo

 	}

 	if d.state.runConfig.ExposedPorts == nil {

-		d.state.runConfig.ExposedPorts = make(nat.PortSet)

+		d.state.runConfig.ExposedPorts = make(container.PortSet)

 	}

 	for p := range ps {

 		d.state.runConfig.ExposedPorts[p] = struct{}{}

@@ -12,7 +12,6 @@ import (

 	"github.com/docker/docker/daemon/internal/image"

 	"github.com/docker/docker/daemon/pkg/oci"

 	"github.com/docker/docker/daemon/server/backend"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/buildkit/frontend/dockerfile/instructions"

 	"github.com/moby/buildkit/frontend/dockerfile/parser"

 	"github.com/moby/buildkit/frontend/dockerfile/shell"

@@ -337,9 +336,7 @@ func TestExpose(t *testing.T) {

 	assert.Assert(t, sb.state.runConfig.ExposedPorts != nil)

 	assert.Assert(t, is.Len(sb.state.runConfig.ExposedPorts, 1))

-	portsMapping, err := nat.ParsePortSpec(exposedPort)

-	assert.NilError(t, err)

-	assert.Check(t, is.Contains(sb.state.runConfig.ExposedPorts, portsMapping[0].Port))

+	assert.Check(t, is.Contains(sb.state.runConfig.ExposedPorts, container.PortRangeProto("80/tcp")))

 }

 func TestUser(t *testing.T) {

@@ -17,7 +17,6 @@ import (

 	"github.com/docker/docker/daemon/internal/stringid"

 	networkSettings "github.com/docker/docker/daemon/network"

 	"github.com/docker/docker/daemon/server/backend"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/go-archive"

 	"github.com/moby/go-archive/chrootarchive"

 	"github.com/moby/moby/api/types/build"

@@ -294,7 +293,7 @@ func copyRunConfig(runConfig *container.Config, modifiers ...runConfigModifier)

 	}

 	if cfgCopy.ExposedPorts != nil {

-		cfgCopy.ExposedPorts = make(nat.PortSet, len(runConfig.ExposedPorts))

+		cfgCopy.ExposedPorts = make(container.PortSet, len(runConfig.ExposedPorts))

 		for k, v := range runConfig.ExposedPorts {

 			cfgCopy.ExposedPorts[k] = v

 		}

@@ -12,7 +12,6 @@ import (

 	"github.com/docker/docker/daemon/internal/image"

 	"github.com/docker/docker/daemon/internal/layer"

 	"github.com/docker/docker/daemon/server/backend"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/go-archive"

 	"github.com/moby/moby/api/types/build"

 	"github.com/moby/moby/api/types/container"

@@ -138,7 +137,7 @@ func fullMutableRunConfig() *container.Config {

 	return &container.Config{

 		Cmd: []string{"command", "arg1"},

 		Env: []string{"env1=foo", "env2=bar"},

-		ExposedPorts: nat.PortSet{

+		ExposedPorts: container.PortSet{

 			"1000/tcp": {},

 			"1001/tcp": {},

 		},

@@ -14,9 +14,8 @@ import (

 	executorpkg "github.com/docker/docker/daemon/cluster/executor"

 	clustertypes "github.com/docker/docker/daemon/cluster/provider"

 	"github.com/docker/docker/daemon/libnetwork/scope"

-	"github.com/docker/go-connections/nat"

 	gogotypes "github.com/gogo/protobuf/types"

-	containertypes "github.com/moby/moby/api/types/container"

+	"github.com/moby/moby/api/types/container"

 	"github.com/moby/moby/api/types/events"

 	"github.com/moby/moby/api/types/filters"

 	enginemount "github.com/moby/moby/api/types/mount"

@@ -52,13 +51,13 @@ func (c *containerConfig) setTask(t *api.Task, node *api.NodeDescription) error

 		return exec.ErrRuntimeUnsupported

 	}

-	container := t.Spec.GetContainer()

-	if container != nil {

-		if container.Image == "" {

+	ctr := t.Spec.GetContainer()

+	if ctr != nil {

+		if ctr.Image == "" {

 			return ErrImageRequired

 		}

-		if err := validateMounts(container.Mounts); err != nil {

+		if err := validateMounts(ctr.Mounts); err != nil {

 			return err

 		}

 	}

@@ -140,8 +139,8 @@ func (c *containerConfig) image() string {

 	return reference.FamiliarString(reference.TagNameOnly(ref))

 }

-func (c *containerConfig) portBindings() nat.PortMap {

-	portBindings := nat.PortMap{}

+func (c *containerConfig) portBindings() container.PortMap {

+	portBindings := container.PortMap{}

 	if c.task.Endpoint == nil {

 		return portBindings

 	}

@@ -151,8 +150,8 @@ func (c *containerConfig) portBindings() nat.PortMap {

 			continue

 		}

-		port := nat.Port(fmt.Sprintf("%d/%s", portConfig.TargetPort, strings.ToLower(portConfig.Protocol.String())))

-		binding := []nat.PortBinding{

+		port := container.PortRangeProto(fmt.Sprintf("%d/%s", portConfig.TargetPort, strings.ToLower(portConfig.Protocol.String())))

+		binding := []container.PortBinding{

 			{},

 		}

@@ -165,7 +164,7 @@ func (c *containerConfig) portBindings() nat.PortMap {

 	return portBindings

 }

-func (c *containerConfig) isolation() containertypes.Isolation {

+func (c *containerConfig) isolation() container.Isolation {

 	return convert.IsolationFromGRPC(c.spec().Isolation)

 }

@@ -177,8 +176,8 @@ func (c *containerConfig) init() *bool {

 	return &init

 }

-func (c *containerConfig) exposedPorts() map[nat.Port]struct{} {

-	exposedPorts := make(map[nat.Port]struct{})

+func (c *containerConfig) exposedPorts() map[container.PortRangeProto]struct{} {

+	exposedPorts := make(map[container.PortRangeProto]struct{})

 	if c.task.Endpoint == nil {

 		return exposedPorts

 	}

@@ -188,18 +187,18 @@ func (c *containerConfig) exposedPorts() map[nat.Port]struct{} {

 			continue

 		}

-		port := nat.Port(fmt.Sprintf("%d/%s", portConfig.TargetPort, strings.ToLower(portConfig.Protocol.String())))

+		port := container.PortRangeProto(fmt.Sprintf("%d/%s", portConfig.TargetPort, strings.ToLower(portConfig.Protocol.String())))

 		exposedPorts[port] = struct{}{}

 	}

 	return exposedPorts

 }

-func (c *containerConfig) config() *containertypes.Config {

+func (c *containerConfig) config() *container.Config {

 	genericEnvs := genericresource.EnvFormat(c.task.AssignedGenericResources, "DOCKER_RESOURCE")

 	env := append(c.spec().Env, genericEnvs...)

-	config := &containertypes.Config{

+	config := &container.Config{

 		Labels:       c.labels(),

 		StopSignal:   c.spec().StopSignal,

 		Tty:          c.spec().TTY,

@@ -380,7 +379,7 @@ func convertMount(m api.Mount) enginemount.Mount {

 	return mount

 }

-func (c *containerConfig) healthcheck() *containertypes.HealthConfig {

+func (c *containerConfig) healthcheck() *container.HealthConfig {

 	hcSpec := c.spec().Healthcheck

 	if hcSpec == nil {

 		return nil

@@ -389,7 +388,7 @@ func (c *containerConfig) healthcheck() *containertypes.HealthConfig {

 	timeout, _ := gogotypes.DurationFromProto(hcSpec.Timeout)

 	startPeriod, _ := gogotypes.DurationFromProto(hcSpec.StartPeriod)

 	startInterval, _ := gogotypes.DurationFromProto(hcSpec.StartInterval)

-	return &containertypes.HealthConfig{

+	return &container.HealthConfig{

 		Test:          hcSpec.Test,

 		Interval:      interval,

 		Timeout:       timeout,

@@ -399,8 +398,8 @@ func (c *containerConfig) healthcheck() *containertypes.HealthConfig {

 	}

 }

-func (c *containerConfig) hostConfig(deps exec.VolumeGetter) *containertypes.HostConfig {

-	hc := &containertypes.HostConfig{

+func (c *containerConfig) hostConfig(deps exec.VolumeGetter) *container.HostConfig {

+	hc := &container.HostConfig{

 		Resources:      c.resources(),

 		GroupAdd:       c.spec().Groups,

 		PortBindings:   c.portBindings(),

@@ -437,7 +436,7 @@ func (c *containerConfig) hostConfig(deps exec.VolumeGetter) *containertypes.Hos

 	}

 	if c.task.LogDriver != nil {

-		hc.LogConfig = containertypes.LogConfig{

+		hc.LogConfig = container.LogConfig{

 			Type:   c.task.LogDriver.Name,

 			Config: c.task.LogDriver.Options,

 		}

@@ -447,7 +446,7 @@ func (c *containerConfig) hostConfig(deps exec.VolumeGetter) *containertypes.Hos

 		labels := c.task.Networks[0].Network.Spec.Annotations.Labels

 		name := c.task.Networks[0].Network.Spec.Annotations.Name

 		if v, ok := labels["com.docker.swarm.predefined"]; ok && v == "true" {

-			hc.NetworkMode = containertypes.NetworkMode(name)

+			hc.NetworkMode = container.NetworkMode(name)

 		}

 	}

@@ -479,8 +478,8 @@ func (c *containerConfig) volumeCreateRequest(mount *api.Mount) *volume.CreateOp

 	return nil

 }

-func (c *containerConfig) resources() containertypes.Resources {

-	resources := containertypes.Resources{}

+func (c *containerConfig) resources() container.Resources {

+	resources := container.Resources{}

 	// set pids limit

 	pidsLimit := c.spec().PidsLimit

@@ -488,9 +487,9 @@ func (c *containerConfig) resources() containertypes.Resources {

 		resources.PidsLimit = &pidsLimit

 	}

-	resources.Ulimits = make([]*containertypes.Ulimit, len(c.spec().Ulimits))

+	resources.Ulimits = make([]*container.Ulimit, len(c.spec().Ulimits))

 	for i, ulimit := range c.spec().Ulimits {

-		resources.Ulimits[i] = &containertypes.Ulimit{

+		resources.Ulimits[i] = &container.Ulimit{

 			Name: ulimit.Name,

 			Soft: ulimit.Soft,

 			Hard: ulimit.Hard,

@@ -673,7 +672,7 @@ func networkCreateRequest(name string, nw *api.Network) clustertypes.NetworkCrea

 	}

 }

-func (c *containerConfig) applyPrivileges(hc *containertypes.HostConfig) {

+func (c *containerConfig) applyPrivileges(hc *container.HostConfig) {

 	privileges := c.spec().Privileges

 	if privileges == nil {

 		return

@@ -11,7 +11,6 @@ import (

 	cerrdefs "github.com/containerd/errdefs"

 	executorpkg "github.com/docker/docker/daemon/cluster/executor"

 	"github.com/docker/docker/daemon/libnetwork"

-	"github.com/docker/go-connections/nat"

 	gogotypes "github.com/gogo/protobuf/types"

 	"github.com/moby/moby/api/types/container"

 	"github.com/moby/moby/api/types/events"

@@ -641,7 +640,7 @@ func parsePortStatus(ctnr container.InspectResponse) (*api.PortStatus, error) {

 	return status, nil

 }

-func parsePortMap(portMap nat.PortMap) ([]*api.PortConfig, error) {

+func parsePortMap(portMap container.PortMap) ([]*api.PortConfig, error) {

 	exposedPorts := make([]*api.PortConfig, 0, len(portMap))

 	for portProtocol, mapping := range portMap {

@@ -376,7 +376,7 @@ func validateHealthCheck(healthConfig *containertypes.HealthConfig) error {

 	return nil

 }

-func validatePortBindings(ports nat.PortMap) error {

+func validatePortBindings(ports containertypes.PortMap) error {

 	for port := range ports {

 		_, portStr := nat.SplitProtoPort(string(port))

 		if _, err := nat.ParsePort(portStr); err != nil {

@@ -43,8 +43,8 @@ type Snapshot struct {

 	Running      bool

 	Paused       bool

 	Managed      bool

-	ExposedPorts nat.PortSet

-	PortBindings nat.PortSet

+	ExposedPorts container.PortSet

+	PortBindings container.PortSet

 	Health       container.HealthStatus

 	HostConfig   struct {

 		Isolation string

@@ -324,8 +324,8 @@ func (v *View) transform(ctr *Container) *Snapshot {

 		Name:         ctr.Name,

 		Pid:          ctr.Pid,

 		Managed:      ctr.Managed,

-		ExposedPorts: make(nat.PortSet),

-		PortBindings: make(nat.PortSet),

+		ExposedPorts: make(container.PortSet),

+		PortBindings: make(container.PortSet),

 		Health:       health,

 		Running:      ctr.Running,

 		Paused:       ctr.Paused,

@@ -395,8 +395,9 @@ func (v *View) transform(ctr *Container) *Snapshot {

 				}

 			}

 		}

-		for port, bindings := range ctr.NetworkSettings.Ports {

-			p, err := nat.ParsePort(port.Port())

+		for p, bindings := range ctr.NetworkSettings.Ports {

+			proto, port := nat.SplitProtoPort(string(p))

+			p, err := nat.ParsePort(port)

 			if err != nil {

 				log.G(context.TODO()).WithError(err).Warn("invalid port map")

 				continue

@@ -404,7 +405,7 @@ func (v *View) transform(ctr *Container) *Snapshot {

 			if len(bindings) == 0 {

 				snapshot.Ports = append(snapshot.Ports, container.Port{

 					PrivatePort: uint16(p),

-					Type:        port.Proto(),

+					Type:        proto,

 				})

 				continue

 			}

@@ -417,7 +418,7 @@ func (v *View) transform(ctr *Container) *Snapshot {

 				snapshot.Ports = append(snapshot.Ports, container.Port{

 					PrivatePort: uint16(p),

 					PublicPort:  uint16(h),

-					Type:        port.Proto(),

+					Type:        proto,

 					IP:          binding.HostIP,

 				})

 			}

@@ -101,12 +101,12 @@ func buildSandboxOptions(cfg *config.Config, ctr *container.Container) ([]libnet

 		}

 	}

-	bindings := make(nat.PortMap)

+	bindings := make(containertypes.PortMap)

 	if ctr.HostConfig.PortBindings != nil {

 		for p, b := range ctr.HostConfig.PortBindings {

-			bindings[p] = []nat.PortBinding{}

+			bindings[p] = []containertypes.PortBinding{}

 			for _, bb := range b {

-				bindings[p] = append(bindings[p], nat.PortBinding{

+				bindings[p] = append(bindings[p], containertypes.PortBinding{

 					HostIP:   bb.HostIP,

 					HostPort: bb.HostPort,

 				})

@@ -115,7 +115,7 @@ func buildSandboxOptions(cfg *config.Config, ctr *container.Container) ([]libnet

 	}

 	// TODO(thaJeztah): Move this code to a method on nat.PortSet.

-	ports := make([]nat.Port, 0, len(ctr.Config.ExposedPorts))

+	ports := make([]containertypes.PortRangeProto, 0, len(ctr.Config.ExposedPorts))

 	for p := range ctr.Config.ExposedPorts {

 		ports = append(ports, p)

 	}

@@ -6,7 +6,6 @@ import (

 	"testing"

 	"github.com/docker/docker/daemon/config"

-	"github.com/docker/go-connections/nat"

 	containertypes "github.com/moby/moby/api/types/container"

 	"gotest.tools/v3/assert"

 )

@@ -15,12 +14,12 @@ import (

 // This should not be tested on Windows because Windows doesn't support "host" network mode.

 func TestContainerWarningHostAndPublishPorts(t *testing.T) {

 	testCases := []struct {

-		ports    nat.PortMap

+		ports    containertypes.PortMap

 		warnings []string

 	}{

-		{ports: nat.PortMap{}},

-		{ports: nat.PortMap{

-			"8080": []nat.PortBinding{{HostPort: "8989"}},

+		{ports: containertypes.PortMap{}},

+		{ports: containertypes.PortMap{

+			"8080": []containertypes.PortBinding{{HostPort: "8989"}},

 		}, warnings: []string{"Published ports are discarded when using host network mode"}},

 	}

 	muteLogs(t)

@@ -34,9 +33,9 @@ func TestContainerWarningHostAndPublishPorts(t *testing.T) {

 		d := &Daemon{}

 		cfg, err := config.New()

 		assert.NilError(t, err)

-		runtimes, err := setupRuntimes(cfg)

+		rts, err := setupRuntimes(cfg)

 		assert.NilError(t, err)

-		daemonCfg := &configStore{Config: *cfg, Runtimes: runtimes}

+		daemonCfg := &configStore{Config: *cfg, Runtimes: rts}

 		wrns, err := d.verifyContainerSettings(daemonCfg, hostConfig, &containertypes.Config{}, false)

 		assert.NilError(t, err)

 		assert.DeepEqual(t, tc.warnings, wrns)

@@ -3,7 +3,6 @@ package containerd

 import (

 	"testing"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/moby/api/types/container"

 	"gotest.tools/v3/assert"

 	is "gotest.tools/v3/assert/cmp"

@@ -12,7 +11,7 @@ import (

 // regression test for https://github.com/moby/moby/issues/45904

 func TestContainerConfigToDockerImageConfig(t *testing.T) {

 	ociCFG := containerConfigToDockerOCIImageConfig(&container.Config{

-		ExposedPorts: nat.PortSet{

+		ExposedPorts: container.PortSet{

 			"80/tcp": struct{}{},

 		},

 	})

@@ -8,7 +8,6 @@ import (

 	"github.com/docker/docker/daemon/internal/image"

 	"github.com/docker/docker/dockerversion"

-	"github.com/docker/go-connections/nat"

 	imagespec "github.com/moby/docker-image-spec/specs-go/v1"

 	"github.com/moby/moby/api/types/container"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

@@ -83,8 +82,8 @@ func containerConfigToDockerOCIImageConfig(cfg *container.Config) imagespec.Dock

 		if len(cfg.ExposedPorts) > 0 {

 			ociCfg.ExposedPorts = map[string]struct{}{}

-			for k, v := range cfg.ExposedPorts {

-				ociCfg.ExposedPorts[string(k)] = v

+			for k := range cfg.ExposedPorts {

+				ociCfg.ExposedPorts[string(k)] = struct{}{}

 			}

 		}

 		ext.Healthcheck = cfg.Healthcheck

@@ -99,9 +98,9 @@ func containerConfigToDockerOCIImageConfig(cfg *container.Config) imagespec.Dock

 }

 func dockerOCIImageConfigToContainerConfig(cfg imagespec.DockerOCIImageConfig) *container.Config {

-	exposedPorts := make(nat.PortSet, len(cfg.ExposedPorts))

-	for k, v := range cfg.ExposedPorts {

-		exposedPorts[nat.Port(k)] = v

+	exposedPorts := make(container.PortSet, len(cfg.ExposedPorts))

+	for k := range cfg.ExposedPorts {

+		exposedPorts[container.PortRangeProto(k)] = struct{}{}

 	}

 	return &container.Config{

@@ -14,7 +14,6 @@ import (

 	"github.com/docker/docker/daemon/internal/idtools"

 	"github.com/docker/docker/daemon/libnetwork"

 	volumesservice "github.com/docker/docker/daemon/volume/service"

-	"github.com/docker/go-connections/nat"

 	containertypes "github.com/moby/moby/api/types/container"

 	"github.com/pkg/errors"

 	"gotest.tools/v3/assert"

@@ -219,33 +218,28 @@ func TestContainerInitDNS(t *testing.T) {

 	}

 }

-func newPortNoError(proto, port string) nat.Port {

-	p, _ := nat.NewPort(proto, port)

-	return p

-}

-

 func TestMerge(t *testing.T) {

-	volumesImage := make(map[string]struct{})

-	volumesImage["/test1"] = struct{}{}

-	volumesImage["/test2"] = struct{}{}

-	portsImage := make(nat.PortSet)

-	portsImage[newPortNoError("tcp", "1111")] = struct{}{}

-	portsImage[newPortNoError("tcp", "2222")] = struct{}{}

 	configImage := &containertypes.Config{

-		ExposedPorts: portsImage,

-		Env:          []string{"VAR1=1", "VAR2=2"},

-		Volumes:      volumesImage,

+		ExposedPorts: containertypes.PortSet{

+			"1111/tcp": struct{}{},

+			"2222/tcp": struct{}{},

+		},

+		Env: []string{"VAR1=1", "VAR2=2"},

+		Volumes: map[string]struct{}{

+			"/test1": {},

+			"/test2": {},

+		},

 	}

-	portsUser := make(nat.PortSet)

-	portsUser[newPortNoError("tcp", "2222")] = struct{}{}

-	portsUser[newPortNoError("tcp", "3333")] = struct{}{}

-	volumesUser := make(map[string]struct{})

-	volumesUser["/test3"] = struct{}{}

 	configUser := &containertypes.Config{

-		ExposedPorts: portsUser,

-		Env:          []string{"VAR2=3", "VAR3=3"},

-		Volumes:      volumesUser,

+		ExposedPorts: containertypes.PortSet{

+			"2222/tcp": struct{}{},

+			"3333/tcp": struct{}{},

+		},

+		Env: []string{"VAR2=3", "VAR3=3"},

+		Volumes: map[string]struct{}{

+			"/test3": {},

+		},

 	}

 	if err := merge(configUser, configImage); err != nil {

@@ -278,12 +272,8 @@ func TestMerge(t *testing.T) {

 		}

 	}

-	ports, _, err := nat.ParsePortSpecs([]string{"0000"})

-	if err != nil {

-		t.Error(err)

-	}

 	configImage2 := &containertypes.Config{

-		ExposedPorts: ports,

+		ExposedPorts: map[containertypes.PortRangeProto]struct{}{"0/tcp": {}},

 	}

 	if err := merge(configUser, configImage2); err != nil {

@@ -14,7 +14,6 @@ import (

 	"github.com/docker/docker/daemon/network"

 	"github.com/docker/docker/daemon/server/backend"

 	"github.com/docker/docker/errdefs"

-	"github.com/docker/go-connections/nat"

 	containertypes "github.com/moby/moby/api/types/container"

 	networktypes "github.com/moby/moby/api/types/network"

 )

@@ -60,7 +59,7 @@ func (daemon *Daemon) ContainerInspect(ctx context.Context, name string, options

 		Networks:               apiNetworks,

 	}

-	ports := make(nat.PortMap, len(ctr.NetworkSettings.Ports))

+	ports := make(containertypes.PortMap, len(ctr.NetworkSettings.Ports))

 	for k, pm := range ctr.NetworkSettings.Ports {

 		ports[k] = pm

 	}

@@ -4,37 +4,36 @@ import (

 	"runtime"

 	"testing"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/moby/api/types/container"

 	ocispec "github.com/opencontainers/image-spec/specs-go/v1"

 	"gotest.tools/v3/assert"

 	is "gotest.tools/v3/assert/cmp"

 )

-// Just to make life easier

-func newPortNoError(proto, port string) nat.Port {

-	p, _ := nat.NewPort(proto, port)

-	return p

-}

-

 func TestCompare(t *testing.T) {

-	ports1 := make(nat.PortSet)

-	ports1[newPortNoError("tcp", "1111")] = struct{}{}

-	ports1[newPortNoError("tcp", "2222")] = struct{}{}

-	ports2 := make(nat.PortSet)

-	ports2[newPortNoError("tcp", "3333")] = struct{}{}

-	ports2[newPortNoError("tcp", "4444")] = struct{}{}

-	ports3 := make(nat.PortSet)

-	ports3[newPortNoError("tcp", "1111")] = struct{}{}

-	ports3[newPortNoError("tcp", "2222")] = struct{}{}

-	ports3[newPortNoError("tcp", "5555")] = struct{}{}

-	volumes1 := make(map[string]struct{})

-	volumes1["/test1"] = struct{}{}

-	volumes2 := make(map[string]struct{})

-	volumes2["/test2"] = struct{}{}

-	volumes3 := make(map[string]struct{})

-	volumes3["/test1"] = struct{}{}

-	volumes3["/test3"] = struct{}{}

+	ports1 := container.PortSet{

+		"1111/tcp": struct{}{},

+		"2222/tcp": struct{}{},

+	}

+	ports2 := container.PortSet{

+		"3333/tcp": struct{}{},

+		"4444/tcp": struct{}{},

+	}

+	ports3 := container.PortSet{

+		"1111/tcp": struct{}{},

+		"2222/tcp": struct{}{},

+		"5555/tcp": struct{}{},

+	}

+	volumes1 := map[string]struct{}{

+		"/test1": {},

+	}

+	volumes2 := map[string]struct{}{

+		"/test2": {},

+	}

+	volumes3 := map[string]struct{}{

+		"/test1": {},

+		"/test3": {},

+	}

 	envs1 := []string{"ENV1=value1", "ENV2=value2"}

 	envs2 := []string{"ENV1=value1", "ENV3=value3"}

 	entrypoint1 := []string{"/bin/sh", "-c"}

@@ -6,6 +6,7 @@ import (

 	"strings"

 	"github.com/docker/go-connections/nat"

+	"github.com/moby/moby/api/types/container"

 )

 // Link struct holds information about parent/child linked container

@@ -19,18 +20,18 @@ type Link struct {

 	// Child environments variables

 	ChildEnvironment []string

 	// Child exposed ports

-	Ports []nat.Port

+	Ports []container.PortRangeProto // TODO(thaJeztah): can we use []string here, or do we need the features of nat.Port?

 }

 // EnvVars generates environment variables for the linked container

 // for the Link with the given options.

-func EnvVars(parentIP, childIP, name string, env []string, exposedPorts map[nat.Port]struct{}) []string {

+func EnvVars(parentIP, childIP, name string, env []string, exposedPorts map[container.PortRangeProto]struct{}) []string {

 	return NewLink(parentIP, childIP, name, env, exposedPorts).ToEnv()

 }

 // NewLink initializes a new Link struct with the provided options.

-func NewLink(parentIP, childIP, name string, env []string, exposedPorts map[nat.Port]struct{}) *Link {

-	ports := make([]nat.Port, 0, len(exposedPorts))

+func NewLink(parentIP, childIP, name string, env []string, exposedPorts map[container.PortRangeProto]struct{}) *Link {

+	ports := make([]container.PortRangeProto, 0, len(exposedPorts))

 	for p := range exposedPorts {

 		ports = append(ports, p)

 	}

@@ -54,7 +55,7 @@ func (l *Link) ToEnv() []string {

 	// sort the ports so that we can bulk the continuous ports together

 	nat.Sort(l.Ports, withTCPPriority)

-	var pStart, pEnd nat.Port

+	var pStart, pEnd container.PortRangeProto

 	env := make([]string, 0, 1+len(l.Ports)*4)

 	for i, p := range l.Ports {

 		if i == 0 {

@@ -112,7 +113,7 @@ func (l *Link) ToEnv() []string {

 // withTCPPriority prioritizes ports using TCP over other protocols before

 // comparing port-number and protocol.

-func withTCPPriority(ip, jp nat.Port) bool {

+func withTCPPriority(ip, jp container.PortRangeProto) bool {

 	if strings.EqualFold(ip.Proto(), jp.Proto()) {

 		return ip.Int() < jp.Int()

 	}

@@ -5,11 +5,12 @@ import (

 	"testing"

 	"github.com/docker/go-connections/nat"

+	"github.com/moby/moby/api/types/container"

 	"gotest.tools/v3/assert"

 )

 func TestLinkNaming(t *testing.T) {

-	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker-1", nil, nat.PortSet{

+	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker-1", nil, container.PortSet{

 		"6379/tcp": struct{}{},

 	})

@@ -27,7 +28,7 @@ func TestLinkNaming(t *testing.T) {

 }

 func TestLinkNew(t *testing.T) {

-	link := NewLink("172.0.17.3", "172.0.17.2", "/db/docker", nil, nat.PortSet{

+	link := NewLink("172.0.17.3", "172.0.17.2", "/db/docker", nil, container.PortSet{

 		"6379/tcp": struct{}{},

 	})

@@ -35,14 +36,14 @@ func TestLinkNew(t *testing.T) {

 		Name:     "/db/docker",

 		ParentIP: "172.0.17.3",

 		ChildIP:  "172.0.17.2",

-		Ports:    []nat.Port{"6379/tcp"},

+		Ports:    []container.PortRangeProto{"6379/tcp"},

 	}

 	assert.DeepEqual(t, expected, link)

 }

 func TestLinkEnv(t *testing.T) {

-	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, nat.PortSet{

+	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, container.PortSet{

 		"6379/tcp": struct{}{},

 	})

@@ -63,7 +64,7 @@ func TestLinkEnv(t *testing.T) {

 // TestSortPorts verifies that ports are sorted with TCP taking priority,

 // and ports with the same protocol to be sorted by port.

 func TestSortPorts(t *testing.T) {

-	ports := []nat.Port{

+	ports := []container.PortRangeProto{

 		"6379/tcp",

 		"6376/udp",

 		"6380/tcp",

@@ -74,7 +75,7 @@ func TestSortPorts(t *testing.T) {

 		"6375/sctp",

 	}

-	expected := []nat.Port{

+	expected := []container.PortRangeProto{

 		"6379/tcp",

 		"6380/tcp",

 		"6381/tcp",

@@ -90,7 +91,7 @@ func TestSortPorts(t *testing.T) {

 }

 func TestLinkMultipleEnv(t *testing.T) {

-	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, nat.PortSet{

+	actual := EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, container.PortSet{

 		"6300/udp": struct{}{},

 		"6379/tcp": struct{}{},

 		"6380/tcp": struct{}{},

@@ -141,7 +142,7 @@ func BenchmarkLinkMultipleEnv(b *testing.B) {

 	b.ReportAllocs()

 	b.ResetTimer()

 	for i := 0; i < b.N; i++ {

-		_ = EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, nat.PortSet{

+		_ = EnvVars("172.0.17.3", "172.0.17.2", "/db/docker", []string{"PASSWORD=gordon"}, container.PortSet{

 			"6300/udp": struct{}{},

 			"6379/tcp": struct{}{},

 			"6380/tcp": struct{}{},

@@ -84,9 +84,9 @@ type listContext struct {

 	isTask bool

 	// publish is a list of published ports to filter with

-	publish map[nat.Port]bool

+	publish map[containertypes.PortRangeProto]bool // TODO(thaJeztah): could this be a straight map[string]bool?

 	// expose is a list of exposed ports to filter with

-	expose map[nat.Port]bool

+	expose map[containertypes.PortRangeProto]bool // TODO(thaJeztah): could this be a straight map[string]bool?

 	// ListOptions is the filters set by the user

 	*containertypes.ListOptions

@@ -346,13 +346,13 @@ func (daemon *Daemon) foldFilter(ctx context.Context, view *container.View, conf

 		}

 	}

-	publishFilter := map[nat.Port]bool{}

+	publishFilter := map[containertypes.PortRangeProto]bool{}

 	err = psFilters.WalkValues("publish", portOp("publish", publishFilter))

 	if err != nil {

 		return nil, err

 	}

-	exposeFilter := map[nat.Port]bool{}

+	exposeFilter := map[containertypes.PortRangeProto]bool{}

 	err = psFilters.WalkValues("expose", portOp("expose", exposeFilter))

 	if err != nil {

 		return nil, err

@@ -397,7 +397,7 @@ func idOrNameFilter(view *container.View, value string) (*container.Snapshot, er

 	return filter, err

 }

-func portOp(key string, filter map[nat.Port]bool) func(value string) error {

+func portOp(key string, filter map[containertypes.PortRangeProto]bool) func(value string) error {

 	return func(value string) error {

 		if strings.Contains(value, ":") {

 			return fmt.Errorf("filter for '%s' should not contain ':': %s", key, value)

@@ -568,12 +568,12 @@ func includeContainerInList(container *container.Snapshot, filter *listContext)

 	if len(filter.expose) > 0 || len(filter.publish) > 0 {

 		var (

 			shouldSkip    = true

-			publishedPort nat.Port

-			exposedPort   nat.Port

+			publishedPort containertypes.PortRangeProto

+			exposedPort   containertypes.PortRangeProto

 		)

 		for _, port := range container.Ports {

-			publishedPort = nat.Port(fmt.Sprintf("%d/%s", port.PublicPort, port.Type))

-			exposedPort = nat.Port(fmt.Sprintf("%d/%s", port.PrivatePort, port.Type))

+			publishedPort = containertypes.PortRangeProto(fmt.Sprintf("%d/%s", port.PublicPort, port.Type))

+			exposedPort = containertypes.PortRangeProto(fmt.Sprintf("%d/%s", port.PrivatePort, port.Type))

 			if ok := filter.publish[publishedPort]; ok {

 				shouldSkip = false

 				break

@@ -944,12 +944,12 @@ func buildPortsRelatedCreateEndpointOptions(c *container.Container, n *libnetwor

 		return nil, nil

 	}

-	bindings := make(nat.PortMap)

+	bindings := make(containertypes.PortMap)

 	if c.HostConfig.PortBindings != nil {

 		for p, b := range c.HostConfig.PortBindings {

-			bindings[p] = []nat.PortBinding{}

+			bindings[p] = []containertypes.PortBinding{}

 			for _, bb := range b {

-				bindings[p] = append(bindings[p], nat.PortBinding{

+				bindings[p] = append(bindings[p], containertypes.PortBinding{

 					HostIP:   bb.HostIP,

 					HostPort: bb.HostPort,

 				})

@@ -958,7 +958,7 @@ func buildPortsRelatedCreateEndpointOptions(c *container.Container, n *libnetwor

 	}

 	// TODO(thaJeztah): Move this code to a method on nat.PortSet.

-	ports := make([]nat.Port, 0, len(c.Config.ExposedPorts))

+	ports := make([]containertypes.PortRangeProto, 0, len(c.Config.ExposedPorts))

 	for p := range c.Config.ExposedPorts {

 		ports = append(ports, p)

 	}

@@ -1009,8 +1009,8 @@ func buildPortsRelatedCreateEndpointOptions(c *container.Container, n *libnetwor

 }

 // getPortMapInfo retrieves the current port-mapping programmed for the given sandbox

-func getPortMapInfo(sb *libnetwork.Sandbox) nat.PortMap {

-	pm := nat.PortMap{}

+func getPortMapInfo(sb *libnetwork.Sandbox) containertypes.PortMap {

+	pm := containertypes.PortMap{}

 	if sb == nil {

 		return pm

 	}

@@ -1021,7 +1021,7 @@ func getPortMapInfo(sb *libnetwork.Sandbox) nat.PortMap {

 	return pm

 }

-func getEndpointPortMapInfo(pm nat.PortMap, ep *libnetwork.Endpoint) {

+func getEndpointPortMapInfo(pm containertypes.PortMap, ep *libnetwork.Endpoint) {

 	driverInfo, _ := ep.DriverInfo()

 	if driverInfo == nil {

 		// It is not an error for epInfo to be nil

@@ -1060,7 +1060,7 @@ func getEndpointPortMapInfo(pm nat.PortMap, ep *libnetwork.Endpoint) {

 			if pp.HostPort > 0 {

 				hp = strconv.Itoa(int(pp.HostPort))

 			}

-			natBndg := nat.PortBinding{HostIP: pp.HostIP.String(), HostPort: hp}

+			natBndg := containertypes.PortBinding{HostIP: pp.HostIP.String(), HostPort: hp}

 			pm[natPort] = append(pm[natPort], natBndg)

 		}

 	}

@@ -5,7 +5,7 @@ import (

 	"sync"

 	clustertypes "github.com/docker/docker/daemon/cluster/provider"

-	"github.com/docker/go-connections/nat"

+	"github.com/moby/moby/api/types/container"

 	networktypes "github.com/moby/moby/api/types/network"

 	"github.com/pkg/errors"

 )

@@ -21,7 +21,7 @@ type Settings struct {

 	LinkLocalIPv6PrefixLen int

 	Networks               map[string]*EndpointSettings

 	Service                *clustertypes.ServiceConfig

-	Ports                  nat.PortMap

+	Ports                  container.PortMap

 	SecondaryIPAddresses   []networktypes.Address

 	SecondaryIPv6Addresses []networktypes.Address

 	HasSwarmEndpoint       bool

@@ -22,7 +22,6 @@ import (

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/testutil"

 	"github.com/docker/docker/testutil/request"

-	"github.com/docker/go-connections/nat"

 	"github.com/moby/moby/api/types/container"

 	"github.com/moby/moby/api/types/mount"

 	"github.com/moby/moby/api/types/network"

@@ -505,8 +504,8 @@ func (s *DockerAPISuite) TestContainerAPIBadPort(c *testing.T) {

 	}

 	hostConfig := container.HostConfig{

-		PortBindings: nat.PortMap{

-			"8080/tcp": []nat.PortBinding{

+		PortBindings: container.PortMap{

+			"8080/tcp": []container.PortBinding{

 				{

 					HostIP:   "",

 					HostPort: "aa80",

@@ -12,7 +12,7 @@ import (

 	"github.com/docker/docker/integration-cli/cli"

 	"github.com/docker/docker/integration-cli/cli/build"

 	"github.com/docker/docker/testutil/fakecontext"

-	"github.com/docker/go-connections/nat"

+	containertypes "github.com/moby/moby/api/types/container"

 	"gotest.tools/v3/assert"

 	is "gotest.tools/v3/assert/cmp"

 )

@@ -92,7 +92,7 @@ func (s *DockerCLICreateSuite) TestCreateWithPortRange(c *testing.T) {

 	var containers []struct {

 		HostConfig *struct {

-			PortBindings map[nat.Port][]nat.PortBinding

+			PortBindings map[containertypes.PortRangeProto][]containertypes.PortBinding

 		}