deleted file mode 100644

@@ -1,203 +0,0 @@

-package main

-

-import (

-	"encoding/json"

-	"flag"

-	"fmt"

-	"github.com/dotcloud/docker/pkg/libcontainer"

-	"github.com/dotcloud/docker/pkg/libcontainer/namespaces"

-	"github.com/dotcloud/docker/pkg/libcontainer/namespaces/nsinit"

-	"github.com/dotcloud/docker/pkg/libcontainer/network"

-	"github.com/dotcloud/docker/pkg/libcontainer/utils"

-	"os"

-	exec_ "os/exec"

-	"path"

-	"path/filepath"

-)

-

-var (

-	displayPid bool

-	newCommand string

-	usrNet     bool

-	masterFd   int

-	console    string

-)

-

-func init() {

-	flag.BoolVar(&displayPid, "pid", false, "display the pid before waiting")

-	flag.StringVar(&newCommand, "cmd", "/bin/bash", "command to run in the existing namespace")

-	flag.BoolVar(&usrNet, "net", false, "user a net namespace")

-	flag.IntVar(&masterFd, "master", 0, "master fd")

-	flag.StringVar(&console, "console", "", "console path")

-	flag.Parse()

-}

-

-func nsinitFunc(container *libcontainer.Container) error {

-	container.Master = uintptr(masterFd)

-	container.Console = console

-	container.LogFile = "/root/logs"

-

-	return nsinit.InitNamespace(container)

-}

-

-func exec(container *libcontainer.Container) error {

-	var (

-		netFile *os.File

-		err     error

-	)

-	container.NetNsFd = 0

-

-	if usrNet {

-		netFile, err = os.Open("/root/nsroot/test")

-		if err != nil {

-			return err

-		}

-		container.NetNsFd = netFile.Fd()

-	}

-

-	self, err := exec_.LookPath(os.Args[0])

-	if err != nil {

-		return err

-	}

-	if output, err := exec_.Command("cp", self, path.Join(container.RootFs, ".nsinit")).CombinedOutput(); err != nil {

-		return fmt.Errorf("Error exec cp: %s, (%s)", err, output)

-	} else {

-		println(self, container.RootFs)

-		fmt.Printf("-----> %s\n", output)

-	}

-	println("----")

-

-	pid, err := namespaces.ExecContainer(container)

-	if err != nil {

-		return fmt.Errorf("error exec container %s", err)

-	}

-

-	if displayPid {

-		fmt.Println(pid)

-	}

-

-	exitcode, err := utils.WaitOnPid(pid)

-	if err != nil {

-		return fmt.Errorf("error waiting on child %s", err)

-	}

-	fmt.Println(exitcode)

-	if usrNet {

-		netFile.Close()

-		if err := network.DeleteNetworkNamespace("/root/nsroot/test"); err != nil {

-			return err

-		}

-	}

-	os.Exit(exitcode)

-	return nil

-}

-

-func execIn(container *libcontainer.Container) error {

-	// f, err := os.Open("/root/nsroot/test")

-	// if err != nil {

-	// 	return err

-	// }

-	// container.NetNsFd = f.Fd()

-	// pid, err := namespaces.ExecIn(container, &libcontainer.Command{

-	// 	Env: container.Command.Env,

-	// 	Args: []string{

-	// 		newCommand,

-	// 	},

-	// })

-	// if err != nil {

-	// 	return fmt.Errorf("error exexin container %s", err)

-	// }

-	// exitcode, err := utils.WaitOnPid(pid)

-	// if err != nil {

-	// 	return fmt.Errorf("error waiting on child %s", err)

-	// }

-	// os.Exit(exitcode)

-	return nil

-}

-

