@@ -425,7 +425,7 @@ func copyExistingContents(source, destination string) error {

 		}

 		if len(srcList) == 0 {

 			// If the source volume is empty, copies files from the root into the volume

-			if err := chrootarchive.CopyWithTar(source, destination); err != nil {

+			if err := chrootarchive.NewArchiver(nil).CopyWithTar(source, destination); err != nil {

 				return err

 			}

 		}

@@ -413,12 +413,7 @@ func (daemon *Daemon) CopyOnBuild(cID, destPath, srcRoot, srcPath string, decomp

 		destExists = false

 	}

-	archiver := &archive.Archiver{

-		Untar:   chrootarchive.Untar,

-		UIDMaps: daemon.idMappings.UIDs(),

-		GIDMaps: daemon.idMappings.GIDs(),

-	}

-

+	archiver := chrootarchive.NewArchiver(daemon.idMappings)

 	src, err := os.Stat(fullSrcPath)

 	if err != nil {

 		return err

@@ -20,9 +20,6 @@ func (daemon *Daemon) tarCopyOptions(container *container.Container, noOverwrite

 	return &archive.TarOptions{

 		NoOverwriteDirNonDir: noOverwriteDirNonDir,

-		ChownOpts: &archive.TarChownOptions{

-			UID: user.Uid,

-			GID: user.Gid,

-		},

+		ChownOpts:            idtools.IDPair{UID: user.Uid, GID: user.Gid},

 	}, nil

 }

@@ -15,7 +15,7 @@ import (

 var (

 	// CopyWithTar defines the copy method to use.

-	CopyWithTar = chrootarchive.CopyWithTar

+	CopyWithTar = chrootarchive.NewArchiver(nil).CopyWithTar

 )

 func init() {

@@ -152,7 +152,7 @@ func testDirectory(templateDir string) (dir string, err error) {

 		return

 	}

 	if templateDir != "" {

-		if err = archive.CopyWithTar(templateDir, dir); err != nil {

+		if err = archive.NewDefaultArchiver().CopyWithTar(templateDir, dir); err != nil {

 			return

 		}

 	}

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

 func init() {

 	graphdriver.ApplyUncompressedLayer = archive.UnpackLayer

-	vfs.CopyWithTar = archive.CopyWithTar

+	defaultArchiver := archive.NewDefaultArchiver()

+	vfs.CopyWithTar = defaultArchiver.CopyWithTar

 }

 func newVFSGraphDriver(td string) (graphdriver.Driver, error) {

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

 	"bytes"

 	"compress/bzip2"

 	"compress/gzip"

-	"errors"

 	"fmt"

 	"io"

 	"io/ioutil"

@@ -31,10 +30,6 @@ type (

 	Compression int

 	// WhiteoutFormat is the format of whiteouts unpacked

 	WhiteoutFormat int

-	// TarChownOptions wraps the chown options UID and GID.

-	TarChownOptions struct {

-		UID, GID int

-	}

 	// TarOptions wraps the tar options.

 	TarOptions struct {

@@ -44,7 +39,7 @@ type (

 		NoLchown         bool

 		UIDMaps          []idtools.IDMap

 		GIDMaps          []idtools.IDMap

-		ChownOpts        *TarChownOptions

+		ChownOpts        idtools.IDPair

 		IncludeSourceDir bool

 		// WhiteoutFormat is the expected on disk format for whiteout files.

 		// This format will be converted to the standard format on pack

@@ -58,33 +53,26 @@ type (

 		RebaseNames map[string]string

 		InUserNS    bool

 	}

-

-	// Archiver allows the reuse of most utility functions of this package

-	// with a pluggable Untar function. Also, to facilitate the passing of

-	// specific id mappings for untar, an archiver can be created with maps

-	// which will then be passed to Untar operations

-	Archiver struct {

-		Untar   func(io.Reader, string, *TarOptions) error

-		UIDMaps []idtools.IDMap

-		GIDMaps []idtools.IDMap

-	}

-

-	// breakoutError is used to differentiate errors related to breaking out

-	// When testing archive breakout in the unit tests, this error is expected

-	// in order for the test to pass.

-	breakoutError error

 )

-var (

-	// ErrNotImplemented is the error message of function not implemented.

-	ErrNotImplemented = errors.New("Function not implemented")

-	defaultArchiver   = &Archiver{Untar: Untar, UIDMaps: nil, GIDMaps: nil}

-)

+// Archiver allows the reuse of most utility functions of this package

+// with a pluggable Untar function. Also, to facilitate the passing of

+// specific id mappings for untar, an archiver can be created with maps

+// which will then be passed to Untar operations

+type Archiver struct {

+	Untar      func(io.Reader, string, *TarOptions) error

+	IDMappings *idtools.IDMappings

+}

-const (

-	// HeaderSize is the size in bytes of a tar header

-	HeaderSize = 512

-)

+// NewDefaultArchiver returns a new Archiver without any IDMappings

+func NewDefaultArchiver() *Archiver {

+	return &Archiver{Untar: Untar, IDMappings: &idtools.IDMappings{}}

+}

+

+// breakoutError is used to differentiate errors related to breaking out

+// When testing archive breakout in the unit tests, this error is expected

+// in order for the test to pass.

+type breakoutError error

 const (

 	// Uncompressed represents the uncompressed.

@@ -105,18 +93,6 @@ const (

 	OverlayWhiteoutFormat

 )

-// IsArchive checks for the magic bytes of a tar or any supported compression

-// algorithm.

-func IsArchive(header []byte) bool {

-	compression := DetectCompression(header)

-	if compression != Uncompressed {

-		return true

-	}

-	r := tar.NewReader(bytes.NewBuffer(header))

-	_, err := r.Next()

-	return err == nil

-}

-

 // IsArchivePath checks if the (possibly compressed) file at the given path

 // starts with a tar file header.

 func IsArchivePath(path string) bool {

@@ -496,7 +472,7 @@ func (ta *tarAppender) addTarFile(path, name string) error {

 	return nil

 }

-func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, Lchown bool, chownOpts *TarChownOptions, inUserns bool) error {

+func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, Lchown bool, chownOpts *idtools.IDPair, inUserns bool) error {

 	// hdr.Mode is in linux format, which we can use for sycalls,

 	// but for os.Foo() calls we need the mode converted to os.FileMode,

 	// so use hdrInfo.Mode() (they differ for e.g. setuid bits)

@@ -576,7 +552,7 @@ func createTarFile(path, extractDir string, hdr *tar.Header, reader io.Reader, L

 	// Lchown is not supported on Windows.

 	if Lchown && runtime.GOOS != "windows" {

 		if chownOpts == nil {

-			chownOpts = &TarChownOptions{UID: hdr.Uid, GID: hdr.Gid}

+			chownOpts = &idtools.IDPair{UID: hdr.Uid, GID: hdr.Gid}

 		}

 		if err := os.Lchown(path, chownOpts.UID, chownOpts.GID); err != nil {

 			return err

@@ -941,7 +917,7 @@ loop:

 			}

 		}

-		if err := createTarFile(path, dest, hdr, trBuf, !options.NoLchown, options.ChownOpts, options.InUserNS); err != nil {

+		if err := createTarFile(path, dest, hdr, trBuf, !options.NoLchown, &options.ChownOpts, options.InUserNS); err != nil {

 			return err

 		}

@@ -1013,23 +989,13 @@ func (archiver *Archiver) TarUntar(src, dst string) error {

 		return err

 	}

 	defer archive.Close()

-

-	var options *TarOptions

-	if archiver.UIDMaps != nil || archiver.GIDMaps != nil {

-		options = &TarOptions{

-			UIDMaps: archiver.UIDMaps,

-			GIDMaps: archiver.GIDMaps,

-		}

+	options := &TarOptions{

+		UIDMaps: archiver.IDMappings.UIDs(),

+		GIDMaps: archiver.IDMappings.GIDs(),

 	}

 	return archiver.Untar(archive, dst, options)

 }

-// TarUntar is a convenience function which calls Tar and Untar, with the output of one piped into the other.

-// If either Tar or Untar fails, TarUntar aborts and returns the error.

-func TarUntar(src, dst string) error {

-	return defaultArchiver.TarUntar(src, dst)

-}

-

 // UntarPath untar a file from path to a destination, src is the source tar file path.

 func (archiver *Archiver) UntarPath(src, dst string) error {

 	archive, err := os.Open(src)

@@ -1037,22 +1003,13 @@ func (archiver *Archiver) UntarPath(src, dst string) error {

 		return err

 	}

 	defer archive.Close()

-	var options *TarOptions

-	if archiver.UIDMaps != nil || archiver.GIDMaps != nil {

-		options = &TarOptions{

-			UIDMaps: archiver.UIDMaps,

-			GIDMaps: archiver.GIDMaps,

-		}

+	options := &TarOptions{

+		UIDMaps: archiver.IDMappings.UIDs(),

+		GIDMaps: archiver.IDMappings.GIDs(),

 	}

 	return archiver.Untar(archive, dst, options)

 }

-// UntarPath is a convenience function which looks for an archive

-// at filesystem path `src`, and unpacks it at `dst`.

-func UntarPath(src, dst string) error {

-	return defaultArchiver.UntarPath(src, dst)

-}

-

 // CopyWithTar creates a tar archive of filesystem path `src`, and

 // unpacks it at filesystem path `dst`.

 // The archive is streamed directly with fixed buffering and no

@@ -1069,27 +1026,19 @@ func (archiver *Archiver) CopyWithTar(src, dst string) error {

 	// if this archiver is set up with ID mapping we need to create

 	// the new destination directory with the remapped root UID/GID pair

 	// as owner

-	rootUID, rootGID, err := idtools.GetRootUIDGID(archiver.UIDMaps, archiver.GIDMaps)

+	rootIDs, err := archiver.IDMappings.RootPair()

 	if err != nil {

 		return err

 	}

 	// Create dst, copy src's content into it

 	logrus.Debugf("Creating dest directory: %s", dst)

-	if err := idtools.MkdirAllNewAs(dst, 0755, rootUID, rootGID); err != nil {

+	if err := idtools.MkdirAllAndChownNew(dst, 0755, rootIDs); err != nil {

 		return err

 	}

 	logrus.Debugf("Calling TarUntar(%s, %s)", src, dst)

 	return archiver.TarUntar(src, dst)

 }

-// CopyWithTar creates a tar archive of filesystem path `src`, and

-// unpacks it at filesystem path `dst`.

-// The archive is streamed directly with fixed buffering and no

-// intermediary disk IO.

-func CopyWithTar(src, dst string) error {

-	return defaultArchiver.CopyWithTar(src, dst)

-}

-

 // CopyFileWithTar emulates the behavior of the 'cp' command-line

 // for a single file. It copies a regular file from path `src` to

 // path `dst`, and preserves all its metadata.

@@ -1131,26 +1080,24 @@ func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {

 		hdr.Name = filepath.Base(dst)

 		hdr.Mode = int64(chmodTarEntry(os.FileMode(hdr.Mode)))

-		remappedRootUID, remappedRootGID, err := idtools.GetRootUIDGID(archiver.UIDMaps, archiver.GIDMaps)

+		remappedRootIDs, err := archiver.IDMappings.RootPair()

 		if err != nil {

 			return err

 		}

 		// only perform mapping if the file being copied isn't already owned by the

 		// uid or gid of the remapped root in the container

-		if remappedRootUID != hdr.Uid {

-			xUID, err := idtools.ToHost(hdr.Uid, archiver.UIDMaps)

+		if remappedRootIDs.UID != hdr.Uid {

+			hdr.Uid, err = archiver.IDMappings.UIDToHost(hdr.Uid)

 			if err != nil {

 				return err

 			}

-			hdr.Uid = xUID

 		}

-		if remappedRootGID != hdr.Gid {

-			xGID, err := idtools.ToHost(hdr.Gid, archiver.GIDMaps)

+		if remappedRootIDs.GID != hdr.Gid {

+			hdr.Gid, err = archiver.IDMappings.GIDToHost(hdr.Gid)

 			if err != nil {

 				return err

 			}

-			hdr.Gid = xGID

 		}

 		tw := tar.NewWriter(w)

@@ -1176,18 +1123,6 @@ func (archiver *Archiver) CopyFileWithTar(src, dst string) (err error) {

 	return err

 }

-// CopyFileWithTar emulates the behavior of the 'cp' command-line

-// for a single file. It copies a regular file from path `src` to

-// path `dst`, and preserves all its metadata.

-//

-// Destination handling is in an operating specific manner depending

-// where the daemon is running. If `dst` ends with a trailing slash

-// the final destination path will be `dst/base(src)`  (Linux) or

-// `dst\base(src)` (Windows).

-func CopyFileWithTar(src, dst string) (err error) {

-	return defaultArchiver.CopyFileWithTar(src, dst)

-}

-

 // cmdStream executes a command, and returns its stdout as a stream.

 // If the command fails to run or doesn't complete successfully, an error

 // will be returned, including anything written on stderr.

@@ -27,35 +27,22 @@ func init() {

 	}

 }

-func TestIsArchiveNilHeader(t *testing.T) {

-	out := IsArchive(nil)

-	if out {

-		t.Fatalf("isArchive should return false as nil is not a valid archive header")

-	}

+var defaultArchiver = NewDefaultArchiver()

+

+func defaultTarUntar(src, dst string) error {

+	return defaultArchiver.TarUntar(src, dst)

 }

-func TestIsArchiveInvalidHeader(t *testing.T) {

-	header := []byte{0x00, 0x01, 0x02}

-	out := IsArchive(header)

-	if out {

-		t.Fatalf("isArchive should return false as %s is not a valid archive header", header)

-	}

+func defaultUntarPath(src, dst string) error {

+	return defaultArchiver.UntarPath(src, dst)

 }

-func TestIsArchiveBzip2(t *testing.T) {

-	header := []byte{0x42, 0x5A, 0x68}

-	out := IsArchive(header)

-	if !out {

-		t.Fatalf("isArchive should return true as %s is a bz2 header", header)

-	}

+func defaultCopyFileWithTar(src, dst string) (err error) {

+	return defaultArchiver.CopyFileWithTar(src, dst)

 }

-func TestIsArchive7zip(t *testing.T) {

-	header := []byte{0x50, 0x4b, 0x03, 0x04}

-	out := IsArchive(header)

-	if out {

-		t.Fatalf("isArchive should return false as %s is a 7z header and it is not supported", header)

-	}

+func defaultCopyWithTar(src, dst string) error {

+	return defaultArchiver.CopyWithTar(src, dst)

 }

 func TestIsArchivePathDir(t *testing.T) {

@@ -301,7 +288,7 @@ func TestUntarPathWithInvalidDest(t *testing.T) {

 		t.Fatal(err)

 	}

-	err = UntarPath(tarFile, invalidDestFolder)

+	err = defaultUntarPath(tarFile, invalidDestFolder)

 	if err == nil {

 		t.Fatalf("UntarPath with invalid destination path should throw an error.")

 	}

@@ -313,7 +300,7 @@ func TestUntarPathWithInvalidSrc(t *testing.T) {

 		t.Fatalf("Fail to create the destination file")

 	}

 	defer os.RemoveAll(dest)

-	err = UntarPath("/invalid/path", dest)

+	err = defaultUntarPath("/invalid/path", dest)

 	if err == nil {

 		t.Fatalf("UntarPath with invalid src path should throw an error.")

 	}

@@ -348,7 +335,7 @@ func TestUntarPath(t *testing.T) {

 		t.Fatal(err)

 	}

-	err = UntarPath(tarFile, destFolder)

+	err = defaultUntarPath(tarFile, destFolder)

 	if err != nil {

 		t.Fatalf("UntarPath shouldn't throw an error, %s.", err)

 	}

@@ -387,7 +374,7 @@ func TestUntarPathWithDestinationFile(t *testing.T) {

 	if err != nil {

 		t.Fatalf("Fail to create the destination file")

 	}

-	err = UntarPath(tarFile, destFile)

+	err = defaultUntarPath(tarFile, destFile)

 	if err == nil {

 		t.Fatalf("UntarPath should throw an error if the destination if a file")

 	}

@@ -430,7 +417,7 @@ func TestUntarPathWithDestinationSrcFileAsFolder(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	err = UntarPath(tarFile, destFolder)

+	err = defaultUntarPath(tarFile, destFolder)

 	if err != nil {

 		t.Fatalf("UntarPath should throw not throw an error if the extracted file already exists and is a folder")

 	}

@@ -447,7 +434,7 @@ func TestCopyWithTarInvalidSrc(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	err = CopyWithTar(invalidSrc, destFolder)

+	err = defaultCopyWithTar(invalidSrc, destFolder)

 	if err == nil {

 		t.Fatalf("archiver.CopyWithTar with invalid src path should throw an error.")

 	}

@@ -464,7 +451,7 @@ func TestCopyWithTarInexistentDestWillCreateIt(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	err = CopyWithTar(srcFolder, inexistentDestFolder)

+	err = defaultCopyWithTar(srcFolder, inexistentDestFolder)

 	if err != nil {

 		t.Fatalf("CopyWithTar with an inexistent folder shouldn't fail.")

 	}

@@ -493,7 +480,7 @@ func TestCopyWithTarSrcFile(t *testing.T) {

 		t.Fatal(err)

 	}

 	ioutil.WriteFile(src, []byte("content"), 0777)

-	err = CopyWithTar(src, dest)

+	err = defaultCopyWithTar(src, dest)

 	if err != nil {

 		t.Fatalf("archiver.CopyWithTar shouldn't throw an error, %s.", err)

 	}

@@ -522,7 +509,7 @@ func TestCopyWithTarSrcFolder(t *testing.T) {

 		t.Fatal(err)

 	}

 	ioutil.WriteFile(filepath.Join(src, "file"), []byte("content"), 0777)

-	err = CopyWithTar(src, dest)

+	err = defaultCopyWithTar(src, dest)

 	if err != nil {

 		t.Fatalf("archiver.CopyWithTar shouldn't throw an error, %s.", err)

 	}

@@ -545,7 +532,7 @@ func TestCopyFileWithTarInvalidSrc(t *testing.T) {

 		t.Fatal(err)

 	}

 	invalidFile := filepath.Join(tempFolder, "doesnotexists")

-	err = CopyFileWithTar(invalidFile, destFolder)

+	err = defaultCopyFileWithTar(invalidFile, destFolder)

 	if err == nil {

 		t.Fatalf("archiver.CopyWithTar with invalid src path should throw an error.")

 	}

@@ -563,7 +550,7 @@ func TestCopyFileWithTarInexistentDestWillCreateIt(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	err = CopyFileWithTar(srcFile, inexistentDestFolder)

+	err = defaultCopyFileWithTar(srcFile, inexistentDestFolder)

 	if err != nil {

 		t.Fatalf("CopyWithTar with an inexistent folder shouldn't fail.")

 	}

@@ -590,7 +577,7 @@ func TestCopyFileWithTarSrcFolder(t *testing.T) {

 	if err != nil {

 		t.Fatal(err)

 	}

-	err = CopyFileWithTar(src, dest)

+	err = defaultCopyFileWithTar(src, dest)

 	if err == nil {

 		t.Fatalf("CopyFileWithTar should throw an error with a folder.")

 	}

@@ -614,7 +601,7 @@ func TestCopyFileWithTarSrcFile(t *testing.T) {

 		t.Fatal(err)

 	}

 	ioutil.WriteFile(src, []byte("content"), 0777)

-	err = CopyWithTar(src, dest+"/")

+	err = defaultCopyWithTar(src, dest+"/")

 	if err != nil {

 		t.Fatalf("archiver.CopyFileWithTar shouldn't throw an error, %s.", err)

 	}

@@ -657,7 +644,7 @@ func checkNoChanges(fileNum int, hardlinks bool) error {

 		return err

 	}

-	err = TarUntar(srcDir, destDir)

+	err = defaultTarUntar(srcDir, destDir)

 	if err != nil {

 		return err

 	}

@@ -871,7 +858,7 @@ func BenchmarkTarUntar(b *testing.B) {

 	b.ResetTimer()

 	b.SetBytes(int64(n))

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

-		err := TarUntar(origin, target)

+		err := defaultTarUntar(origin, target)

 		if err != nil {

 			b.Fatal(err)

 		}

@@ -899,7 +886,7 @@ func BenchmarkTarUntarWithLinks(b *testing.B) {

 	b.ResetTimer()

 	b.SetBytes(int64(n))

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

-		err := TarUntar(origin, target)

+		err := defaultTarUntar(origin, target)

 		if err != nil {

 			b.Fatal(err)

 		}

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

 		t.Fatal(err)

 	}

 	ioutil.WriteFile(src, []byte("content"), 0777)

-	err = CopyWithTar(src, dest)

+	err = defaultCopyWithTar(src, dest)

 	if err == nil {

 		t.Fatalf("archiver.CopyWithTar should throw an error on invalid dest.")

 	}

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

 	"github.com/docker/docker/pkg/idtools"

 )

-var chrootArchiver = &archive.Archiver{Untar: Untar}

+// NewArchiver returns a new Archiver which uses chrootarchive.Untar

+func NewArchiver(idMappings *idtools.IDMappings) *archive.Archiver {

+	if idMappings == nil {

+		idMappings = &idtools.IDMappings{}

+	}

+	return &archive.Archiver{Untar: Untar, IDMappings: idMappings}

+}

 // Untar reads a stream of bytes from `archive`, parses it as a tar archive,

 // and unpacks it into the directory at `dest`.

@@ -30,7 +36,6 @@ func UntarUncompressed(tarArchive io.Reader, dest string, options *archive.TarOp

 // Handler for teasing out the automatic decompression

 func untarHandler(tarArchive io.Reader, dest string, options *archive.TarOptions, decompress bool) error {

-

 	if tarArchive == nil {

 		return fmt.Errorf("Empty archive")

 	}

@@ -65,33 +70,3 @@ func untarHandler(tarArchive io.Reader, dest string, options *archive.TarOptions

 	return invokeUnpack(r, dest, options)

 }

-

-// TarUntar is a convenience function which calls Tar and Untar, with the output of one piped into the other.

-// If either Tar or Untar fails, TarUntar aborts and returns the error.

-func TarUntar(src, dst string) error {

-	return chrootArchiver.TarUntar(src, dst)

-}

-

-// CopyWithTar creates a tar archive of filesystem path `src`, and

-// unpacks it at filesystem path `dst`.

-// The archive is streamed directly with fixed buffering and no

-// intermediary disk IO.

-func CopyWithTar(src, dst string) error {

-	return chrootArchiver.CopyWithTar(src, dst)

-}

-

-// CopyFileWithTar emulates the behavior of the 'cp' command-line

-// for a single file. It copies a regular file from path `src` to

-// path `dst`, and preserves all its metadata.

-//

-// If `dst` ends with a trailing slash '/' ('\' on Windows), the final

-// destination path will be `dst/base(src)` or `dst\base(src)`

-func CopyFileWithTar(src, dst string) (err error) {

-	return chrootArchiver.CopyFileWithTar(src, dst)

-}

-

-// UntarPath is a convenience function which looks for an archive

-// at filesystem path `src`, and unpacks it at `dst`.

-func UntarPath(src, dst string) error {

-	return chrootArchiver.UntarPath(src, dst)

-}

@@ -22,6 +22,24 @@ func init() {

 	reexec.Init()

 }

+var chrootArchiver = NewArchiver(nil)

+

+func TarUntar(src, dst string) error {

+	return chrootArchiver.TarUntar(src, dst)

+}

+

+func CopyFileWithTar(src, dst string) (err error) {

+	return chrootArchiver.CopyFileWithTar(src, dst)

+}

+

+func UntarPath(src, dst string) error {

+	return chrootArchiver.UntarPath(src, dst)

+}

+

+func CopyWithTar(src, dst string) error {

+	return chrootArchiver.CopyWithTar(src, dst)

+}

+

 func TestChrootTarUntar(t *testing.T) {

 	tmpdir, err := ioutil.TempDir("", "docker-TestChrootTarUntar")

 	if err != nil {

@@ -118,6 +118,7 @@ func ToContainer(hostID int, idMap []IDMap) (int, error) {

 // ToHost takes an id mapping and a remapped ID, and translates the

 // ID to the mapped host ID. If no map is provided, then the translation

 // assumes a 1-to-1 mapping and returns the passed in id #

+// Depercated: use IDMappings.UIDToHost and IDMappings.GIDToHost

 func ToHost(contID int, idMap []IDMap) (int, error) {

 	if idMap == nil {

 		return contID, nil

@@ -174,6 +175,16 @@ func (i *IDMappings) RootPair() (IDPair, error) {

 	return IDPair{UID: uid, GID: gid}, err

 }

+// UIDToHost returns the host UID for the container uid

+func (i *IDMappings) UIDToHost(uid int) (int, error) {

+	return ToHost(uid, i.uids)

+}

+

+// GIDToHost returns the host GID for the container gid

+func (i *IDMappings) GIDToHost(gid int) (int, error) {

+	return ToHost(gid, i.gids)

+}

+

 // UIDs return the UID mapping

 // TODO: remove this once everything has been refactored to use pairs

 func (i *IDMappings) UIDs() []IDMap {