libpod: deduplicate ports in db

The OCICNI port format has one big problem: It does not support ranges.
So if a users forwards a range of 1k ports with podman run -p 1001-2000
we have to store each of the thousand ports individually as array element.
This bloats the db and makes the JSON encoding and decoding much slower.
In many places we already use a better port struct type which supports
ranges, e.g. `pkg/specgen` or the new network interface.

Because of this we have to do many runtime conversions between the two
port formats. If everything uses the new format we can skip the runtime
conversions.

This commit adds logic to replace all occurrences of the old format
with the new one. The database will automatically migrate the ports
to new format when the container config is read for the first time
after the update.

The `ParsePortMapping` function is `pkg/specgen/generate` has been
reworked to better work with the new format. The new logic is able
to deduplicate the given ports. This is necessary the ensure we
store them efficiently in the DB. The new code should also be more
performant than the old one.

To prove that the code is fast enough I added go benchmarks. Parsing
1 million ports took less than 0.5 seconds on my laptop.

Benchmark normalize PortMappings in specgen:
Please note that the 1 million ports are actually 20x 50k ranges
because we cannot have bigger ranges than 65535 ports.
```
$ go test -bench=. -benchmem  ./pkg/specgen/generate/
goos: linux
goarch: amd64
pkg: github.com/containers/podman/v3/pkg/specgen/generate
cpu: Intel(R) Core(TM) i7-10850H CPU @ 2.70GHz
BenchmarkParsePortMappingNoPorts-12             480821532                2.230 ns/op           0 B/op          0 allocs/op
BenchmarkParsePortMapping1-12                      38972             30183 ns/op          131584 B/op          9 allocs/op
BenchmarkParsePortMapping100-12                    18752             60688 ns/op          141088 B/op        315 allocs/op
BenchmarkParsePortMapping1k-12                      3104            331719 ns/op          223840 B/op       3018 allocs/op
BenchmarkParsePortMapping10k-12                      376           3122930 ns/op         1223650 B/op      30027 allocs/op
BenchmarkParsePortMapping1m-12                         3         390869926 ns/op        124593840 B/op   4000624 allocs/op
BenchmarkParsePortMappingReverse100-12             18940             63414 ns/op          141088 B/op        315 allocs/op
BenchmarkParsePortMappingReverse1k-12               3015            362500 ns/op          223841 B/op       3018 allocs/op
BenchmarkParsePortMappingReverse10k-12               343           3318135 ns/op         1223650 B/op      30027 allocs/op
BenchmarkParsePortMappingReverse1m-12                  3         403392469 ns/op        124593840 B/op   4000624 allocs/op
BenchmarkParsePortMappingRange1-12                 37635             28756 ns/op          131584 B/op          9 allocs/op
BenchmarkParsePortMappingRange100-12               39604             28935 ns/op          131584 B/op          9 allocs/op
BenchmarkParsePortMappingRange1k-12                38384             29921 ns/op          131584 B/op          9 allocs/op
BenchmarkParsePortMappingRange10k-12               29479             40381 ns/op          131584 B/op          9 allocs/op
BenchmarkParsePortMappingRange1m-12                  927           1279369 ns/op          143022 B/op        164 allocs/op
PASS
ok      github.com/containers/podman/v3/pkg/specgen/generate    25.492s
```

Benchmark convert old port format to new one:
```
go test -bench=. -benchmem  ./libpod/
goos: linux
goarch: amd64
pkg: github.com/containers/podman/v3/libpod
cpu: Intel(R) Core(TM) i7-10850H CPU @ 2.70GHz
Benchmark_ocicniPortsToNetTypesPortsNoPorts-12          663526126                1.663 ns/op           0 B/op          0 allocs/op
Benchmark_ocicniPortsToNetTypesPorts1-12                 7858082               141.9 ns/op            72 B/op          2 allocs/op
Benchmark_ocicniPortsToNetTypesPorts10-12                2065347               571.0 ns/op           536 B/op          4 allocs/op
Benchmark_ocicniPortsToNetTypesPorts100-12                138478              8641 ns/op            4216 B/op          4 allocs/op
Benchmark_ocicniPortsToNetTypesPorts1k-12                   9414            120964 ns/op           41080 B/op          4 allocs/op
Benchmark_ocicniPortsToNetTypesPorts10k-12                   781           1490526 ns/op          401528 B/op          4 allocs/op
Benchmark_ocicniPortsToNetTypesPorts1m-12                      4         250579010 ns/op        40001656 B/op          4 allocs/op
PASS
ok      github.com/containers/podman/v3/libpod  11.727s
```

Signed-off-by: Paul Holzinger <pholzing@redhat.com>

2 files changed, 48 insertions, 185 deletions