-func createNet(config *libcontainer.Network) error {

-	/*

-		root := "/root/nsroot"

-		if err := network.SetupNamespaceMountDir(root); err != nil {

-			return err

-		}

-

-		nspath := root + "/test"

-		if err := network.CreateNetworkNamespace(nspath); err != nil {

-			return nil

-		}

-		if err := network.CreateVethPair("veth0", config.TempVethName); err != nil {

-			return err

-		}

-		if err := network.SetInterfaceMaster("veth0", config.Bridge); err != nil {

-			return err

-		}

-		if err := network.InterfaceUp("veth0"); err != nil {

-			return err

-		}

-

-		f, err := os.Open(nspath)

-		if err != nil {

-			return err

-		}

-		defer f.Close()

-

-		if err := network.SetInterfaceInNamespaceFd("veth1", int(f.Fd())); err != nil {

-			return err

-		}

-

-			if err := network.SetupVethInsideNamespace(f.Fd(), config); err != nil {

-				return err

-			}

-	*/

-	return nil

-}

-

-func printErr(err error) {

-	fmt.Fprintln(os.Stderr, err)

-	os.Exit(1)

-}

-

-func main() {

-	cliCmd := flag.Arg(0)

-

-	config, err := filepath.Abs(flag.Arg(1))

-	if err != nil {

-		printErr(err)

-	}

-	println("cli:", cliCmd, "config:", config)

-	f, err := os.Open(config)

-	if err != nil {

-		printErr(err)

-	}

-

-	dec := json.NewDecoder(f)

-	var container *libcontainer.Container

-

-	if err := dec.Decode(&container); err != nil {

-		printErr(err)

-	}

-	f.Close()

-

-	switch cliCmd {

-	case "init":

-		err = nsinitFunc(container)

-	case "exec":

-		err = exec(container)

-	case "execin":

-		err = execIn(container)

-	case "net":

-		err = createNet(&libcontainer.Network{

-			TempVethName: "veth1",

-			IP:           "172.17.0.100/16",

-			Gateway:      "172.17.42.1",

-			Mtu:          1500,

-			Bridge:       "docker0",

-		})

-	default:

-		err = fmt.Errorf("command not supported: %s", cliCmd)

-	}

-

-	if err != nil {

-		printErr(err)

-	}

-}

deleted file mode 100644

@@ -1,76 +0,0 @@

-package namespaces

-

-import (

-	"github.com/dotcloud/docker/pkg/libcontainer"

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

-	"github.com/dotcloud/docker/pkg/term"

-	"io"

-	"log"

-	"os"

-	"os/exec"

-	"syscall"

-)

-

-// ExecContainer will spawn new namespaces with the specified Container configuration

-// in the RootFs path and return the pid of the new containerized process.

-//

-// If an existing network namespace is specified the container

-// will join that namespace.  If an existing network namespace is not specified but CLONE_NEWNET is,

-// the container will be spawned with a new network namespace with no configuration.  Omiting an

-// existing network namespace and the CLONE_NEWNET option in the container configuration will allow

-// the container to the the host's networking options and configuration.

-func ExecContainer(container *libcontainer.Container) (pid int, err error) {

-	master, console, err := createMasterAndConsole()

-	if err != nil {

-		return -1, err

-	}

-

-	// we need CLONE_VFORK so we can wait on the child

-	flag := uintptr(getNamespaceFlags(container.Namespaces) | CLONE_VFORK)

-

-	command := exec.Command("nsinit", console)

-	command.SysProcAttr = &syscall.SysProcAttr{

-		Cloneflags: flag,

-	}

-

-	if err := command.Start(); err != nil {

-		return -1, err

-	}

-	pid = command.Process.Pid

-

-	go func() {

-		if _, err := io.Copy(os.Stdout, master); err != nil {

-			log.Println(err)

-		}

-	}()

-

-	go func() {

-		if _, err := io.Copy(master, os.Stdin); err != nil {

-			log.Println(err)

-		}

-	}()

-

-	term.SetRawTerminal(os.Stdin.Fd())

-

-	if err := command.Wait(); err != nil {

-		return pid, err

-	}

-	return pid, nil

-}

-

