@@ -222,7 +222,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {

 	//Check if the given image name can be resolved

 	if *tag != "" {

 		repository, tag := parsers.ParseRepositoryTag(*tag)

-		if _, _, err := registry.ResolveRepositoryName(repository); err != nil {

+		if err := registry.ValidateRepositoryName(repository); err != nil {

 			return err

 		}

 		if len(tag) > 0 {

@@ -1148,7 +1148,7 @@ func (cli *DockerCli) CmdImport(args ...string) error {

 	if repository != "" {

 		//Check if the given image name can be resolved

 		repo, _ := parsers.ParseRepositoryTag(repository)

-		if _, _, err := registry.ResolveRepositoryName(repo); err != nil {

+		if err := registry.ValidateRepositoryName(repo); err != nil {

 			return err

 		}

 	}

@@ -1174,23 +1174,23 @@ func (cli *DockerCli) CmdPush(args ...string) error {

 	remote, tag := parsers.ParseRepositoryTag(name)

-	// Resolve the Repository name from fqn to hostname + name

-	hostname, _, err := registry.ResolveRepositoryName(remote)

+	// Resolve the Repository name from fqn to RepositoryInfo

+	repoInfo, err := registry.ParseRepositoryInfo(remote)

 	if err != nil {

 		return err

 	}

 	// Resolve the Auth config relevant for this server

-	authConfig := cli.configFile.ResolveAuthConfig(hostname)

+	authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)

 	// If we're not using a custom registry, we know the restrictions

 	// applied to repository names and can warn the user in advance.

 	// Custom repositories can have different rules, and we must also

 	// allow pushing by image ID.

-	if len(strings.SplitN(name, "/", 2)) == 1 {

-		username := cli.configFile.Configs[registry.IndexServerAddress()].Username

+	if repoInfo.Official {

+		username := authConfig.Username

 		if username == "" {

 			username = "<user>"

 		}

-		return fmt.Errorf("You cannot push a \"root\" repository. Please rename your repository in <user>/<repo> (ex: %s/%s)", username, name)

+		return fmt.Errorf("You cannot push a \"root\" repository. Please rename your repository to <user>/<repo> (ex: %s/%s)", username, repoInfo.LocalName)

 	}

 	v := url.Values{}

@@ -1212,10 +1212,10 @@ func (cli *DockerCli) CmdPush(args ...string) error {

 	if err := push(authConfig); err != nil {

 		if strings.Contains(err.Error(), "Status 401") {

 			fmt.Fprintln(cli.out, "\nPlease login prior to push:")

-			if err := cli.CmdLogin(hostname); err != nil {

+			if err := cli.CmdLogin(repoInfo.Index.GetAuthConfigKey()); err != nil {

 				return err

 			}

-			authConfig := cli.configFile.ResolveAuthConfig(hostname)

+			authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)

 			return push(authConfig)

 		}

 		return err

@@ -1245,8 +1245,8 @@ func (cli *DockerCli) CmdPull(args ...string) error {

 	v.Set("fromImage", newRemote)

-	// Resolve the Repository name from fqn to hostname + name

-	hostname, _, err := registry.ResolveRepositoryName(taglessRemote)

+	// Resolve the Repository name from fqn to RepositoryInfo

+	repoInfo, err := registry.ParseRepositoryInfo(taglessRemote)

 	if err != nil {

 		return err

 	}

@@ -1254,7 +1254,7 @@ func (cli *DockerCli) CmdPull(args ...string) error {

 	cli.LoadConfigFile()

 	// Resolve the Auth config relevant for this server

-	authConfig := cli.configFile.ResolveAuthConfig(hostname)

+	authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)

 	pull := func(authConfig registry.AuthConfig) error {

 		buf, err := json.Marshal(authConfig)

@@ -1273,10 +1273,10 @@ func (cli *DockerCli) CmdPull(args ...string) error {

 	if err := pull(authConfig); err != nil {

 		if strings.Contains(err.Error(), "Status 401") {

 			fmt.Fprintln(cli.out, "\nPlease login prior to pull:")

-			if err := cli.CmdLogin(hostname); err != nil {

+			if err := cli.CmdLogin(repoInfo.Index.GetAuthConfigKey()); err != nil {

 				return err

 			}

-			authConfig := cli.configFile.ResolveAuthConfig(hostname)

+			authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)

 			return pull(authConfig)

 		}

 		return err

@@ -1691,7 +1691,7 @@ func (cli *DockerCli) CmdCommit(args ...string) error {

 	//Check if the given image name can be resolved

 	if repository != "" {

-		if _, _, err := registry.ResolveRepositoryName(repository); err != nil {

+		if err := registry.ValidateRepositoryName(repository); err != nil {

 			return err

 		}

 	}

@@ -2002,7 +2002,7 @@ func (cli *DockerCli) CmdTag(args ...string) error {

 	)

 	//Check if the given image name can be resolved

-	if _, _, err := registry.ResolveRepositoryName(repository); err != nil {

+	if err := registry.ValidateRepositoryName(repository); err != nil {

 		return err

 	}

 	v.Set("repo", repository)

@@ -2032,8 +2032,8 @@ func (cli *DockerCli) pullImageCustomOut(image string, out io.Writer) error {

 	v.Set("fromImage", repos)

 	v.Set("tag", tag)

-	// Resolve the Repository name from fqn to hostname + name

-	hostname, _, err := registry.ResolveRepositoryName(repos)

+	// Resolve the Repository name from fqn to RepositoryInfo

+	repoInfo, err := registry.ParseRepositoryInfo(repos)

 	if err != nil {

 		return err

 	}

@@ -2042,7 +2042,7 @@ func (cli *DockerCli) pullImageCustomOut(image string, out io.Writer) error {

 	cli.LoadConfigFile()

 	// Resolve the Auth config relevant for this server

-	authConfig := cli.configFile.ResolveAuthConfig(hostname)

+	authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)

 	buf, err := json.Marshal(authConfig)

 	if err != nil {

 		return err

@@ -66,7 +66,7 @@ func (cli *DockerCli) call(method, path string, data interface{}, passAuthInfo b

 	if passAuthInfo {

 		cli.LoadConfigFile()

 		// Resolve the Auth config relevant for this server

-		authConfig := cli.configFile.ResolveAuthConfig(registry.IndexServerAddress())

+		authConfig := cli.configFile.Configs[registry.IndexServerAddress()]

 		getHeaders := func(authConfig registry.AuthConfig) (map[string][]string, error) {

 			buf, err := json.Marshal(authConfig)

 			if err != nil {

@@ -260,7 +260,10 @@ func (cli *DockerCli) monitorTtySize(id string, isExec bool) error {

 	sigchan := make(chan os.Signal, 1)

 	gosignal.Notify(sigchan, signal.SIGWINCH)

 	go func() {

-		for _ = range sigchan {

+		// This tmp := range..., _ = tmp workaround is needed to

+		// suppress gofmt warnings while still preserve go1.3 compatibility

+		for tmp := range sigchan {

+			_ = tmp

 			cli.resizeTty(id, isExec)

 		}

 	}()

@@ -427,17 +427,17 @@ func (b *Builder) pullImage(name string) (*imagepkg.Image, error) {

 	if tag == "" {

 		tag = "latest"

 	}

+	job := b.Engine.Job("pull", remote, tag)

 	pullRegistryAuth := b.AuthConfig

 	if len(b.AuthConfigFile.Configs) > 0 {

 		// The request came with a full auth config file, we prefer to use that

-		endpoint, _, err := registry.ResolveRepositoryName(remote)

+		repoInfo, err := registry.ResolveRepositoryInfo(job, remote)

 		if err != nil {

 			return nil, err

 		}

-		resolvedAuth := b.AuthConfigFile.ResolveAuthConfig(endpoint)

+		resolvedAuth := b.AuthConfigFile.ResolveAuthConfig(repoInfo.Index)

 		pullRegistryAuth = &resolvedAuth

 	}

-	job := b.Engine.Job("pull", remote, tag)

 	job.SetenvBool("json", b.StreamFormatter.Json())

 	job.SetenvBool("parallel", true)

 	job.SetenvJson("authConfig", pullRegistryAuth)

@@ -50,7 +50,7 @@ func (b *BuilderJob) CmdBuild(job *engine.Job) engine.Status {

 	repoName, tag = parsers.ParseRepositoryTag(repoName)

 	if repoName != "" {

-		if _, _, err := registry.ResolveRepositoryName(repoName); err != nil {

+		if err := registry.ValidateRepositoryName(repoName); err != nil {

 			return job.Error(err)

 		}

 		if len(tag) > 0 {

@@ -23,7 +23,6 @@ type Config struct {

 	AutoRestart                 bool

 	Dns                         []string

 	DnsSearch                   []string

-	Mirrors                     []string

 	EnableIptables              bool

 	EnableIpForward             bool

 	EnableIpMasq                bool

@@ -31,7 +30,6 @@ type Config struct {

 	BridgeIface                 string

 	BridgeIP                    string

 	FixedCIDR                   string

-	InsecureRegistries          []string

 	InterContainerCommunication bool

 	GraphDriver                 string

 	GraphOptions                []string

@@ -58,7 +56,6 @@ func (config *Config) InstallFlags() {

 	flag.StringVar(&config.BridgeIP, []string{"#bip", "-bip"}, "", "Use this CIDR notation address for the network bridge's IP, not compatible with -b")

 	flag.StringVar(&config.BridgeIface, []string{"b", "-bridge"}, "", "Attach containers to a pre-existing network bridge\nuse 'none' to disable container networking")

 	flag.StringVar(&config.FixedCIDR, []string{"-fixed-cidr"}, "", "IPv4 subnet for fixed IPs (ex: 10.20.0.0/16)\nthis subnet must be nested in the bridge subnet (which is defined by -b or --bip)")

-	opts.ListVar(&config.InsecureRegistries, []string{"-insecure-registry"}, "Enable insecure communication with specified registries (no certificate verification for HTTPS and enable HTTP fallback) (e.g., localhost:5000 or 10.20.0.0/16)")

 	flag.BoolVar(&config.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Allow unrestricted inter-container and Docker daemon host communication")

 	flag.StringVar(&config.GraphDriver, []string{"s", "-storage-driver"}, "", "Force the Docker runtime to use a specific storage driver")

 	flag.StringVar(&config.ExecDriver, []string{"e", "-exec-driver"}, "native", "Force the Docker runtime to use a specific exec driver")

@@ -69,16 +66,7 @@ func (config *Config) InstallFlags() {

 	// FIXME: why the inconsistency between "hosts" and "sockets"?

 	opts.IPListVar(&config.Dns, []string{"#dns", "-dns"}, "Force Docker to use specific DNS servers")

 	opts.DnsSearchListVar(&config.DnsSearch, []string{"-dns-search"}, "Force Docker to use specific DNS search domains")

-	opts.MirrorListVar(&config.Mirrors, []string{"-registry-mirror"}, "Specify a preferred Docker registry mirror")

 	opts.LabelListVar(&config.Labels, []string{"-label"}, "Set key=value labels to the daemon (displayed in `docker info`)")

-

-	// Localhost is by default considered as an insecure registry

-	// This is a stop-gap for people who are running a private registry on localhost (especially on Boot2docker).

-	//

-	// TODO: should we deprecate this once it is easier for people to set up a TLS registry or change

-	// daemon flags on boot2docker?

-	// If so, do not forget to check the TODO in TestIsSecure

-	config.InsecureRegistries = append(config.InsecureRegistries, "127.0.0.0/8")

 }

 func getDefaultNetworkMtu() int {

@@ -898,7 +898,7 @@ func NewDaemonFromDirectory(config *Config, eng *engine.Engine) (*Daemon, error)

 	}

 	log.Debugf("Creating repository list")

-	repositories, err := graph.NewTagStore(path.Join(config.Root, "repositories-"+driver.String()), g, config.Mirrors, config.InsecureRegistries)

+	repositories, err := graph.NewTagStore(path.Join(config.Root, "repositories-"+driver.String()), g)

 	if err != nil {

 		return nil, fmt.Errorf("Couldn't create Tag store: %s", err)

 	}

@@ -55,6 +55,15 @@ func (daemon *Daemon) CmdInfo(job *engine.Job) engine.Status {

 	if err := cjob.Run(); err != nil {

 		return job.Error(err)

 	}

+	registryJob := job.Eng.Job("registry_config")

+	registryEnv, _ := registryJob.Stdout.AddEnv()

+	if err := registryJob.Run(); err != nil {

+		return job.Error(err)

+	}

+	registryConfig := registry.ServiceConfig{}

+	if err := registryEnv.GetJson("config", &registryConfig); err != nil {

+		return job.Error(err)

+	}

 	v := &engine.Env{}

 	v.SetJson("ID", daemon.ID)

 	v.SetInt("Containers", len(daemon.List()))

@@ -72,6 +81,7 @@ func (daemon *Daemon) CmdInfo(job *engine.Job) engine.Status {

 	v.Set("KernelVersion", kernelVersion)

 	v.Set("OperatingSystem", operatingSystem)

 	v.Set("IndexServerAddress", registry.IndexServerAddress())

+	v.SetJson("RegistryConfig", registryConfig)

 	v.Set("InitSha1", dockerversion.INITSHA1)

 	v.Set("InitPath", initPath)

 	v.SetInt("NCPU", runtime.NumCPU())

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

 const CanDaemon = true

 var (

-	daemonCfg = &daemon.Config{}

+	daemonCfg   = &daemon.Config{}

+	registryCfg = &registry.Options{}

 )

 func init() {

 	daemonCfg.InstallFlags()

+	registryCfg.InstallFlags()

 }

 func mainDaemon() {

@@ -42,7 +44,7 @@ func mainDaemon() {

 	}

 	// load registry service

-	if err := registry.NewService(daemonCfg.InsecureRegistries).Install(eng); err != nil {

+	if err := registry.NewService(registryCfg).Install(eng); err != nil {

 		log.Fatal(err)

 	}

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

 	"github.com/docker/docker/engine"

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

 	"github.com/docker/docker/pkg/parsers"

+	"github.com/docker/docker/registry"

 )

 // CmdImageExport exports all images with the given tag. All versions

@@ -39,6 +40,7 @@ func (s *TagStore) CmdImageExport(job *engine.Job) engine.Status {

 		}

 	}

 	for _, name := range job.Args {

+		name = registry.NormalizeLocalName(name)

 		log.Debugf("Serializing %s", name)

 		rootRepo := s.Repositories[name]

 		if rootRepo != nil {

@@ -85,9 +85,14 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 		sf          = utils.NewStreamFormatter(job.GetenvBool("json"))

 		authConfig  = &registry.AuthConfig{}

 		metaHeaders map[string][]string

-		mirrors     []string

 	)

+	// Resolve the Repository name from fqn to RepositoryInfo

+	repoInfo, err := registry.ResolveRepositoryInfo(job, localName)

+	if err != nil {

+		return job.Error(err)

+	}

+

 	if len(job.Args) > 1 {

 		tag = job.Args[1]

 	}

@@ -95,25 +100,19 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 	job.GetenvJson("authConfig", authConfig)

 	job.GetenvJson("metaHeaders", &metaHeaders)

-	c, err := s.poolAdd("pull", localName+":"+tag)

+	c, err := s.poolAdd("pull", repoInfo.LocalName+":"+tag)

 	if err != nil {

 		if c != nil {

 			// Another pull of the same repository is already taking place; just wait for it to finish

-			job.Stdout.Write(sf.FormatStatus("", "Repository %s already being pulled by another client. Waiting.", localName))

+			job.Stdout.Write(sf.FormatStatus("", "Repository %s already being pulled by another client. Waiting.", repoInfo.LocalName))

 			<-c

 			return engine.StatusOK

 		}

 		return job.Error(err)

 	}

-	defer s.poolRemove("pull", localName+":"+tag)

-

-	// Resolve the Repository name from fqn to endpoint + name

-	hostname, remoteName, err := registry.ResolveRepositoryName(localName)

-	if err != nil {

-		return job.Error(err)

-	}

+	defer s.poolRemove("pull", repoInfo.LocalName+":"+tag)

-	endpoint, err := registry.NewEndpoint(hostname, s.insecureRegistries)

+	endpoint, err := repoInfo.GetEndpoint()

 	if err != nil {

 		return job.Error(err)

 	}

@@ -123,32 +122,18 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 		return job.Error(err)

 	}

-	var isOfficial bool

-	if endpoint.VersionString(1) == registry.IndexServerAddress() {

-		// If pull "index.docker.io/foo/bar", it's stored locally under "foo/bar"

-		localName = remoteName

-

-		isOfficial = isOfficialName(remoteName)

-		if isOfficial && strings.IndexRune(remoteName, '/') == -1 {

-			remoteName = "library/" + remoteName

-		}

-

-		// Use provided mirrors, if any

-		mirrors = s.mirrors

-	}

-

-	logName := localName

+	logName := repoInfo.LocalName

 	if tag != "" {

 		logName += ":" + tag

 	}

-	if len(mirrors) == 0 && (isOfficial || endpoint.Version == registry.APIVersion2) {

+	if len(repoInfo.Index.Mirrors) == 0 && (repoInfo.Official || endpoint.Version == registry.APIVersion2) {

 		j := job.Eng.Job("trust_update_base")

 		if err = j.Run(); err != nil {

 			return job.Errorf("error updating trust base graph: %s", err)

 		}

-		if err := s.pullV2Repository(job.Eng, r, job.Stdout, localName, remoteName, tag, sf, job.GetenvBool("parallel")); err == nil {

+		if err := s.pullV2Repository(job.Eng, r, job.Stdout, repoInfo, tag, sf, job.GetenvBool("parallel")); err == nil {

 			if err = job.Eng.Job("log", "pull", logName, "").Run(); err != nil {

 				log.Errorf("Error logging event 'pull' for %s: %s", logName, err)

 			}

@@ -158,7 +143,7 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 		}

 	}

-	if err = s.pullRepository(r, job.Stdout, localName, remoteName, tag, sf, job.GetenvBool("parallel"), mirrors); err != nil {

+	if err = s.pullRepository(r, job.Stdout, repoInfo, tag, sf, job.GetenvBool("parallel")); err != nil {

 		return job.Error(err)

 	}

@@ -169,20 +154,20 @@ func (s *TagStore) CmdPull(job *engine.Job) engine.Status {

 	return engine.StatusOK

 }

-func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName, remoteName, askedTag string, sf *utils.StreamFormatter, parallel bool, mirrors []string) error {

-	out.Write(sf.FormatStatus("", "Pulling repository %s", localName))

+func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, repoInfo *registry.RepositoryInfo, askedTag string, sf *utils.StreamFormatter, parallel bool) error {

+	out.Write(sf.FormatStatus("", "Pulling repository %s", repoInfo.CanonicalName))

-	repoData, err := r.GetRepositoryData(remoteName)

+	repoData, err := r.GetRepositoryData(repoInfo.RemoteName)

 	if err != nil {

 		if strings.Contains(err.Error(), "HTTP code: 404") {

-			return fmt.Errorf("Error: image %s:%s not found", remoteName, askedTag)

+			return fmt.Errorf("Error: image %s:%s not found", repoInfo.RemoteName, askedTag)

 		}

 		// Unexpected HTTP error

 		return err

 	}

 	log.Debugf("Retrieving the tag list")

-	tagsList, err := r.GetRemoteTags(repoData.Endpoints, remoteName, repoData.Tokens)

+	tagsList, err := r.GetRemoteTags(repoData.Endpoints, repoInfo.RemoteName, repoData.Tokens)

 	if err != nil {

 		log.Errorf("%v", err)

 		return err

@@ -207,7 +192,7 @@ func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName,

 		// Otherwise, check that the tag exists and use only that one

 		id, exists := tagsList[askedTag]

 		if !exists {

-			return fmt.Errorf("Tag %s not found in repository %s", askedTag, localName)

+			return fmt.Errorf("Tag %s not found in repository %s", askedTag, repoInfo.CanonicalName)

 		}

 		imageId = id

 		repoData.ImgList[id].Tag = askedTag

@@ -250,31 +235,29 @@ func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName,

 			}

 			defer s.poolRemove("pull", "img:"+img.ID)

-			out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s", img.Tag, localName), nil))

+			out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s", img.Tag, repoInfo.CanonicalName), nil))

 			success := false

 			var lastErr, err error

 			var is_downloaded bool

-			if mirrors != nil {

-				for _, ep := range mirrors {

-					out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, mirror: %s", img.Tag, localName, ep), nil))

-					if is_downloaded, err = s.pullImage(r, out, img.ID, ep, repoData.Tokens, sf); err != nil {

-						// Don't report errors when pulling from mirrors.

-						log.Debugf("Error pulling image (%s) from %s, mirror: %s, %s", img.Tag, localName, ep, err)

-						continue

-					}

-					layers_downloaded = layers_downloaded || is_downloaded

-					success = true

-					break

+			for _, ep := range repoInfo.Index.Mirrors {

+				out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, mirror: %s", img.Tag, repoInfo.CanonicalName, ep), nil))

+				if is_downloaded, err = s.pullImage(r, out, img.ID, ep, repoData.Tokens, sf); err != nil {

+					// Don't report errors when pulling from mirrors.

+					log.Debugf("Error pulling image (%s) from %s, mirror: %s, %s", img.Tag, repoInfo.CanonicalName, ep, err)

+					continue

 				}

+				layers_downloaded = layers_downloaded || is_downloaded

+				success = true

+				break

 			}

 			if !success {

 				for _, ep := range repoData.Endpoints {

-					out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, endpoint: %s", img.Tag, localName, ep), nil))

+					out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Pulling image (%s) from %s, endpoint: %s", img.Tag, repoInfo.CanonicalName, ep), nil))

 					if is_downloaded, err = s.pullImage(r, out, img.ID, ep, repoData.Tokens, sf); err != nil {

 						// It's not ideal that only the last error is returned, it would be better to concatenate the errors.

 						// As the error is also given to the output stream the user will see the error.

 						lastErr = err

-						out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Error pulling image (%s) from %s, endpoint: %s, %s", img.Tag, localName, ep, err), nil))

+						out.Write(sf.FormatProgress(utils.TruncateID(img.ID), fmt.Sprintf("Error pulling image (%s) from %s, endpoint: %s, %s", img.Tag, repoInfo.CanonicalName, ep, err), nil))

 						continue

 					}

 					layers_downloaded = layers_downloaded || is_downloaded

@@ -283,7 +266,7 @@ func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName,

 				}

 			}

 			if !success {

-				err := fmt.Errorf("Error pulling image (%s) from %s, %v", img.Tag, localName, lastErr)

+				err := fmt.Errorf("Error pulling image (%s) from %s, %v", img.Tag, repoInfo.CanonicalName, lastErr)

 				out.Write(sf.FormatProgress(utils.TruncateID(img.ID), err.Error(), nil))

 				if parallel {

 					errors <- err

@@ -319,14 +302,14 @@ func (s *TagStore) pullRepository(r *registry.Session, out io.Writer, localName,

 		if askedTag != "" && id != imageId {

 			continue

 		}

-		if err := s.Set(localName, tag, id, true); err != nil {

+		if err := s.Set(repoInfo.LocalName, tag, id, true); err != nil {

 			return err

 		}

 	}

-	requestedTag := localName

+	requestedTag := repoInfo.CanonicalName

 	if len(askedTag) > 0 {

-		requestedTag = localName + ":" + askedTag

+		requestedTag = repoInfo.CanonicalName + ":" + askedTag

 	}

 	WriteStatus(requestedTag, out, sf, layers_downloaded)

 	return nil

@@ -440,40 +423,40 @@ type downloadInfo struct {

 	err        chan error

 }

-func (s *TagStore) pullV2Repository(eng *engine.Engine, r *registry.Session, out io.Writer, localName, remoteName, tag string, sf *utils.StreamFormatter, parallel bool) error {

+func (s *TagStore) pullV2Repository(eng *engine.Engine, r *registry.Session, out io.Writer, repoInfo *registry.RepositoryInfo, tag string, sf *utils.StreamFormatter, parallel bool) error {

 	var layersDownloaded bool

 	if tag == "" {

-		log.Debugf("Pulling tag list from V2 registry for %s", remoteName)

-		tags, err := r.GetV2RemoteTags(remoteName, nil)

+		log.Debugf("Pulling tag list from V2 registry for %s", repoInfo.CanonicalName)

+		tags, err := r.GetV2RemoteTags(repoInfo.RemoteName, nil)

 		if err != nil {

 			return err

 		}

 		for _, t := range tags {

-			if downloaded, err := s.pullV2Tag(eng, r, out, localName, remoteName, t, sf, parallel); err != nil {

+			if downloaded, err := s.pullV2Tag(eng, r, out, repoInfo, t, sf, parallel); err != nil {

 				return err

 			} else if downloaded {

 				layersDownloaded = true

 			}

 		}

 	} else {

-		if downloaded, err := s.pullV2Tag(eng, r, out, localName, remoteName, tag, sf, parallel); err != nil {

+		if downloaded, err := s.pullV2Tag(eng, r, out, repoInfo, tag, sf, parallel); err != nil {

 			return err

 		} else if downloaded {

 			layersDownloaded = true

 		}

 	}

-	requestedTag := localName

+	requestedTag := repoInfo.CanonicalName

 	if len(tag) > 0 {

-		requestedTag = localName + ":" + tag

+		requestedTag = repoInfo.CanonicalName + ":" + tag

 	}

 	WriteStatus(requestedTag, out, sf, layersDownloaded)

 	return nil

 }

-func (s *TagStore) pullV2Tag(eng *engine.Engine, r *registry.Session, out io.Writer, localName, remoteName, tag string, sf *utils.StreamFormatter, parallel bool) (bool, error) {

+func (s *TagStore) pullV2Tag(eng *engine.Engine, r *registry.Session, out io.Writer, repoInfo *registry.RepositoryInfo, tag string, sf *utils.StreamFormatter, parallel bool) (bool, error) {

 	log.Debugf("Pulling tag from V2 registry: %q", tag)

-	manifestBytes, err := r.GetV2ImageManifest(remoteName, tag, nil)

+	manifestBytes, err := r.GetV2ImageManifest(repoInfo.RemoteName, tag, nil)

 	if err != nil {

 		return false, err

 	}

@@ -488,9 +471,9 @@ func (s *TagStore) pullV2Tag(eng *engine.Engine, r *registry.Session, out io.Wri

 	}

 	if verified {

-		out.Write(sf.FormatStatus(localName+":"+tag, "The image you are pulling has been verified"))

+		out.Write(sf.FormatStatus(repoInfo.CanonicalName+":"+tag, "The image you are pulling has been verified"))

 	} else {

-		out.Write(sf.FormatStatus(tag, "Pulling from %s", localName))

+		out.Write(sf.FormatStatus(tag, "Pulling from %s", repoInfo.CanonicalName))

 	}

 	if len(manifest.FSLayers) == 0 {

@@ -542,7 +525,7 @@ func (s *TagStore) pullV2Tag(eng *engine.Engine, r *registry.Session, out io.Wri

 					return err

 				}

-				r, l, err := r.GetV2ImageBlobReader(remoteName, sumType, checksum, nil)

+				r, l, err := r.GetV2ImageBlobReader(repoInfo.RemoteName, sumType, checksum, nil)

 				if err != nil {

 					return err

 				}

@@ -605,7 +588,7 @@ func (s *TagStore) pullV2Tag(eng *engine.Engine, r *registry.Session, out io.Wri

 	}

-	if err = s.Set(localName, tag, downloads[0].img.ID, true); err != nil {

+	if err = s.Set(repoInfo.LocalName, tag, downloads[0].img.ID, true); err != nil {

 		return false, err

 	}

@@ -61,7 +61,7 @@ func (s *TagStore) getImageList(localRepo map[string]string, requestedTag string

 	return imageList, tagsByImage, nil

 }

-func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, localName, remoteName string, localRepo map[string]string, tag string, sf *utils.StreamFormatter) error {

+func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, repoInfo *registry.RepositoryInfo, localRepo map[string]string, tag string, sf *utils.StreamFormatter) error {

 	out = utils.NewWriteFlusher(out)

 	log.Debugf("Local repo: %s", localRepo)

 	imgList, tagsByImage, err := s.getImageList(localRepo, tag)

@@ -104,7 +104,7 @@ func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, localName,

 	// Register all the images in a repository with the registry

 	// If an image is not in this list it will not be associated with the repository

-	repoData, err = r.PushImageJSONIndex(remoteName, imageIndex, false, nil)

+	repoData, err = r.PushImageJSONIndex(repoInfo.RemoteName, imageIndex, false, nil)

 	if err != nil {

 		return err

 	}

@@ -114,11 +114,11 @@ func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, localName,

 		nTag = len(localRepo)

 	}

 	for _, ep := range repoData.Endpoints {

-		out.Write(sf.FormatStatus("", "Pushing repository %s (%d tags)", localName, nTag))

+		out.Write(sf.FormatStatus("", "Pushing repository %s (%d tags)", repoInfo.CanonicalName, nTag))

 		for _, imgId := range imgList {

 			if err := r.LookupRemoteImage(imgId, ep, repoData.Tokens); err != nil {

 				log.Errorf("Error in LookupRemoteImage: %s", err)

-				if _, err := s.pushImage(r, out, remoteName, imgId, ep, repoData.Tokens, sf); err != nil {

+				if _, err := s.pushImage(r, out, imgId, ep, repoData.Tokens, sf); err != nil {

 					// FIXME: Continue on error?

 					return err

 				}

@@ -126,23 +126,23 @@ func (s *TagStore) pushRepository(r *registry.Session, out io.Writer, localName,

 				out.Write(sf.FormatStatus("", "Image %s already pushed, skipping", utils.TruncateID(imgId)))

 			}

 			for _, tag := range tagsByImage[imgId] {

-				out.Write(sf.FormatStatus("", "Pushing tag for rev [%s] on {%s}", utils.TruncateID(imgId), ep+"repositories/"+remoteName+"/tags/"+tag))

+				out.Write(sf.FormatStatus("", "Pushing tag for rev [%s] on {%s}", utils.TruncateID(imgId), ep+"repositories/"+repoInfo.RemoteName+"/tags/"+tag))

-				if err := r.PushRegistryTag(remoteName, imgId, tag, ep, repoData.Tokens); err != nil {

+				if err := r.PushRegistryTag(repoInfo.RemoteName, imgId, tag, ep, repoData.Tokens); err != nil {

 					return err

 				}

 			}

 		}

 	}

-	if _, err := r.PushImageJSONIndex(remoteName, imageIndex, true, repoData.Endpoints); err != nil {

+	if _, err := r.PushImageJSONIndex(repoInfo.RemoteName, imageIndex, true, repoData.Endpoints); err != nil {

 		return err

 	}

 	return nil

 }

-func (s *TagStore) pushImage(r *registry.Session, out io.Writer, remote, imgID, ep string, token []string, sf *utils.StreamFormatter) (checksum string, err error) {

+func (s *TagStore) pushImage(r *registry.Session, out io.Writer, imgID, ep string, token []string, sf *utils.StreamFormatter) (checksum string, err error) {

 	out = utils.NewWriteFlusher(out)

 	jsonRaw, err := ioutil.ReadFile(path.Join(s.graph.Root, imgID, "json"))

 	if err != nil {

@@ -199,26 +199,27 @@ func (s *TagStore) CmdPush(job *engine.Job) engine.Status {

 		metaHeaders map[string][]string

 	)

+	// Resolve the Repository name from fqn to RepositoryInfo

+	repoInfo, err := registry.ResolveRepositoryInfo(job, localName)

+	if err != nil {

+		return job.Error(err)

+	}

+

 	tag := job.Getenv("tag")

 	job.GetenvJson("authConfig", authConfig)

 	job.GetenvJson("metaHeaders", &metaHeaders)

-	if _, err := s.poolAdd("push", localName); err != nil {

-		return job.Error(err)

-	}

-	defer s.poolRemove("push", localName)

-	// Resolve the Repository name from fqn to endpoint + name

-	hostname, remoteName, err := registry.ResolveRepositoryName(localName)

-	if err != nil {

+	if _, err := s.poolAdd("push", repoInfo.LocalName); err != nil {

 		return job.Error(err)

 	}

+	defer s.poolRemove("push", repoInfo.LocalName)

-	endpoint, err := registry.NewEndpoint(hostname, s.insecureRegistries)

+	endpoint, err := repoInfo.GetEndpoint()

 	if err != nil {

 		return job.Error(err)

 	}

-	img, err := s.graph.Get(localName)

+	img, err := s.graph.Get(repoInfo.LocalName)

 	r, err2 := registry.NewSession(authConfig, registry.HTTPRequestFactory(metaHeaders), endpoint, false)

 	if err2 != nil {

 		return job.Error(err2)

@@ -227,12 +228,12 @@ func (s *TagStore) CmdPush(job *engine.Job) engine.Status {

 	if err != nil {

 		reposLen := 1

 		if tag == "" {

-			reposLen = len(s.Repositories[localName])

+			reposLen = len(s.Repositories[repoInfo.LocalName])

 		}

-		job.Stdout.Write(sf.FormatStatus("", "The push refers to a repository [%s] (len: %d)", localName, reposLen))

+		job.Stdout.Write(sf.FormatStatus("", "The push refers to a repository [%s] (len: %d)", repoInfo.CanonicalName, reposLen))

 		// If it fails, try to get the repository

-		if localRepo, exists := s.Repositories[localName]; exists {

-			if err := s.pushRepository(r, job.Stdout, localName, remoteName, localRepo, tag, sf); err != nil {

+		if localRepo, exists := s.Repositories[repoInfo.LocalName]; exists {

+			if err := s.pushRepository(r, job.Stdout, repoInfo, localRepo, tag, sf); err != nil {

 				return job.Error(err)

 			}

 			return engine.StatusOK

@@ -241,8 +242,8 @@ func (s *TagStore) CmdPush(job *engine.Job) engine.Status {

 	}

 	var token []string

-	job.Stdout.Write(sf.FormatStatus("", "The push refers to an image: [%s]", localName))

-	if _, err := s.pushImage(r, job.Stdout, remoteName, img.ID, endpoint.String(), token, sf); err != nil {

+	job.Stdout.Write(sf.FormatStatus("", "The push refers to an image: [%s]", repoInfo.CanonicalName))

+	if _, err := s.pushImage(r, job.Stdout, img.ID, endpoint.String(), token, sf); err != nil {

 		return job.Error(err)

 	}

 	return engine.StatusOK

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

 	"github.com/docker/docker/image"

 	"github.com/docker/docker/pkg/parsers"

+	"github.com/docker/docker/registry"

 	"github.com/docker/docker/utils"

 )

@@ -23,11 +24,9 @@ var (

 )

 type TagStore struct {

-	path               string

-	graph              *Graph

-	mirrors            []string

-	insecureRegistries []string

-	Repositories       map[string]Repository

+	path         string

+	graph        *Graph

+	Repositories map[string]Repository

 	sync.Mutex

 	// FIXME: move push/pull-related fields

 	// to a helper type

@@ -55,20 +54,18 @@ func (r Repository) Contains(u Repository) bool {

 	return true

 }

-func NewTagStore(path string, graph *Graph, mirrors []string, insecureRegistries []string) (*TagStore, error) {

+func NewTagStore(path string, graph *Graph) (*TagStore, error) {

 	abspath, err := filepath.Abs(path)

 	if err != nil {

 		return nil, err

 	}

 	store := &TagStore{

-		path:               abspath,

-		graph:              graph,

-		mirrors:            mirrors,

-		insecureRegistries: insecureRegistries,

-		Repositories:       make(map[string]Repository),

-		pullingPool:        make(map[string]chan struct{}),

-		pushingPool:        make(map[string]chan struct{}),

+		path:         abspath,

+		graph:        graph,

+		Repositories: make(map[string]Repository),

+		pullingPool:  make(map[string]chan struct{}),

+		pushingPool:  make(map[string]chan struct{}),

 	}

 	// Load the json file if it exists, otherwise create it.

 	if err := store.reload(); os.IsNotExist(err) {

@@ -178,6 +175,7 @@ func (store *TagStore) Delete(repoName, tag string) (bool, error) {

 	if err := store.reload(); err != nil {

 		return false, err

 	}

+	repoName = registry.NormalizeLocalName(repoName)

 	if r, exists := store.Repositories[repoName]; exists {

 		if tag != "" {

 			if _, exists2 := r[tag]; exists2 {

@@ -219,6 +217,7 @@ func (store *TagStore) Set(repoName, tag, imageName string, force bool) error {

 		return err

 	}

 	var repo Repository

+	repoName = registry.NormalizeLocalName(repoName)

 	if r, exists := store.Repositories[repoName]; exists {

 		repo = r

 		if old, exists := store.Repositories[repoName][tag]; exists && !force {

@@ -238,6 +237,7 @@ func (store *TagStore) Get(repoName string) (Repository, error) {

 	if err := store.reload(); err != nil {

 		return nil, err

 	}

+	repoName = registry.NormalizeLocalName(repoName)

 	if r, exists := store.Repositories[repoName]; exists {

 		return r, nil

 	}

@@ -279,20 +279,6 @@ func (store *TagStore) GetRepoRefs() map[string][]string {

 	return reporefs

 }

-// isOfficialName returns whether a repo name is considered an official

-// repository.  Official repositories are repos with names within

-// the library namespace or which default to the library namespace

-// by not providing one.

-func isOfficialName(name string) bool {

-	if strings.HasPrefix(name, "library/") {

-		return true

-	}

-	if strings.IndexRune(name, '/') == -1 {

-		return true

-	}

-	return false

-}

-

 // Validate the name of a repository

 func validateRepoName(name string) error {

 	if name == "" {

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

 )

 const (

-	testImageName = "myapp"

-	testImageID   = "1a2d3c4d4e5fa2d2a21acea242a5e2345d3aefc3e7dfa2a2a2a21a2a2ad2d234"

+	testOfficialImageName    = "myapp"

+	testOfficialImageID      = "1a2d3c4d4e5fa2d2a21acea242a5e2345d3aefc3e7dfa2a2a2a21a2a2ad2d234"

+	testOfficialImageIDShort = "1a2d3c4d4e5f"

+	testPrivateImageName     = "127.0.0.1:8000/privateapp"

+	testPrivateImageID       = "5bc255f8699e4ee89ac4469266c3d11515da88fdcbde45d7b069b636ff4efd81"

+	testPrivateImageIDShort  = "5bc255f8699e"

 )

 func fakeTar() (io.Reader, error) {

@@ -53,19 +57,30 @@ func mkTestTagStore(root string, t *testing.T) *TagStore {

 	if err != nil {

 		t.Fatal(err)

 	}

-	store, err := NewTagStore(path.Join(root, "tags"), graph, nil, nil)

+	store, err := NewTagStore(path.Join(root, "tags"), graph)

 	if err != nil {

 		t.Fatal(err)

 	}

-	archive, err := fakeTar()

+	officialArchive, err := fakeTar()

 	if err != nil {

 		t.Fatal(err)

 	}

-	img := &image.Image{ID: testImageID}

-	if err := graph.Register(img, archive); err != nil {

+	img := &image.Image{ID: testOfficialImageID}

+	if err := graph.Register(img, officialArchive); err != nil {

 		t.Fatal(err)

 	}

-	if err := store.Set(testImageName, "", testImageID, false); err != nil {

+	if err := store.Set(testOfficialImageName, "", testOfficialImageID, false); err != nil {

+		t.Fatal(err)

+	}

+	privateArchive, err := fakeTar()

+	if err != nil {

+		t.Fatal(err)

+	}

+	img = &image.Image{ID: testPrivateImageID}

+	if err := graph.Register(img, privateArchive); err != nil {

+		t.Fatal(err)

+	}

+	if err := store.Set(testPrivateImageName, "", testPrivateImageID, false); err != nil {

 		t.Fatal(err)

 	}

 	return store

@@ -80,39 +95,65 @@ func TestLookupImage(t *testing.T) {

 	store := mkTestTagStore(tmp, t)

 	defer store.graph.driver.Cleanup()

-	if img, err := store.LookupImage(testImageName); err != nil {

-		t.Fatal(err)

-	} else if img == nil {

-		t.Errorf("Expected 1 image, none found")

-	}

-	if img, err := store.LookupImage(testImageName + ":" + DEFAULTTAG); err != nil {

-		t.Fatal(err)

-	} else if img == nil {

-		t.Errorf("Expected 1 image, none found")

-	}

-

-	if img, err := store.LookupImage(testImageName + ":" + "fail"); err == nil {

-		t.Errorf("Expected error, none found")

-	} else if img != nil {

-		t.Errorf("Expected 0 image, 1 found")

-	}

-

-	if img, err := store.LookupImage("fail:fail"); err == nil {

-		t.Errorf("Expected error, none found")

-	} else if img != nil {

-		t.Errorf("Expected 0 image, 1 found")

+	officialLookups := []string{

+		testOfficialImageID,

+		testOfficialImageIDShort,

+		testOfficialImageName + ":" + testOfficialImageID,

+		testOfficialImageName + ":" + testOfficialImageIDShort,

+		testOfficialImageName,