func main() {
    if utils.SelfPath() == "/sbin/init" {
        // Running in init mode
        docker.SysInit()
        return
    }
    // FIXME: Switch d and D ? (to be more sshd like)
    flDaemon := flag.Bool("d", false, "Daemon mode")
    flDebug := flag.Bool("D", false, "Debug mode")

    ...

    if *flDaemon {
        if flag.NArg() != 0 {
            flag.Usage()
            return
        }
        if err := daemon(*pidfile, flHosts, *flAutoRestart, *flEnableCors, *flDns); err != nil {
            log.Fatal(err)
            os.Exit(-1)
        }
    } else {
        if len(flHosts) > 1 {
            log.Fatal("Please specify only one -H")
            return
        }
        protoAddrParts := strings.SplitN(flHosts[0], "://", 2)
        if err := docker.ParseCommands(protoAddrParts[0], protoAddrParts[1], flag.Args()...); err != nil {
            log.Fatal(err)
            os.Exit(-1)
        }
    }
}

func ListenAndServe(proto, addr string, srv *Server, logging bool) error {
    log.Printf("Listening for HTTP on %s (%s)\n", addr, proto)

    r, err := createRouter(srv, logging)
    if err != nil {
        return err
    }
    l, e := net.Listen(proto, addr)
    if e != nil {
        return e
    }
    //as the daemon is launched as root, change to permission of the socket to allow non-root to connect
    if proto == "unix" {
        os.Chmod(addr, 0777)
    }
    httpSrv := http.Server{Addr: addr, Handler: r}
    return httpSrv.Serve(l)
}

func getImagesJSON(srv *Server, version float64, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    if err := parseForm(r); err != nil {
        return err
    }

    all, err := getBoolParam(r.Form.Get("all"))
    if err != nil {
        return err
    }
    filter := r.Form.Get("filter")

    outs, err := srv.Images(all, filter)
    if err != nil {
        return err
    }
    b, err := json.Marshal(outs)
    if err != nil {
        return err
    }
    writeJSON(w, b)
    return nil
}

type APIImages struct {
    Repository  string `json:",omitempty"`
    Tag         string `json:",omitempty"`
    ID          string `json:"Id"`
    Created     int64
    Size        int64
    VirtualSize int64
}

func NewRuntime(autoRestart bool, dns []string) (*Runtime, error) {
    runtime, err := NewRuntimeFromDirectory("/var/lib/docker", autoRestart)
    ...
    return runtime, nil
}

func NewRuntimeFromDirectory(root string, autoRestart bool) (*Runtime, error) {
    runtimeRepo := path.Join(root, "containers")

    if err := os.MkdirAll(runtimeRepo, 0700); err != nil && !os.IsExist(err) {
        return nil, err
    }

    g, err := NewGraph(path.Join(root, "graph"))
    if err != nil {
        return nil, err
    }
    volumes, err := NewGraph(path.Join(root, "volumes"))
    if err != nil {
        return nil, err
    }
    repositories, err := NewTagStore(path.Join(root, "repositories"), g)
    if err != nil {
        return nil, fmt.Errorf("Couldn't create Tag store: %s", err)
    }
    ...
    return runtime, nil
}