-func createMasterAndConsole() (*os.File, string, error) {

-	master, err := os.OpenFile("/dev/ptmx", syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_CLOEXEC, 0)

-	if err != nil {

-		return nil, "", err

-	}

-

-	console, err := system.Ptsname(master)

-	if err != nil {

-		return nil, "", err

-	}

-

-	if err := system.Unlockpt(master); err != nil {

-		return nil, "", err

-	}

-	return master, console, nil

-}

deleted file mode 100644

@@ -1,44 +0,0 @@

-package namespaces

-

-import (

-	"github.com/dotcloud/docker/pkg/libcontainer"

-)

-

-const (

-	SIGCHLD       = 0x14

-	CLONE_VFORK   = 0x00004000

-	CLONE_NEWNS   = 0x00020000

-	CLONE_NEWUTS  = 0x04000000

-	CLONE_NEWIPC  = 0x08000000

-	CLONE_NEWUSER = 0x10000000

-	CLONE_NEWPID  = 0x20000000

-	CLONE_NEWNET  = 0x40000000

-)

-

-var namespaceMap = map[libcontainer.Namespace]int{

-	"": 0,

-	libcontainer.CLONE_NEWNS:   CLONE_NEWNS,

-	libcontainer.CLONE_NEWUTS:  CLONE_NEWUTS,

-	libcontainer.CLONE_NEWIPC:  CLONE_NEWIPC,

-	libcontainer.CLONE_NEWUSER: CLONE_NEWUSER,

-	libcontainer.CLONE_NEWPID:  CLONE_NEWPID,

-	libcontainer.CLONE_NEWNET:  CLONE_NEWNET,

-}

-

-var namespaceFileMap = map[libcontainer.Namespace]string{

-	libcontainer.CLONE_NEWNS:   "mnt",

-	libcontainer.CLONE_NEWUTS:  "uts",

-	libcontainer.CLONE_NEWIPC:  "ipc",

-	libcontainer.CLONE_NEWUSER: "user",

-	libcontainer.CLONE_NEWPID:  "pid",

-	libcontainer.CLONE_NEWNET:  "net",

-}

-

-// getNamespaceFlags parses the container's Namespaces options to set the correct

-// flags on clone, unshare, and setns

-func getNamespaceFlags(namespaces libcontainer.Namespaces) (flag int) {

-	for _, ns := range namespaces {

-		flag |= namespaceMap[ns]

-	}

-	return flag

-}

deleted file mode 100644

@@ -1,170 +0,0 @@

-package main

-

-import (

-	"encoding/json"

-	"fmt"

-	"github.com/dotcloud/docker/pkg/libcontainer"

-	"github.com/dotcloud/docker/pkg/libcontainer/capabilities"

-	"github.com/dotcloud/docker/pkg/libcontainer/namespaces"

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

-	"log"

-	"os"

-	"path/filepath"

-	"syscall"

-)

-

-func loadContainer() (*libcontainer.Container, error) {

-	f, err := os.Open("container.json")

-	if err != nil {

-		return nil, err

-	}

-	defer f.Close()

-

-	var container *libcontainer.Container

-	if err := json.NewDecoder(f).Decode(&container); err != nil {

-		return nil, err

-	}

-	return container, nil

-}

-