diff --git a/cmd/podman/containers/port.go b/cmd/podman/containers/port.go
index f309390c3..0e582ae52 100644
--- a/cmd/podman/containers/port.go
+++ b/cmd/podman/containers/port.go
@@ -8,7 +8,6 @@ import (
 	"github.com/containers/podman/v3/cmd/podman/common"
 	"github.com/containers/podman/v3/cmd/podman/registry"
 	"github.com/containers/podman/v3/cmd/podman/validate"
-	"github.com/containers/podman/v3/libpod/network/types"
 	"github.com/containers/podman/v3/pkg/domain/entities"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
@@ -73,7 +72,8 @@ func port(_ *cobra.Command, args []string) error {
 	var (
 		container string
 		err       error
-		userPort  types.OCICNIPortMapping
+		userPort  uint16
+		userProto string
 	)
 
 	if len(args) == 0 && !portOpts.Latest && !portOpts.All {
@@ -101,16 +101,12 @@ func port(_ *cobra.Command, args []string) error {
 			fields = append(fields, "tcp")
 		}
 
-		portNum, err := strconv.Atoi(fields[0])
+		portNum, err := strconv.ParseUint(fields[0], 10, 16)
 		if err != nil {
 			return err
 		}
-		userPort = types.OCICNIPortMapping{
-			HostPort:      0,
-			ContainerPort: int32(portNum),
-			Protocol:      fields[1],
-			HostIP:        "",
-		}
+		userPort = uint16(portNum)
+		userProto = fields[1]
 	}
 
 	reports, err := registry.ContainerEngine().ContainerPort(registry.GetContext(), container, portOpts)
@@ -120,24 +116,36 @@ func port(_ *cobra.Command, args []string) error {
 	var found bool
 	// Iterate mappings
 	for _, report := range reports {
+		allPrefix := ""
+		if portOpts.All {
+			allPrefix = report.Id[:12] + "\t"
+		}
 		for _, v := range report.Ports {
 			hostIP := v.HostIP
 			// Set host IP to 0.0.0.0 if blank
 			if hostIP == "" {
 				hostIP = "0.0.0.0"
 			}
-			if portOpts.All {
-				fmt.Printf("%s\t", report.Id[:12])
-			}
-			// If not searching by port or port/proto, then dump what we see
-			if port == "" {
-				fmt.Printf("%d/%s -> %s:%d\n", v.ContainerPort, v.Protocol, hostIP, v.HostPort)
-				continue
-			}
-			if v.ContainerPort == userPort.ContainerPort {
-				fmt.Printf("%s:%d\n", hostIP, v.HostPort)
-				found = true
-				break
+			protocols := strings.Split(v.Protocol, ",")
+			for _, protocol := range protocols {
+				// If not searching by port or port/proto, then dump what we see
+				if port == "" {
+					for i := uint16(0); i < v.Range; i++ {
+						fmt.Printf("%s%d/%s -> %s:%d\n", allPrefix, v.ContainerPort+i, protocol, hostIP, v.HostPort+i)
+					}
+					continue
+				}
+				// check if the proto matches and if the port is in the range
+				// this is faster than looping over the range for no reason
+				if v.Protocol == userProto &&
+					v.ContainerPort <= userPort &&
+					v.ContainerPort+v.Range > userPort {
+					// we have to add the current range to the host port
+					hostPort := v.HostPort + userPort - v.ContainerPort
+					fmt.Printf("%s%s:%d\n", allPrefix, hostIP, hostPort)
+					found = true
+					break
+				}
 			}
 		}
 		if !found && port != "" {
diff --git a/cmd/podman/containers/ps.go b/cmd/podman/containers/ps.go
index 9687cd5bd..712de327c 100644
--- a/cmd/podman/containers/ps.go
+++ b/cmd/podman/containers/ps.go
@@ -3,8 +3,6 @@ package containers
 import (
 	"fmt"
 	"os"
-	"sort"
-	"strconv"
 	"strings"
 	"time"
 
@@ -477,174 +475,31 @@ func (l psReporter) UTS() string {
 
 // portsToString converts the ports used to a string of the from "port1, port2"
 // and also groups a continuous list of ports into a readable format.
-func portsToString(ports []types.OCICNIPortMapping) string {
+// The format is IP:HostPort(-Range)->ContainerPort(-Range)/Proto
+func portsToString(ports []types.PortMapping) string {
 	if len(ports) == 0 {
 		return ""
 	}
-	// Sort the ports, so grouping continuous ports become easy.
-	sort.Slice(ports, func(i, j int) bool {
-		return comparePorts(ports[i], ports[j])
-	})
-
-	portGroups := [][]types.OCICNIPortMapping{}
-	currentGroup := []types.OCICNIPortMapping{}
-	for i, v := range ports {
-		var prevPort, nextPort *int32
-		if i > 0 {
-			prevPort = &ports[i-1].ContainerPort
-		}
-		if i+1 < len(ports) {
-			nextPort = &ports[i+1].ContainerPort
-		}
-
-		port := v.ContainerPort
-
-		// Helper functions
-		addToCurrentGroup := func(x types.OCICNIPortMapping) {
-			currentGroup = append(currentGroup, x)
-		}
-
-		addToPortGroup := func(x types.OCICNIPortMapping) {
-			portGroups = append(portGroups, []types.OCICNIPortMapping{x})
-		}
-
-		finishCurrentGroup := func() {
-			portGroups = append(portGroups, currentGroup)
-			currentGroup = []types.OCICNIPortMapping{}
-		}
-
-		// Single entry slice
-		if prevPort == nil && nextPort == nil {
-			addToPortGroup(v)
-		}
-
-		// Start of the slice with len > 0
-		if prevPort == nil && nextPort != nil {
-			isGroup := *nextPort-1 == port
-
-			if isGroup {
-				// Start with a group
-				addToCurrentGroup(v)
-			} else {
-				// Start with single item
-				addToPortGroup(v)
-			}
-
-			continue
-		}
-
-		// Middle of the slice with len > 0
-		if prevPort != nil && nextPort != nil {
-			currentIsGroup := *prevPort+1 == port
-			nextIsGroup := *nextPort-1 == port
-
-			if currentIsGroup {
-				// Maybe in the middle of a group
-				addToCurrentGroup(v)
-
-				if !nextIsGroup {
-					// End of a group
-					finishCurrentGroup()
-				}
-			} else if nextIsGroup {
-				// Start of a new group
-				addToCurrentGroup(v)
-			} else {
-				// No group at all
-				addToPortGroup(v)
-			}
-
-			continue
-		}
-
-		// End of the slice with len > 0
-		if prevPort != nil && nextPort == nil {
-			isGroup := *prevPort+1 == port
-
-			if isGroup {
-				// End group
-				addToCurrentGroup(v)
-				finishCurrentGroup()
-			} else {
-				// End single item
-				addToPortGroup(v)
-			}
-		}
-	}
-
-	portDisplay := []string{}
-	for _, group := range portGroups {
-		if len(group) == 0 {
-			// Usually should not happen, but better do not crash.
-			continue
-		}
-
-		first := group[0]
-
-		hostIP := first.HostIP
+	sb := &strings.Builder{}
+	for _, port := range ports {
+		hostIP := port.HostIP
 		if hostIP == "" {
 			hostIP = "0.0.0.0"
 		}
-
-		// Single mappings
-		if len(group) == 1 {
-			portDisplay = append(portDisplay,
-				fmt.Sprintf(
-					"%s:%d->%d/%s",
-					hostIP, first.HostPort, first.ContainerPort, first.Protocol,
-				),
-			)
-			continue
-		}
-
-		// Group mappings
-		last := group[len(group)-1]
-		portDisplay = append(portDisplay, formatGroup(
-			fmt.Sprintf("%s/%s", hostIP, first.Protocol),
-			first.HostPort, last.HostPort,
-			first.ContainerPort, last.ContainerPort,
-		))
-	}
-	return strings.Join(portDisplay, ", ")
-}
-
-func comparePorts(i, j types.OCICNIPortMapping) bool {
-	if i.ContainerPort != j.ContainerPort {
-		return i.ContainerPort < j.ContainerPort
-	}
-
-	if i.HostIP != j.HostIP {
-		return i.HostIP < j.HostIP
-	}
-
-	if i.HostPort != j.HostPort {
-		return i.HostPort < j.HostPort
-	}
-
-	return i.Protocol < j.Protocol
-}
-
-// formatGroup returns the group in the format:
-// <IP:firstHost:lastHost->firstCtr:lastCtr/Proto>
-// e.g 0.0.0.0:1000-1006->2000-2006/tcp.
-func formatGroup(key string, firstHost, lastHost, firstCtr, lastCtr int32) string {
-	parts := strings.Split(key, "/")
-	groupType := parts[0]
-	var ip string
-	if len(parts) > 1 {
-		ip = parts[0]
-		groupType = parts[1]
-	}
-
-	group := func(first, last int32) string {
-		group := strconv.Itoa(int(first))
-		if first != last {
-			group = fmt.Sprintf("%s-%d", group, last)
+		protocols := strings.Split(port.Protocol, ",")
+		for _, protocol := range protocols {
+			if port.Range > 1 {
+				fmt.Fprintf(sb, "%s:%d-%d->%d-%d/%s, ",
+					hostIP, port.HostPort, port.HostPort+port.Range-1,
+					port.ContainerPort, port.ContainerPort+port.Range-1, protocol)
+			} else {
+				fmt.Fprintf(sb, "%s:%d->%d/%s, ",
+					hostIP, port.HostPort,
+					port.ContainerPort, protocol)
+			}
 		}
-		return group
 	}
-	hostGroup := group(firstHost, lastHost)
-	ctrGroup := group(firstCtr, lastCtr)
-
-	return fmt.Sprintf("%s:%s->%s/%s", ip, hostGroup, ctrGroup, groupType)
+	display := sb.String()
+	// make sure to trim the last ", " of the string
+	return display[:len(display)-2]
 }