func (builder *Builder) Commit(container *Container, repository, tag, comment, author string, config *Config) (*Image, error) {
    // FIXME: freeze the container before copying it to avoid data corruption?
    // FIXME: this shouldn't be in commands.
    rwTar, err := container.ExportRw()
    if err != nil {
        return nil, err
    }
    // Create a new image from the container's base layers + a new layer from container changes
    img, err := builder.graph.Create(rwTar, container, comment, author, config)
    if err != nil {
        return nil, err
    }
    ...

// Create creates a new image and registers it in the graph.
func (graph *Graph) Create(layerData Archive, container *Container, comment, author string, config *Config) (*Image, error) {
    img := &Image{
        ID:            GenerateID(),
        Comment:       comment,
        Created:       time.Now(),
        DockerVersion: VERSION,
        Author:        author,
        Config:        config,
        Architecture:  "x86_64",
    }
    if container != nil {
        img.Parent = container.Image
        img.Container = container.ID
        img.ContainerConfig = *container.Config
    }
    if err := graph.Register(layerData, layerData != nil, img); err != nil {
        return nil, err
    }
    go img.Checksum()
    return img, nil
}

func (b *buildFile) CmdRun(args string) error {
    ...
    cid, err := b.run()
    if err != nil {
        return err
    }
    if err := b.commit(cid, cmd, "run"); err != nil {
        return err
    }
    b.config.Cmd = cmd
    return nil
}

func (b *buildFile) run() (string, error) {
    if b.image == "" {
        return "", fmt.Errorf("Please provide a source image with `from` prior to run")
    }
    b.config.Image = b.image

    // Create the container and start it
    c, err := b.builder.Create(b.config)

    ...

    return c.ID, nil
}

// Commit the container <id> with the autorun command <autoCmd>
func (b *buildFile) commit(id string, autoCmd []string, comment string) error {
    ...

    container := b.runtime.Get(id)
    if container == nil {
        return fmt.Errorf("An error occured while creating the container")
    }

    // Note: Actually copy the struct
    autoConfig := *b.config
    autoConfig.Cmd = autoCmd
    // Commit the container
    image, err := b.builder.Commit(container, "", "", "", b.maintainer, &autoConfig)
    if err != nil {
        return err
    }
    b.tmpImages[image.ID] = struct{}{}
    b.image = image.ID
    return nil
}

func (cli *DockerCli) getMethod(name string) (reflect.Method, bool) {
    methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:])
    return reflect.TypeOf(cli).MethodByName(methodName)
}

func ParseCommands(proto, addr string, args ...string) error {
    cli := NewDockerCli(proto, addr)

    if len(args) > 0 {
        method, exists := cli.getMethod(args[0])
        if !exists {
            fmt.Println("Error: Command not found:", args[0])
            return cli.CmdHelp(args[1:]...)
        }
        ret := method.Func.CallSlice([]reflect.Value{
            reflect.ValueOf(cli),
            reflect.ValueOf(args[1:]),
        })[0].Interface()
        if ret == nil {
            return nil
        }
        return ret.(error)
    }
    return cli.CmdHelp(args...)
}

func (cli *DockerCli) CmdRun(args ...string) error {
    ...

    if !config.AttachStdout && !config.AttachStderr {
        fmt.Println(out.ID)
    } else {
        if config.Tty {
            cli.monitorTtySize(out.ID)
        }

        v := url.Values{}
        v.Set("logs", "1")
        v.Set("stream", "1")

        if config.AttachStdin {
            v.Set("stdin", "1")
        }
        if config.AttachStdout {
            v.Set("stdout", "1")
        }
        if config.AttachStderr {
            v.Set("stderr", "1")
        }
        if err := cli.hijack("POST", "/containers/"+out.ID+"/attach?"+v.Encode(), config.Tty, os.Stdin, os.Stdout); err != nil {
            utils.Debugf("Error hijack: %s", err)
            return err
        }
    }
    return nil

func (cli *DockerCli) hijack(method, path string, setRawTerminal bool, in *os.File, out io.Writer) error {

    req, err := http.NewRequest(method, fmt.Sprintf("/v%g%s", APIVERSION, path), nil)
    if err != nil {
        return err
    }
    req.Header.Set("User-Agent", "Docker-Client/"+VERSION)
    req.Header.Set("Content-Type", "plain/text")

    dial, err := net.Dial(cli.proto, cli.addr)
    if err != nil {
        return err
    }
    clientconn := httputil.NewClientConn(dial, nil)
    defer clientconn.Close()

    // Server hijacks the connection, error 'connection closed' expected
    clientconn.Do(req)

    rwc, br := clientconn.Hijack()
    defer rwc.Close()

    receiveStdout := utils.Go(func() error {
        _, err := io.Copy(out, br)
        return err
    })

    if in != nil && setRawTerminal && term.IsTerminal(in.Fd()) && os.Getenv("NORAW") == "" {
        oldState, err := term.SetRawTerminal()
        if err != nil {
            return err
        }
        defer term.RestoreTerminal(oldState)
    }
    sendStdin := utils.Go(func() error {
        io.Copy(rwc, in)
        if err := rwc.(*net.TCPConn).CloseWrite(); err != nil {
            utils.Debugf("Couldn't send EOF: %s\n", err)
        }
        // Discard errors due to pipe interruption
        return nil
    })

    if err := <-receiveStdout; err != nil {
        utils.Debugf("Error receiveStdout: %s", err)
        return err
    }

    if !term.IsTerminal(in.Fd()) {
        if err := <-sendStdin; err != nil {
            utils.Debugf("Error sendStdin: %s", err)
            return err
        }
    }
    return nil

}