-func main() {

-	container, err := loadContainer()

-	if err != nil {

-		log.Fatal(err)

-	}

-

-	if os.Args[1] == "exec" {

-		_, err := namespaces.ExecContainer(container)

-		if err != nil {

-			log.Fatal(err)

-		}

-		os.Exit(0)

-	}

-	console := os.Args[1]

-

-	if err := setLogFile(container); err != nil {

-		log.Fatal(err)

-	}

-

-	rootfs, err := resolveRootfs()

-	if err != nil {

-		log.Fatal(err)

-	}

-

-	// close pipes so that we can replace it with the pty

-	os.Stdin.Close()

-	os.Stdout.Close()

-	os.Stderr.Close()

-

-	slave, err := openTerminal(console, syscall.O_RDWR)

-	if err != nil {

-		log.Fatalf("open terminal %s", err)

-	}

-	if slave.Fd() != 0 {

-		log.Fatalf("slave fd should be 0")

-	}

-	if err := dupSlave(slave); err != nil {

-		log.Fatalf("dup2 slave %s", err)

-	}

-

-	if _, err := system.Setsid(); err != nil {

-		log.Fatalf("setsid %s", err)

-	}

-	if err := system.Setctty(); err != nil {

-		log.Fatalf("setctty %s", err)

-	}

-	if err := system.ParentDeathSignal(); err != nil {

-		log.Fatalf("parent deth signal %s", err)

-	}

-

-	if err := setupNewMountNamespace(rootfs, console, container.ReadonlyFs); err != nil {

-		log.Fatalf("setup mount namespace %s", err)

-	}

-

-	if container.Network != nil {

-		if err := setupNetworking(container); err != nil {

-			log.Fatalf("setup networking %s", err)

-		}

-	}

-

-	if err := system.Sethostname(container.ID); err != nil {

-		log.Fatalf("sethostname %s", err)

-	}

-	if err := capabilities.DropCapabilities(container); err != nil {

-		log.Fatalf("drop capabilities %s", err)

-	}

-	if err := setupUser(container); err != nil {

-		log.Fatalf("setup user %s", err)

-	}

-	if container.WorkingDir != "" {

-		if err := system.Chdir(container.WorkingDir); err != nil {

-			log.Fatalf("chdir to %s %s", container.WorkingDir, err)

-		}

-	}

-	if err := system.Exec(container.Command.Args[0], container.Command.Args[0:], container.Command.Env); err != nil {

-		log.Fatalf("exec %s", err)

-	}

-	panic("unreachable")

-}

-

-func resolveRootfs() (string, error) {

-	cwd, err := os.Getwd()

-	if err != nil {

-		return "", err

-	}

-	rootfs, err := filepath.Abs(cwd)

-	if err != nil {

-		return "", err

-	}

-	return filepath.EvalSymlinks(rootfs)

-}

-

-func setupUser(container *libcontainer.Container) error {

-	// TODO: honor user passed on container

-	if err := system.Setgroups(nil); err != nil {

-		return err

-	}

-	if err := system.Setresgid(0, 0, 0); err != nil {

-		return err

-	}

-	if err := system.Setresuid(0, 0, 0); err != nil {

-		return err

-	}

-	return nil

-}

-

-func dupSlave(slave *os.File) error {

-	// we close Stdin,etc so our pty slave should have fd 0

-	if slave.Fd() != 0 {

-		return fmt.Errorf("slave fd not 0 %d", slave.Fd())

-	}

-	if err := system.Dup2(slave.Fd(), 1); err != nil {

-		return err

-	}

-	if err := system.Dup2(slave.Fd(), 2); err != nil {

-		return err

-	}

-	return nil

-}

-

-// openTerminal is a clone of os.OpenFile without the O_CLOEXEC addition.

-func openTerminal(name string, flag int) (*os.File, error) {

-	r, e := syscall.Open(name, flag, 0)

-	if e != nil {

-		return nil, &os.PathError{"open", name, e}

-	}

-	return os.NewFile(uintptr(r), name), nil

-}

-

-func setLogFile(container *libcontainer.Container) error {

-	f, err := os.OpenFile(container.LogFile, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0655)

-	if err != nil {

-		return err

-	}

-	log.SetOutput(f)

-	return nil

-}

-

-func setupNetworking(conatiner *libcontainer.Container) error {

-	return nil

-}

deleted file mode 100644

@@ -1,209 +0,0 @@

-package main

-

-import (

-	"fmt"

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

-	"log"

-	"os"

-	"path/filepath"

-	"syscall"

-)

-

-var (

-	// default mount point options

-	defaults = syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV

-)

-

