Merge pull request #9868 from mheon/310_backports

Final backports for v3.1.0

10 files changed, 150 insertions, 101 deletions

diff --git a/pkg/api/handlers/compat/containers.go b/pkg/api/handlers/compat/containers.go
index d3277b815..e7146a5d8 100644
--- a/pkg/api/handlers/compat/containers.go
+++ b/pkg/api/handlers/compat/containers.go
@@ -19,6 +19,7 @@ import (
 	"github.com/containers/podman/v3/pkg/domain/infra/abi"
 	"github.com/containers/podman/v3/pkg/ps"
 	"github.com/containers/podman/v3/pkg/signal"
+	"github.com/containers/podman/v3/pkg/util"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/go-connections/nat"
@@ -92,23 +93,24 @@ func ListContainers(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
-		All     bool                `schema:"all"`
-		Limit   int                 `schema:"limit"`
-		Size    bool                `schema:"size"`
-		Filters map[string][]string `schema:"filters"`
+		All   bool `schema:"all"`
+		Limit int  `schema:"limit"`
+		Size  bool `schema:"size"`
 	}{
 		// override any golang type defaults
 	}
 
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
+	filterMap, err := util.PrepareFilters(r)
+
+	if dErr := decoder.Decode(&query, r.URL.Query()); dErr != nil || err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
 
-	filterFuncs := make([]libpod.ContainerFilter, 0, len(query.Filters))
+	filterFuncs := make([]libpod.ContainerFilter, 0, len(*filterMap))
 	all := query.All || query.Limit > 0
-	if len(query.Filters) > 0 {
-		for k, v := range query.Filters {
+	if len((*filterMap)) > 0 {
+		for k, v := range *filterMap {
 			generatedFunc, err := filters.GenerateContainerFilterFuncs(k, v, runtime)
 			if err != nil {
 				utils.InternalServerError(w, err)
@@ -120,7 +122,7 @@ func ListContainers(w http.ResponseWriter, r *http.Request) {
 
 	// Docker thinks that if status is given as an input, then we should override
 	// the all setting and always deal with all containers.
-	if len(query.Filters["status"]) > 0 {
+	if len((*filterMap)["status"]) > 0 {
 		all = true
 	}
 	if !all {
diff --git a/pkg/api/handlers/compat/containers_prune.go b/pkg/api/handlers/compat/containers_prune.go
index dc4d53af6..e37929d27 100644
--- a/pkg/api/handlers/compat/containers_prune.go
+++ b/pkg/api/handlers/compat/containers_prune.go
@@ -9,23 +9,20 @@ import (
 	"github.com/containers/podman/v3/pkg/api/handlers/utils"
 	"github.com/containers/podman/v3/pkg/domain/entities/reports"
 	"github.com/containers/podman/v3/pkg/domain/filters"
-	"github.com/gorilla/schema"
+	"github.com/containers/podman/v3/pkg/util"
 	"github.com/pkg/errors"
 )
 
 func PruneContainers(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-
-	query := struct {
-		Filters map[string][]string `schema:"filters"`
-	}{}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
+	filtersMap, err := util.PrepareFilters(r)
+	if err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
-	filterFuncs := make([]libpod.ContainerFilter, 0, len(query.Filters))
-	for k, v := range query.Filters {
+
+	filterFuncs := make([]libpod.ContainerFilter, 0, len(*filtersMap))
+	for k, v := range *filtersMap {
 		generatedFunc, err := filters.GenerateContainerFilterFuncs(k, v, runtime)
 		if err != nil {
 			utils.InternalServerError(w, err)
diff --git a/pkg/api/handlers/compat/images_build.go b/pkg/api/handlers/compat/images_build.go
index 7751b91a7..36785a362 100644
--- a/pkg/api/handlers/compat/images_build.go
+++ b/pkg/api/handlers/compat/images_build.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/containers/buildah"
+	"github.com/containers/buildah/define"
 	"github.com/containers/buildah/imagebuildah"
 	"github.com/containers/buildah/util"
 	"github.com/containers/image/v5/types"
@@ -69,7 +70,7 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		BuildArgs              string `schema:"buildargs"`
 		CacheFrom              string `schema:"cachefrom"`
 		Compression            uint64 `schema:"compression"`
-		ConfigureNetwork       int64  `schema:"networkmode"`
+		ConfigureNetwork       string `schema:"networkmode"`
 		CpuPeriod              uint64 `schema:"cpuperiod"`  // nolint
 		CpuQuota               int64  `schema:"cpuquota"`   // nolint
 		CpuSetCpus             string `schema:"cpusetcpus"` // nolint
@@ -84,7 +85,7 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		ForceRm                bool   `schema:"forcerm"`
 		From                   string `schema:"from"`
 		HTTPProxy              bool   `schema:"httpproxy"`
-		Isolation              int64  `schema:"isolation"`
+		Isolation              string `schema:"isolation"`
 		Ignore                 bool   `schema:"ignore"`
 		Jobs                   int    `schema:"jobs"` // nolint
 		Labels                 string `schema:"labels"`
@@ -98,6 +99,7 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		OutputFormat           string `schema:"outputformat"`
 		Platform               string `schema:"platform"`
 		Pull                   bool   `schema:"pull"`
+		PullPolicy             string `schema:"pullpolicy"`
 		Quiet                  bool   `schema:"q"`
 		Registry               string `schema:"registry"`
 		Rm                     bool   `schema:"rm"`
@@ -199,15 +201,17 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 	}
 	format := buildah.Dockerv2ImageManifest
 	registry := query.Registry
-	isolation := buildah.IsolationChroot
-	/*
-		// FIXME, This is very broken.  Buildah will only work with chroot
-		isolation := buildah.IsolationDefault
-	*/
+	isolation := buildah.IsolationDefault
 	if utils.IsLibpodRequest(r) {
-		//		isolation = buildah.Isolation(query.Isolation)
+		isolation = parseLibPodIsolation(query.Isolation)
 		registry = ""
 		format = query.OutputFormat
+	} else {
+		if _, found := r.URL.Query()["isolation"]; found {
+			if query.Isolation != "" && query.Isolation != "default" {
+				logrus.Debugf("invalid `isolation` parameter: %q", query.Isolation)
+			}
+		}
 	}
 	var additionalTags []string
 	if len(query.Tag) > 1 {
@@ -273,10 +277,14 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		jobs = query.Jobs
 	}
 
-	pullPolicy := buildah.PullIfMissing
-	if _, found := r.URL.Query()["pull"]; found {
-		if query.Pull {
-			pullPolicy = buildah.PullAlways
+	pullPolicy := define.PullIfMissing
+	if utils.IsLibpodRequest(r) {
+		pullPolicy = define.PolicyMap[query.PullPolicy]
+	} else {
+		if _, found := r.URL.Query()["pull"]; found {
+			if query.Pull {
+				pullPolicy = define.PullAlways
+			}
 		}
 	}
 
@@ -329,7 +337,7 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		CNIConfigDir:                   rtc.Network.CNIPluginDirs[0],
 		CNIPluginPath:                  util.DefaultCNIPluginPath,
 		Compression:                    compression,
-		ConfigureNetwork:               buildah.NetworkConfigurationPolicy(query.ConfigureNetwork),
+		ConfigureNetwork:               parseNetworkConfigurationPolicy(query.ConfigureNetwork),
 		ContextDirectory:               contextDirectory,
 		Devices:                        devices,
 		DropCapabilities:               dropCaps,
@@ -459,6 +467,40 @@ loop:
 	}
 }
 
+func parseNetworkConfigurationPolicy(network string) buildah.NetworkConfigurationPolicy {
+	if val, err := strconv.Atoi(network); err == nil {
+		return buildah.NetworkConfigurationPolicy(val)
+	}
+	switch network {
+	case "NetworkDefault":
+		return buildah.NetworkDefault
+	case "NetworkDisabled":
+		return buildah.NetworkDisabled
+	case "NetworkEnabled":
+		return buildah.NetworkEnabled
+	default:
+		return buildah.NetworkDefault
+	}
+}
+
+func parseLibPodIsolation(isolation string) buildah.Isolation { // nolint
+	if val, err := strconv.Atoi(isolation); err == nil {
+		return buildah.Isolation(val)
+	}
+	switch isolation {
+	case "IsolationDefault", "default":
+		return buildah.IsolationDefault
+	case "IsolationOCI":
+		return buildah.IsolationOCI
+	case "IsolationChroot":
+		return buildah.IsolationChroot
+	case "IsolationOCIRootless":
+		return buildah.IsolationOCIRootless
+	default:
+		return buildah.IsolationDefault
+	}
+}
+
 func extractTarFile(r *http.Request) (string, error) {
 	// build a home for the request body
 	anchorDir, err := ioutil.TempDir("", "libpod_builder")
diff --git a/pkg/api/handlers/compat/images_prune.go b/pkg/api/handlers/compat/images_prune.go
index 63daaa780..ddf559ec6 100644
--- a/pkg/api/handlers/compat/images_prune.go
+++ b/pkg/api/handlers/compat/images_prune.go
@@ -8,8 +8,8 @@ import (
 	"github.com/containers/podman/v3/libpod"
 	"github.com/containers/podman/v3/pkg/api/handlers"
 	"github.com/containers/podman/v3/pkg/api/handlers/utils"
+	"github.com/containers/podman/v3/pkg/util"
 	"github.com/docker/docker/api/types"
-	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 )
 
@@ -17,27 +17,20 @@ func PruneImages(w http.ResponseWriter, r *http.Request) {
 	var (
 		filters []string
 	)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 
-	query := struct {
-		All     bool
-		Filters map[string][]string `schema:"filters"`
-	}{
-		// This is where you can override the golang default value for one of fields
-	}
-
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, "Something went wrong.", http.StatusBadRequest, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
+	filterMap, err := util.PrepareFilters(r)
+	if err != nil {
+		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
 
-	for k, v := range query.Filters {
+	for k, v := range *filterMap {
 		for _, val := range v {
 			filters = append(filters, fmt.Sprintf("%s=%s", k, val))
 		}
 	}
-	imagePruneReports, err := runtime.ImageRuntime().PruneImages(r.Context(), query.All, filters)
+	imagePruneReports, err := runtime.ImageRuntime().PruneImages(r.Context(), false, filters)
 	if err != nil {
 		utils.InternalServerError(w, err)
 		return
diff --git a/pkg/api/handlers/compat/images_remove.go b/pkg/api/handlers/compat/images_remove.go
index 874c57f16..e89558a86 100644
--- a/pkg/api/handlers/compat/images_remove.go
+++ b/pkg/api/handlers/compat/images_remove.go
@@ -4,7 +4,10 @@ import (
 	"net/http"
 
 	"github.com/containers/podman/v3/libpod"
+	"github.com/containers/podman/v3/libpod/define"
 	"github.com/containers/podman/v3/pkg/api/handlers/utils"
+	"github.com/containers/podman/v3/pkg/domain/entities"
+	"github.com/containers/podman/v3/pkg/domain/infra/abi"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 )
@@ -30,28 +33,32 @@ func RemoveImage(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 	name := utils.GetName(r)
-	newImage, err := runtime.ImageRuntime().NewFromLocal(name)
-	if err != nil {
-		utils.ImageNotFound(w, name, errors.Wrapf(err, "failed to find image %s", name))
-		return
+	imageEngine := abi.ImageEngine{Libpod: runtime}
+
+	options := entities.ImageRemoveOptions{
+		Force: query.Force,
 	}
+	report, rmerrors := imageEngine.Remove(r.Context(), []string{name}, options)
+	if len(rmerrors) > 0 && rmerrors[0] != nil {
+		err := rmerrors[0]
+		if errors.Cause(err) == define.ErrNoSuchImage {
+			utils.ImageNotFound(w, name, errors.Wrapf(err, "failed to find image %s", name))
+			return
+		}
 
-	results, err := runtime.RemoveImage(r.Context(), newImage, query.Force)
-	if err != nil {
 		utils.Error(w, "Something went wrong.", http.StatusInternalServerError, err)
 		return
 	}
-
-	response := make([]map[string]string, 0, len(results.Untagged)+1)
-	deleted := make(map[string]string, 1)
-	deleted["Deleted"] = results.Deleted
-	response = append(response, deleted)
-
-	for _, u := range results.Untagged {
+	response := make([]map[string]string, 0, len(report.Untagged)+1)
+	for _, d := range report.Deleted {
+		deleted := make(map[string]string, 1)
+		deleted["Deleted"] = d
+		response = append(response, deleted)
+	}
+	for _, u := range report.Untagged {
 		untagged := make(map[string]string, 1)
 		untagged["Untagged"] = u
 		response = append(response, untagged)
 	}
-
 	utils.WriteResponse(w, http.StatusOK, response)
 }
diff --git a/pkg/api/handlers/compat/resize.go b/pkg/api/handlers/compat/resize.go
index 1bf7ad460..23ed33a22 100644
--- a/pkg/api/handlers/compat/resize.go
+++ b/pkg/api/handlers/compat/resize.go
@@ -19,8 +19,9 @@ func ResizeTTY(w http.ResponseWriter, r *http.Request) {
 
 	// /containers/{id}/resize
 	query := struct {
-		Height uint16 `schema:"h"`
-		Width  uint16 `schema:"w"`
+		Height           uint16 `schema:"h"`
+		Width            uint16 `schema:"w"`
+		IgnoreNotRunning bool   `schema:"running"`
 	}{
 		// override any golang type defaults
 	}
@@ -48,14 +49,17 @@ func ResizeTTY(w http.ResponseWriter, r *http.Request) {
 		if state, err := ctnr.State(); err != nil {
 			utils.InternalServerError(w, errors.Wrapf(err, "cannot obtain container state"))
 			return
-		} else if state != define.ContainerStateRunning {
+		} else if state != define.ContainerStateRunning && !query.IgnoreNotRunning {
 			utils.Error(w, "Container not running", http.StatusConflict,
 				fmt.Errorf("container %q in wrong state %q", name, state.String()))
 			return
 		}
+		// If container is not running, ignore since this can be a race condition, and is expected
 		if err := ctnr.AttachResize(sz); err != nil {
-			utils.InternalServerError(w, errors.Wrapf(err, "cannot resize container"))
-			return
+			if errors.Cause(err) != define.ErrCtrStateInvalid || !query.IgnoreNotRunning {
+				utils.InternalServerError(w, errors.Wrapf(err, "cannot resize container"))
+				return
+			}
 		}
 		// This is not a 204, even though we write nothing, for compatibility
 		// reasons.
@@ -70,14 +74,16 @@ func ResizeTTY(w http.ResponseWriter, r *http.Request) {
 		if state, err := ctnr.State(); err != nil {
 			utils.InternalServerError(w, errors.Wrapf(err, "cannot obtain session container state"))
 			return
-		} else if state != define.ContainerStateRunning {
+		} else if state != define.ContainerStateRunning && !query.IgnoreNotRunning {
 			utils.Error(w, "Container not running", http.StatusConflict,
 				fmt.Errorf("container %q in wrong state %q", name, state.String()))
 			return
 		}
 		if err := ctnr.ExecResize(name, sz); err != nil {
-			utils.InternalServerError(w, errors.Wrapf(err, "cannot resize session"))
-			return
+			if errors.Cause(err) != define.ErrCtrStateInvalid || !query.IgnoreNotRunning {
+				utils.InternalServerError(w, errors.Wrapf(err, "cannot resize session"))
+				return
+			}
 		}
 		// This is not a 204, even though we write nothing, for compatibility
 		// reasons.
diff --git a/pkg/api/handlers/libpod/containers.go b/pkg/api/handlers/libpod/containers.go
index 01b9ec101..77269db8b 100644
--- a/pkg/api/handlers/libpod/containers.go
+++ b/pkg/api/handlers/libpod/containers.go
@@ -11,6 +11,7 @@ import (
 	"github.com/containers/podman/v3/pkg/api/handlers/utils"
 	"github.com/containers/podman/v3/pkg/domain/entities"
 	"github.com/containers/podman/v3/pkg/domain/infra/abi"
+	"github.com/containers/podman/v3/pkg/util"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -59,20 +60,21 @@ func ContainerExists(w http.ResponseWriter, r *http.Request) {
 func ListContainers(w http.ResponseWriter, r *http.Request) {
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
-		All       bool                `schema:"all"`
-		External  bool                `schema:"external"`
-		Filters   map[string][]string `schema:"filters"`
-		Last      int                 `schema:"last"` // alias for limit
-		Limit     int                 `schema:"limit"`
-		Namespace bool                `schema:"namespace"`
-		Size      bool                `schema:"size"`
-		Sync      bool                `schema:"sync"`
+		All       bool `schema:"all"`
+		External  bool `schema:"external"`
+		Last      int  `schema:"last"` // alias for limit
+		Limit     int  `schema:"limit"`
+		Namespace bool `schema:"namespace"`
+		Size      bool `schema:"size"`
+		Sync      bool `schema:"sync"`
 	}{
 		// override any golang type defaults
 	}
 
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+	filterMap, err := util.PrepareFilters(r)
+
+	if dErr := decoder.Decode(&query, r.URL.Query()); dErr != nil || err != nil {
+		utils.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError,
 			errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
@@ -94,7 +96,7 @@ func ListContainers(w http.ResponseWriter, r *http.Request) {
 	opts := entities.ContainerListOptions{
 		All:       query.All,
 		External:  query.External,
-		Filters:   query.Filters,
+		Filters:   *filterMap,
 		Last:      limit,
 		Namespace: query.Namespace,
 		// Always return Pod, should not be part of the API.
diff --git a/pkg/api/handlers/libpod/images.go b/pkg/api/handlers/libpod/images.go
index 1f306a533..158babcdc 100644
--- a/pkg/api/handlers/libpod/images.go
+++ b/pkg/api/handlers/libpod/images.go
@@ -22,6 +22,7 @@ import (
 	"github.com/containers/podman/v3/pkg/domain/entities"
 	"github.com/containers/podman/v3/pkg/domain/infra/abi"
 	"github.com/containers/podman/v3/pkg/errorhandling"
+	"github.com/containers/podman/v3/pkg/util"
 	utils2 "github.com/containers/podman/v3/utils"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
@@ -125,31 +126,32 @@ func PruneImages(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	decoder := r.Context().Value("decoder").(*schema.Decoder)
 	query := struct {
-		All     bool                `schema:"all"`
-		Filters map[string][]string `schema:"filters"`
+		All bool `schema:"all"`
 	}{
 		// override any golang type defaults
 	}
 
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
-		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
+	filterMap, err := util.PrepareFilters(r)
+
+	if dErr := decoder.Decode(&query, r.URL.Query()); dErr != nil || err != nil {
+		utils.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError,
 			errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
 	}
 
 	var libpodFilters = []string{}
 	if _, found := r.URL.Query()["filters"]; found {
-		dangling := query.Filters["all"]
+		dangling := (*filterMap)["all"]
 		if len(dangling) > 0 {
-			query.All, err = strconv.ParseBool(query.Filters["all"][0])
+			query.All, err = strconv.ParseBool((*filterMap)["all"][0])
 			if err != nil {
 				utils.InternalServerError(w, err)
 				return
 			}
 		}
 		// dangling is special and not implemented in the libpod side of things
-		delete(query.Filters, "dangling")
-		for k, v := range query.Filters {
+		delete(*filterMap, "dangling")
+		for k, v := range *filterMap {
 			libpodFilters = append(libpodFilters, fmt.Sprintf("%s=%s", k, v[0]))
 		}
 	}
diff --git a/pkg/api/handlers/libpod/pods.go b/pkg/api/handlers/libpod/pods.go
index 89a4a451f..4dc8740e2 100644
--- a/pkg/api/handlers/libpod/pods.go
+++ b/pkg/api/handlers/libpod/pods.go
@@ -44,13 +44,9 @@ func PodCreate(w http.ResponseWriter, r *http.Request) {
 
 func Pods(w http.ResponseWriter, r *http.Request) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
-	decoder := r.Context().Value("decoder").(*schema.Decoder)
-	query := struct {
-		Filters map[string][]string `schema:"filters"`
-	}{
-		// override any golang type defaults
-	}
-	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
+
+	filterMap, err := util.PrepareFilters(r)
+	if err != nil {
 		utils.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest,
 			errors.Wrapf(err, "failed to parse parameters for %s", r.URL.String()))
 		return
@@ -58,7 +54,7 @@ func Pods(w http.ResponseWriter, r *http.Request) {
 
 	containerEngine := abi.ContainerEngine{Libpod: runtime}
 	podPSOptions := entities.PodPSOptions{
-		Filters: query.Filters,
+		Filters: *filterMap,
 	}
 	pods, err := containerEngine.PodPs(r.Context(), podPSOptions)
 	if err != nil {
diff --git a/pkg/api/handlers/utils/images.go b/pkg/api/handlers/utils/images.go
index 743629db8..da3c9e985 100644
--- a/pkg/api/handlers/utils/images.go
+++ b/pkg/api/handlers/utils/images.go
@@ -11,6 +11,7 @@ import (
 	"github.com/containers/image/v5/types"
 	"github.com/containers/podman/v3/libpod"
 	"github.com/containers/podman/v3/libpod/image"
+	"github.com/containers/podman/v3/pkg/util"
 	"github.com/gorilla/schema"
 	"github.com/pkg/errors"
 )
@@ -58,13 +59,17 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
 	query := struct {
 		All     bool
-		Filters map[string][]string `schema:"filters"`
 		Digests bool
 		Filter  string // Docker 1.24 compatibility
 	}{
 		// This is where you can override the golang default value for one of fields
 	}
 
+	filterMap, err := util.PrepareFilters(r)
+	if err != nil {
+		return nil, err
+	}
+
 	if err := decoder.Decode(&query, r.URL.Query()); err != nil {
 		return nil, err
 	}
@@ -72,12 +77,9 @@ func GetImages(w http.ResponseWriter, r *http.Request) ([]*image.Image, error) {
 	if _, found := r.URL.Query()["digests"]; found && query.Digests {
 		UnSupportedParameter("digests")
 	}
-	var (
-		images []*image.Image
-		err    error
-	)
+	var images []*image.Image
 
-	queryFilters := query.Filters
+	queryFilters := *filterMap
 	if !IsLibpodRequest(r) && len(query.Filter) > 0 { // Docker 1.24 compatibility
 		if queryFilters == nil {
 			queryFilters = make(map[string][]string)