@@ -2,7 +2,6 @@ package httputils

 import (

 	"net/http"

-	"path/filepath"

 	"strconv"

 	"strings"

 )

@@ -69,8 +68,7 @@ func ArchiveFormValues(r *http.Request, vars map[string]string) (ArchiveOptions,

 	if name == "" {

 		return ArchiveOptions{}, badParameterError{"name"}

 	}

-

-	path := filepath.FromSlash(r.Form.Get("path"))

+	path := r.Form.Get("path")

 	if path == "" {

 		return ArchiveOptions{}, badParameterError{"path"}

 	}

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

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

 	containerpkg "github.com/docker/docker/container"

 	"github.com/docker/docker/layer"

+	"github.com/docker/docker/pkg/containerfs"

 	"golang.org/x/net/context"

 )

@@ -24,7 +25,7 @@ const (

 // instructions in the builder.

 type Source interface {

 	// Root returns root path for accessing source

-	Root() string

+	Root() containerfs.ContainerFS

 	// Close allows to signal that the filesystem tree won't be used anymore.

 	// For Context implementations using a temporary directory, it is recommended to

 	// delete the temporary directory in Close().

@@ -99,7 +100,7 @@ type Image interface {

 // ReleaseableLayer is an image layer that can be mounted and released

 type ReleaseableLayer interface {

 	Release() error

-	Mount() (string, error)

+	Mount() (containerfs.ContainerFS, error)

 	Commit(platform string) (ReleaseableLayer, error)

 	DiffID() layer.DiffID

 }

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

 	"github.com/docker/docker/builder/dockerfile/parser"

 	"github.com/docker/docker/builder/fscache"

 	"github.com/docker/docker/builder/remotecontext"

-	"github.com/docker/docker/pkg/archive"

-	"github.com/docker/docker/pkg/chrootarchive"

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

 	"github.com/docker/docker/pkg/streamformatter"

 	"github.com/docker/docker/pkg/stringid"

@@ -50,21 +48,21 @@ type SessionGetter interface {

 // BuildManager is shared across all Builder objects

 type BuildManager struct {

-	archiver  *archive.Archiver

-	backend   builder.Backend

-	pathCache pathCache // TODO: make this persistent

-	sg        SessionGetter

-	fsCache   *fscache.FSCache

+	idMappings *idtools.IDMappings

+	backend    builder.Backend

+	pathCache  pathCache // TODO: make this persistent

+	sg         SessionGetter

+	fsCache    *fscache.FSCache

 }

 // NewBuildManager creates a BuildManager

 func NewBuildManager(b builder.Backend, sg SessionGetter, fsCache *fscache.FSCache, idMappings *idtools.IDMappings) (*BuildManager, error) {

 	bm := &BuildManager{

-		backend:   b,

-		pathCache: &syncmap.Map{},

-		sg:        sg,

-		archiver:  chrootarchive.NewArchiver(idMappings),

-		fsCache:   fsCache,

+		backend:    b,

+		pathCache:  &syncmap.Map{},

+		sg:         sg,

+		idMappings: idMappings,

+		fsCache:    fsCache,

 	}

 	if err := fsCache.RegisterTransport(remotecontext.ClientSessionRemote, NewClientSessionTransport()); err != nil {

 		return nil, err

@@ -114,7 +112,7 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 		ProgressWriter: config.ProgressWriter,

 		Backend:        bm.backend,

 		PathCache:      bm.pathCache,

-		Archiver:       bm.archiver,

+		IDMappings:     bm.idMappings,

 		Platform:       dockerfile.Platform,

 	}

@@ -160,7 +158,7 @@ type builderOptions struct {

 	Backend        builder.Backend

 	ProgressWriter backend.ProgressWriter

 	PathCache      pathCache

-	Archiver       *archive.Archiver

+	IDMappings     *idtools.IDMappings

 	Platform       string

 }

@@ -177,7 +175,7 @@ type Builder struct {

 	docker    builder.Backend

 	clientCtx context.Context

-	archiver         *archive.Archiver

+	idMappings       *idtools.IDMappings

 	buildStages      *buildStages

 	disableCommit    bool

 	buildArgs        *buildArgs

@@ -219,7 +217,7 @@ func newBuilder(clientCtx context.Context, options builderOptions) *Builder {

 		Aux:              options.ProgressWriter.AuxFormatter,

 		Output:           options.ProgressWriter.Output,

 		docker:           options.Backend,

-		archiver:         options.Archiver,

+		idMappings:       options.IDMappings,

 		buildArgs:        newBuildArgs(config.BuildArgs),

 		buildStages:      newBuildStages(),

 		imageSources:     newImageSources(clientCtx, options),

@@ -1,6 +1,7 @@

 package dockerfile

 import (

+	"archive/tar"

 	"fmt"

 	"io"

 	"mime"

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

 	"net/url"

 	"os"

 	"path/filepath"

+	"runtime"

 	"sort"

 	"strings"

 	"time"

@@ -15,11 +17,11 @@ import (

 	"github.com/docker/docker/builder"

 	"github.com/docker/docker/builder/remotecontext"

 	"github.com/docker/docker/pkg/archive"

+	"github.com/docker/docker/pkg/containerfs"

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

 	"github.com/docker/docker/pkg/ioutils"

 	"github.com/docker/docker/pkg/progress"

 	"github.com/docker/docker/pkg/streamformatter"

-	"github.com/docker/docker/pkg/symlink"

 	"github.com/docker/docker/pkg/system"

 	"github.com/docker/docker/pkg/urlutil"

 	"github.com/pkg/errors"

@@ -35,14 +37,14 @@ type pathCache interface {

 // copyInfo is a data object which stores the metadata about each source file in

 // a copyInstruction

 type copyInfo struct {

-	root         string

+	root         containerfs.ContainerFS

 	path         string

 	hash         string

 	noDecompress bool

 }

 func (c copyInfo) fullPath() (string, error) {

-	return symlink.FollowSymlinkInScope(filepath.Join(c.root, c.path), c.root)

+	return c.root.ResolveScopedPath(c.path, true)

 }

 func newCopyInfoFromSource(source builder.Source, path string, hash string) copyInfo {

@@ -71,6 +73,7 @@ type copier struct {

 	pathCache   pathCache

 	download    sourceDownloader

 	tmpPaths    []string

+	platform    string

 }

 func copierFromDispatchRequest(req dispatchRequest, download sourceDownloader, imageSource *imageMount) copier {

@@ -79,6 +82,7 @@ func copierFromDispatchRequest(req dispatchRequest, download sourceDownloader, i

 		pathCache:   req.builder.pathCache,

 		download:    download,

 		imageSource: imageSource,

+		platform:    req.builder.platform,

 	}

 }

@@ -86,13 +90,14 @@ func (o *copier) createCopyInstruction(args []string, cmdName string) (copyInstr

 	inst := copyInstruction{cmdName: cmdName}

 	last := len(args) - 1

-	// Work in daemon-specific filepath semantics

-	inst.dest = filepath.FromSlash(args[last])

+	// Work in platform-specific filepath semantics

+	inst.dest = fromSlash(args[last], o.platform)

+	separator := string(separator(o.platform))

 	infos, err := o.getCopyInfosForSourcePaths(args[0:last], inst.dest)

 	if err != nil {

 		return inst, errors.Wrapf(err, "%s failed", cmdName)

 	}

-	if len(infos) > 1 && !strings.HasSuffix(inst.dest, string(os.PathSeparator)) {

+	if len(infos) > 1 && !strings.HasSuffix(inst.dest, separator) {

 		return inst, errors.Errorf("When using %s with more than one source file, the destination must be a directory and end with a /", cmdName)

 	}

 	inst.infos = infos

@@ -122,6 +127,7 @@ func (o *copier) getCopyInfoForSourcePath(orig, dest string) ([]copyInfo, error)

 	if !urlutil.IsURL(orig) {

 		return o.calcCopyInfo(orig, true)

 	}

+

 	remote, path, err := o.download(orig)

 	if err != nil {

 		return nil, err

@@ -134,7 +140,7 @@ func (o *copier) getCopyInfoForSourcePath(orig, dest string) ([]copyInfo, error)

 		}

 		path = unnamedFilename

 	}

-	o.tmpPaths = append(o.tmpPaths, remote.Root())

+	o.tmpPaths = append(o.tmpPaths, remote.Root().Path())

 	hash, err := remote.Hash(path)

 	ci := newCopyInfoFromSource(remote, path, hash)

@@ -154,14 +160,6 @@ func (o *copier) Cleanup() {

 // TODO: allowWildcards can probably be removed by refactoring this function further.

 func (o *copier) calcCopyInfo(origPath string, allowWildcards bool) ([]copyInfo, error) {

 	imageSource := o.imageSource

-	if err := validateCopySourcePath(imageSource, origPath); err != nil {

-		return nil, err

-	}

-

-	// Work in daemon-specific OS filepath semantics

-	origPath = filepath.FromSlash(origPath)

-	origPath = strings.TrimPrefix(origPath, string(os.PathSeparator))

-	origPath = strings.TrimPrefix(origPath, "."+string(os.PathSeparator))

 	// TODO: do this when creating copier. Requires validateCopySourcePath

 	// (and other below) to be aware of the difference sources. Why is it only

@@ -178,8 +176,20 @@ func (o *copier) calcCopyInfo(origPath string, allowWildcards bool) ([]copyInfo,

 		return nil, errors.Errorf("missing build context")

 	}

+	root := o.source.Root()

+

+	if err := validateCopySourcePath(imageSource, origPath, root.OS()); err != nil {

+		return nil, err

+	}

+

+	// Work in source OS specific filepath semantics

+	// For LCOW, this is NOT the daemon OS.

+	origPath = root.FromSlash(origPath)

+	origPath = strings.TrimPrefix(origPath, string(root.Separator()))

+	origPath = strings.TrimPrefix(origPath, "."+string(root.Separator()))

+

 	// Deal with wildcards

-	if allowWildcards && containsWildcards(origPath) {

+	if allowWildcards && containsWildcards(origPath, root.OS()) {

 		return o.copyWithWildcards(origPath)

 	}

@@ -211,6 +221,19 @@ func (o *copier) calcCopyInfo(origPath string, allowWildcards bool) ([]copyInfo,

 	return newCopyInfos(newCopyInfoFromSource(o.source, origPath, hash)), nil

 }

+func containsWildcards(name, platform string) bool {

+	isWindows := platform == "windows"

+	for i := 0; i < len(name); i++ {

+		ch := name[i]

+		if ch == '\\' && !isWindows {

+			i++

+		} else if ch == '*' || ch == '?' || ch == '[' {

+			return true

+		}

+	}

+	return false

+}

+

 func (o *copier) storeInPathCache(im *imageMount, path string, hash string) {

 	if im != nil {

 		o.pathCache.Store(im.ImageID()+path, hash)

@@ -218,12 +241,13 @@ func (o *copier) storeInPathCache(im *imageMount, path string, hash string) {

 }

 func (o *copier) copyWithWildcards(origPath string) ([]copyInfo, error) {

+	root := o.source.Root()

 	var copyInfos []copyInfo

-	if err := filepath.Walk(o.source.Root(), func(path string, info os.FileInfo, err error) error {

+	if err := root.Walk(root.Path(), func(path string, info os.FileInfo, err error) error {

 		if err != nil {

 			return err

 		}

-		rel, err := remotecontext.Rel(o.source.Root(), path)

+		rel, err := remotecontext.Rel(root, path)

 		if err != nil {

 			return err

 		}

@@ -231,7 +255,7 @@ func (o *copier) copyWithWildcards(origPath string) ([]copyInfo, error) {

 		if rel == "." {

 			return nil

 		}

-		if match, _ := filepath.Match(origPath, rel); !match {

+		if match, _ := root.Match(origPath, rel); !match {

 			return nil

 		}

@@ -273,7 +297,7 @@ func walkSource(source builder.Source, origPath string) ([]string, error) {

 	}

 	// Must be a dir

 	var subfiles []string

-	err = filepath.Walk(fp, func(path string, info os.FileInfo, err error) error {

+	err = source.Root().Walk(fp, func(path string, info os.FileInfo, err error) error {

 		if err != nil {

 			return err

 		}

@@ -398,14 +422,19 @@ func downloadSource(output io.Writer, stdout io.Writer, srcURL string) (remote b

 		return

 	}

-	lc, err := remotecontext.NewLazySource(tmpDir)

+	lc, err := remotecontext.NewLazySource(containerfs.NewLocalContainerFS(tmpDir))

 	return lc, filename, err

 }

 type copyFileOptions struct {

 	decompress bool

-	archiver   *archive.Archiver

 	chownPair  idtools.IDPair

+	archiver   Archiver

+}

+

+type copyEndpoint struct {

+	driver containerfs.Driver

+	path   string

 }

 func performCopyForInfo(dest copyInfo, source copyInfo, options copyFileOptions) error {

@@ -413,6 +442,7 @@ func performCopyForInfo(dest copyInfo, source copyInfo, options copyFileOptions)

 	if err != nil {

 		return err

 	}

+

 	destPath, err := dest.fullPath()

 	if err != nil {

 		return err

@@ -420,59 +450,90 @@ func performCopyForInfo(dest copyInfo, source copyInfo, options copyFileOptions)

 	archiver := options.archiver

-	src, err := os.Stat(srcPath)

+	srcEndpoint := &copyEndpoint{driver: source.root, path: srcPath}

+	destEndpoint := &copyEndpoint{driver: dest.root, path: destPath}

+

+	src, err := source.root.Stat(srcPath)

 	if err != nil {

 		return errors.Wrapf(err, "source path not found")

 	}

 	if src.IsDir() {

-		return copyDirectory(archiver, srcPath, destPath, options.chownPair)

+		return copyDirectory(archiver, srcEndpoint, destEndpoint, options.chownPair)

 	}

-	if options.decompress && archive.IsArchivePath(srcPath) && !source.noDecompress {

+	if options.decompress && isArchivePath(source.root, srcPath) && !source.noDecompress {

 		return archiver.UntarPath(srcPath, destPath)

 	}

-	destExistsAsDir, err := isExistingDirectory(destPath)

+	destExistsAsDir, err := isExistingDirectory(destEndpoint)

 	if err != nil {

 		return err

 	}

 	// dest.path must be used because destPath has already been cleaned of any

 	// trailing slash

-	if endsInSlash(dest.path) || destExistsAsDir {

+	if endsInSlash(dest.root, dest.path) || destExistsAsDir {

 		// source.path must be used to get the correct filename when the source

 		// is a symlink

-		destPath = filepath.Join(destPath, filepath.Base(source.path))

+		destPath = dest.root.Join(destPath, source.root.Base(source.path))

+		destEndpoint = &copyEndpoint{driver: dest.root, path: destPath}

 	}

-	return copyFile(archiver, srcPath, destPath, options.chownPair)

+	return copyFile(archiver, srcEndpoint, destEndpoint, options.chownPair)

 }

-func copyDirectory(archiver *archive.Archiver, source, dest string, chownPair idtools.IDPair) error {

+func isArchivePath(driver containerfs.ContainerFS, path string) bool {

+	file, err := driver.Open(path)

+	if err != nil {

+		return false

+	}

+	defer file.Close()

+	rdr, err := archive.DecompressStream(file)

+	if err != nil {

+		return false

+	}

+	r := tar.NewReader(rdr)

+	_, err = r.Next()

+	return err == nil

+}

+

+func copyDirectory(archiver Archiver, source, dest *copyEndpoint, chownPair idtools.IDPair) error {

 	destExists, err := isExistingDirectory(dest)

 	if err != nil {

 		return errors.Wrapf(err, "failed to query destination path")

 	}

-	if err := archiver.CopyWithTar(source, dest); err != nil {

+

+	if err := archiver.CopyWithTar(source.path, dest.path); err != nil {

 		return errors.Wrapf(err, "failed to copy directory")

 	}

-	return fixPermissions(source, dest, chownPair, !destExists)

+	// TODO: @gupta-ak. Investigate how LCOW permission mappings will work.

+	return fixPermissions(source.path, dest.path, chownPair, !destExists)

 }

-func copyFile(archiver *archive.Archiver, source, dest string, chownPair idtools.IDPair) error {

-	if err := idtools.MkdirAllAndChownNew(filepath.Dir(dest), 0755, chownPair); err != nil {

-		return errors.Wrapf(err, "failed to create new directory")

+func copyFile(archiver Archiver, source, dest *copyEndpoint, chownPair idtools.IDPair) error {

+	if runtime.GOOS == "windows" && dest.driver.OS() == "linux" {

+		// LCOW

+		if err := dest.driver.MkdirAll(dest.driver.Dir(dest.path), 0755); err != nil {

+			return errors.Wrapf(err, "failed to create new directory")

+		}

+	} else {

+		if err := idtools.MkdirAllAndChownNew(filepath.Dir(dest.path), 0755, chownPair); err != nil {

+			// Normal containers

+			return errors.Wrapf(err, "failed to create new directory")

+		}

 	}

-	if err := archiver.CopyFileWithTar(source, dest); err != nil {

+

+	if err := archiver.CopyFileWithTar(source.path, dest.path); err != nil {

 		return errors.Wrapf(err, "failed to copy file")

 	}

-	return fixPermissions(source, dest, chownPair, false)

+	// TODO: @gupta-ak. Investigate how LCOW permission mappings will work.

+	return fixPermissions(source.path, dest.path, chownPair, false)

 }

-func endsInSlash(path string) bool {

-	return strings.HasSuffix(path, string(os.PathSeparator))

+func endsInSlash(driver containerfs.Driver, path string) bool {

+	return strings.HasSuffix(path, string(driver.Separator()))

 }

 // isExistingDirectory returns true if the path exists and is a directory

-func isExistingDirectory(path string) (bool, error) {

-	destStat, err := os.Stat(path)

+func isExistingDirectory(point *copyEndpoint) (bool, error) {

+	destStat, err := point.driver.Stat(point.path)

 	switch {

 	case os.IsNotExist(err):

 		return false, nil

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

 	"net/http"

 	"testing"

+	"github.com/docker/docker/pkg/containerfs"

 	"github.com/gotestyourself/gotestyourself/fs"

 	"github.com/stretchr/testify/assert"

 )

@@ -37,7 +38,7 @@ func TestIsExistingDirectory(t *testing.T) {

 	}

 	for _, testcase := range testcases {

-		result, err := isExistingDirectory(testcase.path)

+		result, err := isExistingDirectory(&copyEndpoint{driver: containerfs.NewLocalDriver(), path: testcase.path})

 		if !assert.NoError(t, err) {

 			continue

 		}

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

 	"os"

 	"path/filepath"

+	"github.com/docker/docker/pkg/containerfs"

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

 )

@@ -15,7 +16,8 @@ func fixPermissions(source, destination string, rootIDs idtools.IDPair, override

 		err           error

 	)

 	if !overrideSkip {

-		skipChownRoot, err = isExistingDirectory(destination)

+		destEndpoint := &copyEndpoint{driver: containerfs.NewLocalDriver(), path: destination}

+		skipChownRoot, err = isExistingDirectory(destEndpoint)

 		if err != nil {

 			return err

 		}

@@ -40,3 +42,7 @@ func fixPermissions(source, destination string, rootIDs idtools.IDPair, override

 		return os.Lchown(fullpath, rootIDs.UID, rootIDs.GID)

 	})

 }

+

+func validateCopySourcePath(imageSource *imageMount, origPath, platform string) error {

+	return nil

+}

@@ -1,8 +1,38 @@

 package dockerfile

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

+import (

+	"errors"

+	"path/filepath"

+	"strings"

+

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

+)

 func fixPermissions(source, destination string, rootIDs idtools.IDPair, overrideSkip bool) error {

 	// chown is not supported on Windows

 	return nil

 }

+

+func validateCopySourcePath(imageSource *imageMount, origPath, platform string) error {

+	// validate windows paths from other images + LCOW

+	if imageSource == nil || platform != "windows" {

+		return nil

+	}

+

+	origPath = filepath.FromSlash(origPath)

+	p := strings.ToLower(filepath.Clean(origPath))

+	if !filepath.IsAbs(p) {

+		if filepath.VolumeName(p) != "" {

+			if p[len(p)-2:] == ":." { // case where clean returns weird c:. paths

+				p = p[:len(p)-1]

+			}

+			p += "\\"

+		} else {

+			p = filepath.Join("c:\\", p)

+		}

+	}

+	if _, blacklisted := pathBlacklist[p]; blacklisted {

+		return errors.New("copy from c:\\ or c:\\windows is not allowed on windows")

+	}

+	return nil

+}

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

 	"crypto/sha256"

 	"encoding/hex"

 	"fmt"

+	"io"

+	"os"

+	"path"

 	"path/filepath"

 	"strconv"

 	"strings"

@@ -15,13 +18,69 @@ import (

 	"github.com/docker/docker/api/types/backend"

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

 	"github.com/docker/docker/image"

+	"github.com/docker/docker/pkg/archive"

+	"github.com/docker/docker/pkg/chrootarchive"

+	"github.com/docker/docker/pkg/containerfs"

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

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/docker/docker/pkg/symlink"

+	"github.com/docker/docker/pkg/system"

 	lcUser "github.com/opencontainers/runc/libcontainer/user"

 	"github.com/pkg/errors"

 )

+// For Windows only

+var pathBlacklist = map[string]bool{

+	"c:\\":        true,

+	"c:\\windows": true,

+}

+

+// Archiver defines an interface for copying files from one destination to

+// another using Tar/Untar.

+type Archiver interface {

+	TarUntar(src, dst string) error

+	UntarPath(src, dst string) error

+	CopyWithTar(src, dst string) error

+	CopyFileWithTar(src, dst string) error

+	IDMappings() *idtools.IDMappings

+}

+

+// The builder will use the following interfaces if the container fs implements

+// these for optimized copies to and from the container.

+type extractor interface {

+	ExtractArchive(src io.Reader, dst string, opts *archive.TarOptions) error

+}

+

+type archiver interface {

+	ArchivePath(src string, opts *archive.TarOptions) (io.ReadCloser, error)

+}

+

+// helper functions to get tar/untar func

+func untarFunc(i interface{}) containerfs.UntarFunc {

+	if ea, ok := i.(extractor); ok {

+		return ea.ExtractArchive

+	}

+	return chrootarchive.Untar

+}

+

+func tarFunc(i interface{}) containerfs.TarFunc {

+	if ap, ok := i.(archiver); ok {

+		return ap.ArchivePath

+	}

+	return archive.TarWithOptions

+}

+

+func (b *Builder) getArchiver(src, dst containerfs.Driver) Archiver {

+	t, u := tarFunc(src), untarFunc(dst)

+	return &containerfs.Archiver{

+		SrcDriver:     src,

+		DstDriver:     dst,

+		Tar:           t,

+		Untar:         u,

+		IDMappingsVar: b.idMappings,

+	}

+}

+

 func (b *Builder) commit(dispatchState *dispatchState, comment string) error {

 	if b.disableCommit {

 		return nil

@@ -131,28 +190,29 @@ func (b *Builder) performCopy(state *dispatchState, inst copyInstruction) error

 	if err != nil {

 		return errors.Wrapf(err, "failed to get destination image %q", state.imageID)

 	}

-	destInfo, err := createDestInfo(state.runConfig.WorkingDir, inst, imageMount)

+

+	destInfo, err := createDestInfo(state.runConfig.WorkingDir, inst, imageMount, b.platform)

 	if err != nil {

 		return err

 	}

-	chownPair := b.archiver.IDMappings.RootPair()

+	chownPair := b.idMappings.RootPair()

 	// if a chown was requested, perform the steps to get the uid, gid

 	// translated (if necessary because of user namespaces), and replace

 	// the root pair with the chown pair for copy operations

 	if inst.chownStr != "" {

-		chownPair, err = parseChownFlag(inst.chownStr, destInfo.root, b.archiver.IDMappings)

+		chownPair, err = parseChownFlag(inst.chownStr, destInfo.root.Path(), b.idMappings)

 		if err != nil {

 			return errors.Wrapf(err, "unable to convert uid/gid chown string to host mapping")

 		}

 	}

-	opts := copyFileOptions{

-		decompress: inst.allowLocalDecompression,

-		archiver:   b.archiver,

-		chownPair:  chownPair,

-	}

 	for _, info := range inst.infos {

+		opts := copyFileOptions{

+			decompress: inst.allowLocalDecompression,

+			archiver:   b.getArchiver(info.root, destInfo.root),

+			chownPair:  chownPair,

+		}

 		if err := performCopyForInfo(destInfo, info, opts); err != nil {

 			return errors.Wrapf(err, "failed to copy files")

 		}

@@ -236,10 +296,10 @@ func lookupGroup(groupStr, filepath string) (int, error) {

 	return groups[0].Gid, nil

 }

-func createDestInfo(workingDir string, inst copyInstruction, imageMount *imageMount) (copyInfo, error) {

+func createDestInfo(workingDir string, inst copyInstruction, imageMount *imageMount, platform string) (copyInfo, error) {

 	// Twiddle the destination when it's a relative path - meaning, make it

 	// relative to the WORKINGDIR

-	dest, err := normalizeDest(workingDir, inst.dest)

+	dest, err := normalizeDest(workingDir, inst.dest, platform)

 	if err != nil {

 		return copyInfo{}, errors.Wrapf(err, "invalid %s", inst.cmdName)

 	}

@@ -252,6 +312,63 @@ func createDestInfo(workingDir string, inst copyInstruction, imageMount *imageMo

 	return newCopyInfoFromSource(destMount, dest, ""), nil

 }

+// normalizeDest normalises the destination of a COPY/ADD command in a

+// platform semantically consistent way.

+func normalizeDest(workingDir, requested string, platform string) (string, error) {

+	dest := fromSlash(requested, platform)

+	endsInSlash := strings.HasSuffix(dest, string(separator(platform)))

+

+	if platform != "windows" {

+		if !path.IsAbs(requested) {

+			dest = path.Join("/", filepath.ToSlash(workingDir), dest)

+			// Make sure we preserve any trailing slash

+			if endsInSlash {

+				dest += "/"

+			}

+		}

+		return dest, nil

+	}

+

+	// We are guaranteed that the working directory is already consistent,

+	// However, Windows also has, for now, the limitation that ADD/COPY can

+	// only be done to the system drive, not any drives that might be present

+	// as a result of a bind mount.

+	//

+	// So... if the path requested is Linux-style absolute (/foo or \\foo),

+	// we assume it is the system drive. If it is a Windows-style absolute

+	// (DRIVE:\\foo), error if DRIVE is not C. And finally, ensure we

+	// strip any configured working directories drive letter so that it

+	// can be subsequently legitimately converted to a Windows volume-style

+	// pathname.

+

+	// Not a typo - filepath.IsAbs, not system.IsAbs on this next check as

+	// we only want to validate where the DriveColon part has been supplied.

+	if filepath.IsAbs(dest) {

+		if strings.ToUpper(string(dest[0])) != "C" {

+			return "", fmt.Errorf("Windows does not support destinations not on the system drive (C:)")

+		}

+		dest = dest[2:] // Strip the drive letter

+	}

+

+	// Cannot handle relative where WorkingDir is not the system drive.

+	if len(workingDir) > 0 {

+		if ((len(workingDir) > 1) && !system.IsAbs(workingDir[2:])) || (len(workingDir) == 1) {

+			return "", fmt.Errorf("Current WorkingDir %s is not platform consistent", workingDir)

+		}

+		if !system.IsAbs(dest) {

+			if string(workingDir[0]) != "C" {

+				return "", fmt.Errorf("Windows does not support relative paths when WORKDIR is not the system drive")

+			}

+			dest = filepath.Join(string(os.PathSeparator), workingDir[2:], dest)

+			// Make sure we preserve any trailing slash

+			if endsInSlash {

+				dest += string(os.PathSeparator)

+			}

+		}

+	}

+	return dest, nil

+}

+

 // For backwards compat, if there's just one info then use it as the

 // cache look-up string, otherwise hash 'em all into one

 func getSourceHashFromInfos(infos []copyInfo) string {

@@ -397,3 +514,19 @@ func hostConfigFromOptions(options *types.ImageBuildOptions) *container.HostConf

 		ExtraHosts: options.ExtraHosts,

 	}

 }

+

+// fromSlash works like filepath.FromSlash but with a given OS platform field

+func fromSlash(path, platform string) string {

+	if platform == "windows" {

+		return strings.Replace(path, "/", "\\", -1)

+	}

+	return path

+}

+

+// separator returns a OS path separator for the given OS platform

+func separator(platform string) byte {

+	if platform == "windows" {

+		return '\\'

+	}

+	return '/'

+}

deleted file mode 100644

@@ -1,42 +0,0 @@

-// +build !windows

-

-package dockerfile

-

-import (

-	"os"

-	"path/filepath"

-	"strings"

-

-	"github.com/docker/docker/pkg/system"

-)

-

-// normalizeDest normalizes the destination of a COPY/ADD command in a

-// platform semantically consistent way.

-func normalizeDest(workingDir, requested string) (string, error) {

-	dest := filepath.FromSlash(requested)

-	endsInSlash := strings.HasSuffix(requested, string(os.PathSeparator))

-	if !system.IsAbs(requested) {

-		dest = filepath.Join(string(os.PathSeparator), filepath.FromSlash(workingDir), dest)

-		// Make sure we preserve any trailing slash

-		if endsInSlash {

-			dest += string(os.PathSeparator)

-		}

-	}

-	return dest, nil

-}

-

-func containsWildcards(name string) bool {

-	for i := 0; i < len(name); i++ {

-		ch := name[i]

-		if ch == '\\' {

-			i++

-		} else if ch == '*' || ch == '?' || ch == '[' {

-			return true

-		}

-	}

-	return false

-}

-

-func validateCopySourcePath(imageSource *imageMount, origPath string) error {

-	return nil

-}

deleted file mode 100644

@@ -1,95 +0,0 @@

-package dockerfile

-

-import (

-	"fmt"

-	"os"

-	"path/filepath"

-	"strings"

-

-	"github.com/docker/docker/pkg/system"

-	"github.com/pkg/errors"

-)

-

-// normalizeDest normalizes the destination of a COPY/ADD command in a

-// platform semantically consistent way.

-func normalizeDest(workingDir, requested string) (string, error) {

-	dest := filepath.FromSlash(requested)

-	endsInSlash := strings.HasSuffix(dest, string(os.PathSeparator))

-

-	// We are guaranteed that the working directory is already consistent,

-	// However, Windows also has, for now, the limitation that ADD/COPY can

-	// only be done to the system drive, not any drives that might be present

-	// as a result of a bind mount.

-	//

-	// So... if the path requested is Linux-style absolute (/foo or \\foo),

-	// we assume it is the system drive. If it is a Windows-style absolute

-	// (DRIVE:\\foo), error if DRIVE is not C. And finally, ensure we

-	// strip any configured working directories drive letter so that it

-	// can be subsequently legitimately converted to a Windows volume-style

-	// pathname.

-

-	// Not a typo - filepath.IsAbs, not system.IsAbs on this next check as

-	// we only want to validate where the DriveColon part has been supplied.

-	if filepath.IsAbs(dest) {

-		if strings.ToUpper(string(dest[0])) != "C" {

-			return "", fmt.Errorf("Windows does not support destinations not on the system drive (C:)")

-		}

-		dest = dest[2:] // Strip the drive letter

-	}

-

-	// Cannot handle relative where WorkingDir is not the system drive.

-	if len(workingDir) > 0 {

-		if ((len(workingDir) > 1) && !system.IsAbs(workingDir[2:])) || (len(workingDir) == 1) {

-			return "", fmt.Errorf("Current WorkingDir %s is not platform consistent", workingDir)

-		}

-		if !system.IsAbs(dest) {

-			if string(workingDir[0]) != "C" {

-				return "", fmt.Errorf("Windows does not support relative paths when WORKDIR is not the system drive")

-			}

-			dest = filepath.Join(string(os.PathSeparator), workingDir[2:], dest)

-			// Make sure we preserve any trailing slash

-			if endsInSlash {

-				dest += string(os.PathSeparator)

-			}

-		}

-	}

-	return dest, nil

-}