-func setupNewMountNamespace(rootfs, console string, readonly bool) error {

-	if err := system.Mount("", "/", "", syscall.MS_SLAVE|syscall.MS_REC, ""); err != nil {

-		return fmt.Errorf("mounting / as slave %s", err)

-	}

-

-	if err := system.Mount(rootfs, rootfs, "bind", syscall.MS_BIND|syscall.MS_REC, ""); err != nil {

-		return fmt.Errorf("mouting %s as bind %s", rootfs, err)

-	}

-

-	if readonly {

-		if err := system.Mount(rootfs, rootfs, "bind", syscall.MS_BIND|syscall.MS_REMOUNT|syscall.MS_RDONLY|syscall.MS_REC, ""); err != nil {

-			return fmt.Errorf("mounting %s as readonly %s", rootfs, err)

-		}

-	}

-

-	if err := mountSystem(rootfs); err != nil {

-		return fmt.Errorf("mount system %s", err)

-	}

-

-	if err := copyDevNodes(rootfs); err != nil {

-		return fmt.Errorf("copy dev nodes %s", err)

-	}

-

-	ptmx := filepath.Join(rootfs, "dev/ptmx")

-	if err := os.Remove(ptmx); err != nil && !os.IsNotExist(err) {

-		return err

-	}

-	if err := os.Symlink("pts/ptmx", ptmx); err != nil {

-		return fmt.Errorf("symlink dev ptmx %s", err)

-	}

-

-	if err := setupDev(rootfs); err != nil {

-		return err

-	}

-

-	if err := setupConsole(rootfs, console); err != nil {

-		return err

-	}

-

-	if err := system.Chdir(rootfs); err != nil {

-		return fmt.Errorf("chdir into %s %s", rootfs, err)

-	}

-

-	if err := system.Mount(rootfs, "/", "", syscall.MS_MOVE, ""); err != nil {

-		return fmt.Errorf("mount move %s into / %s", rootfs, err)

-	}

-

-	if err := system.Chroot("."); err != nil {

-		return fmt.Errorf("chroot . %s", err)

-	}

-

-	if err := system.Chdir("/"); err != nil {

-		return fmt.Errorf("chdir / %s", err)

-	}

-

-	system.Umask(0022)

-

-	return nil

-}

-

-func copyDevNodes(rootfs string) error {

-	oldMask := system.Umask(0000)

-	defer system.Umask(oldMask)

-

-	for _, node := range []string{

-		"null",

-		"zero",

-		"full",

-		"random",

-		"urandom",

-		"tty",

-	} {

-		stat, err := os.Stat(filepath.Join("/dev", node))

-		if err != nil {

-			return err

-		}

-

-		var (

-			dest = filepath.Join(rootfs, "dev", node)

-			st   = stat.Sys().(*syscall.Stat_t)

-		)

-

-		log.Printf("copy %s to %s %d\n", node, dest, st.Rdev)

-		if err := system.Mknod(dest, st.Mode, int(st.Rdev)); err != nil && !os.IsExist(err) {

-			return fmt.Errorf("copy %s %s", node, err)

-		}

-	}

-	return nil

-}

-

-func setupDev(rootfs string) error {

-	for _, link := range []struct {

-		from string

-		to   string

-	}{

-		{"/proc/kcore", "/dev/core"},

-		{"/proc/self/fd", "/dev/fd"},

-		{"/proc/self/fd/0", "/dev/stdin"},

-		{"/proc/self/fd/1", "/dev/stdout"},

-		{"/proc/self/fd/2", "/dev/stderr"},

-	} {

-		dest := filepath.Join(rootfs, link.to)

-		if err := os.Remove(dest); err != nil && !os.IsNotExist(err) {

-			return fmt.Errorf("remove %s %s", dest, err)

-		}

-		if err := os.Symlink(link.from, dest); err != nil {

-			return fmt.Errorf("symlink %s %s", dest, err)

-		}

-	}

-	return nil

-}

-

-func setupConsole(rootfs, console string) error {

-	oldMask := system.Umask(0000)

-	defer system.Umask(oldMask)

-

-	stat, err := os.Stat(console)

-	if err != nil {

-		return fmt.Errorf("stat console %s %s", console, err)

-	}

-	st := stat.Sys().(*syscall.Stat_t)

-

-	dest := filepath.Join(rootfs, "dev/console")

-	if err := os.Remove(dest); err != nil && !os.IsNotExist(err) {

-		return fmt.Errorf("remove %s %s", dest, err)

-	}

-

-	if err := os.Chmod(console, 0600); err != nil {

-		return err

-	}

-	if err := os.Chown(console, 0, 0); err != nil {

-		return err

-	}

-

-	if err := system.Mknod(dest, (st.Mode&^07777)|0600, int(st.Rdev)); err != nil {

-		return fmt.Errorf("mknod %s %s", dest, err)

-	}

-

-	if err := system.Mount(console, dest, "bind", syscall.MS_BIND, ""); err != nil {

-		return fmt.Errorf("bind %s to %s %s", console, dest, err)

-	}

-	return nil

-}

-

-// mountSystem sets up linux specific system mounts like sys, proc, shm, and devpts

-// inside the mount namespace

-func mountSystem(rootfs string) error {

-	for _, m := range []struct {

-		source string

-		path   string

-		device string

-		flags  int

-		data   string

-	}{

-		{source: "proc", path: filepath.Join(rootfs, "proc"), device: "proc", flags: defaults},

-		{source: "sysfs", path: filepath.Join(rootfs, "sys"), device: "sysfs", flags: defaults},

-		{source: "tmpfs", path: filepath.Join(rootfs, "dev"), device: "tmpfs", flags: syscall.MS_NOSUID | syscall.MS_STRICTATIME, data: "mode=755"},

-		{source: "shm", path: filepath.Join(rootfs, "dev", "shm"), device: "tmpfs", flags: defaults, data: "mode=1777"},

-		{source: "devpts", path: filepath.Join(rootfs, "dev", "pts"), device: "devpts", flags: syscall.MS_NOSUID | syscall.MS_NOEXEC, data: "newinstance,ptmxmode=0666,mode=620,gid=5"},

-		{source: "tmpfs", path: filepath.Join(rootfs, "run"), device: "tmpfs", flags: syscall.MS_NOSUID | syscall.MS_NODEV | syscall.MS_STRICTATIME, data: "mode=755"},

-	} {

-		if err := os.MkdirAll(m.path, 0755); err != nil && !os.IsExist(err) {

-			return fmt.Errorf("mkdirall %s %s", m.path, err)

-		}

-		if err := system.Mount(m.source, m.path, m.device, uintptr(m.flags), m.data); err != nil {

-			return fmt.Errorf("mounting %s into %s %s", m.source, m.path, err)

-		}

-	}

-	return nil

-}

-

-func remountProc() error {

-	if err := system.Unmount("/proc", syscall.MNT_DETACH); err != nil {

-		return err

-	}

-	if err := system.Mount("proc", "/proc", "proc", uintptr(defaults), ""); err != nil {

-		return err

-	}

-	return nil

-}

-

-func remountSys() error {

-	if err := system.Unmount("/sys", syscall.MNT_DETACH); err != nil {

-		if err != syscall.EINVAL {

-			return err

-		}

-	} else {

-		if err := system.Mount("sysfs", "/sys", "sysfs", uintptr(defaults), ""); err != nil {

-			return err

-		}

-	}

-	return nil

-}

deleted file mode 100644

@@ -1,48 +0,0 @@

-package namespaces

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/pkg/libcontainer"

-	"os"

-	"path/filepath"

-	"strconv"

-	"strings"

-)

-

-func addEnvIfNotSet(container *libcontainer.Container, key, value string) {

-	jv := fmt.Sprintf("%s=%s", key, value)

-	if len(container.Command.Env) == 0 {

-		container.Command.Env = []string{jv}

-		return

-	}

-

-	for _, v := range container.Command.Env {

-		parts := strings.Split(v, "=")

-		if parts[0] == key {

-			return

-		}

-	}

-	container.Command.Env = append(container.Command.Env, jv)

-}

-

-// getNsFd returns the fd for a specific pid and namespace option

-func getNsFd(pid int, ns string) (uintptr, error) {

-	nspath := filepath.Join("/proc", strconv.Itoa(pid), "ns", ns)

-	// OpenFile adds closOnExec

-	f, err := os.OpenFile(nspath, os.O_RDONLY, 0666)

-	if err != nil {

-		return 0, err

-	}

-	return f.Fd(), nil

-}

-

-// setupEnvironment adds additional environment variables to the container's

-// Command such as USER, LOGNAME, container, and TERM

-func setupEnvironment(container *libcontainer.Container) {

-	addEnvIfNotSet(container, "container", "docker")

-	// TODO: check if pty

-	addEnvIfNotSet(container, "TERM", "xterm")

-	// TODO: get username from container

-	addEnvIfNotSet(container, "USER", "root")

-	addEnvIfNotSet(container, "LOGNAME", "root")

-}

new file mode 100644

@@ -0,0 +1,80 @@

+package main

+

+import (

+	"github.com/dotcloud/docker/pkg/libcontainer"

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

+	"github.com/dotcloud/docker/pkg/term"

+	"io"

+	"log"

+	"os"

+	"os/exec"

+	"syscall"

+)

+

+func execCommand(container *libcontainer.Container) (pid int, err error) {

+	master, console, err := createMasterAndConsole()

+	if err != nil {

+		return -1, err

+	}

+

+	// we need CLONE_VFORK so we can wait on the child

+	flag := uintptr(getNamespaceFlags(container.Namespaces) | CLONE_VFORK)

+

+	command := exec.Command("nsinit", console)

+	command.SysProcAttr = &syscall.SysProcAttr{

+		Cloneflags: flag,

+	}

+

+	if err := command.Start(); err != nil {

+		return -1, err

+	}

+	pid = command.Process.Pid

+

+	go func() {

+		if _, err := io.Copy(os.Stdout, master); err != nil {

+			log.Println(err)

+		}

+	}()

+

+	go func() {

+		if _, err := io.Copy(master, os.Stdin); err != nil {

+			log.Println(err)

+		}

+	}()

+

+	ws, err := term.GetWinsize(os.Stdin.Fd())

+	if err != nil {

+		return -1, err

+	}

+	if err := term.SetWinsize(master.Fd(), ws); err != nil {

+		return -1, err

+	}

+	state, err := term.SetRawTerminal(os.Stdin.Fd())

+	if err != nil {

+		command.Process.Kill()

+		return -1, err

+	}

+	defer term.RestoreTerminal(os.Stdin.Fd(), state)

+

+	if err := command.Wait(); err != nil {

+		return pid, err

+	}

+	return pid, nil

+}

+

+func createMasterAndConsole() (*os.File, string, error) {

+	master, err := os.OpenFile("/dev/ptmx", syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_CLOEXEC, 0)

+	if err != nil {

+		return nil, "", err

+	}

+

+	console, err := system.Ptsname(master)

+	if err != nil {

+		return nil, "", err

+	}

+

+	if err := system.Unlockpt(master); err != nil {

+		return nil, "", err

+	}

+	return master, console, nil

+}

new file mode 100644

@@ -0,0 +1,171 @@

+package main

+

+import (

+	"encoding/json"

+	"fmt"

+	"github.com/dotcloud/docker/pkg/libcontainer"

+	"github.com/dotcloud/docker/pkg/libcontainer/capabilities"

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

+	"log"

+	"os"

+	"path/filepath"

+	"syscall"

+)

+

+func loadContainer() (*libcontainer.Container, error) {

+	f, err := os.Open("container.json")

+	if err != nil {

+		return nil, err

+	}

+	defer f.Close()

+

+	var container *libcontainer.Container

+	if err := json.NewDecoder(f).Decode(&container); err != nil {

+		return nil, err

+	}

+	return container, nil