func (x *XCmd) StartPTY(stty []string) (xpty circuit.X, err error) {
pty, tty, err := pty.Open()
if err != nil {
return nil, errors.Pack(err)
}
defer tty.Close() // Close our handle on the TTY after the child executes
x.cmd.Stdout, x.cmd.Stdin, x.cmd.Stderr = tty, tty, tty
x.cmd.SysProcAttr = &syscall.SysProcAttr{Setctty: true, Setsid: true}
if err = x.cmd.Start(); err != nil {
pty.Close()
return nil, errors.Pack(err)
}
// sfs1/rex has comment that maybe tty flags cannot change until tty opened by child?? Not sure.
if len(stty) > 0 {
arg0 := []string{"-f", tty.Name()}
if err = exec.Command("stty", append(arg0, "sane")...).Run(); err != nil {
return nil, errors.Pack(err)
}
//log.Printf("PTY=%s, XX %#v", pty.Name(), append(arg0, stty...))
if err = exec.Command("stty", append(arg0, stty...)...).Run(); err != nil {
return nil, errors.Pack(err)
}
}
defer func() {
go x.cmd.Wait() // Calling wait is necessary, otherwise child remains zombie
}()
return xyio.NewXReadWriteCloser(pty), nil
}
func (x XServer) Profile(name string) (circuit.X, error) {
r, err := x.server.Profile(name)
if err != nil {
return nil, errors.Pack(err)
}
return xio.NewXReadCloser(r), nil
}
func (x XTerminal) Make(kind string, arg interface{}) (xelm circuit.X, err error) {
elm, err := x.t.Make(kind, arg)
if err != nil {
return nil, xerrors.Pack(err)
}
return elm.X(), nil
}
func (x XValve) Recv() (circuit.X, error) {
r, err := x.Valve.Recv()
if err != nil {
return nil, errors.Pack(err)
}
return xio.NewXReadCloser(r), nil
}
func (x XValve) Send() (circuit.X, error) {
w, err := x.Valve.Send()
if err != nil {
return nil, errors.Pack(err)
}
return xio.NewXWriteCloser(w), nil
}
func (x XContainer) Peek() (*ds.Stat, error) {
stat, err := x.Container.Peek()
return stat, errors.Pack(err)
}
// Run executes the command and blocks until it completes, akin to os/exec.Cmd.Run
func (x *XCmd) Run() error {
return errors.Pack(x.cmd.Run())
}
func (x XValve) Close() error {
return errors.Pack(x.Valve.Close())
}
func (x XCloser) Close() error {
return errors.Pack(x.Closer.Close())
}
func (x XWriter) Write(p []byte) (int, error) {
n, err := x.Writer.Write(p)
return n, errors.Pack(err)
}
func (x XServer) Rejoin(addr string) error {
return errors.Pack(x.server.Rejoin(addr))
}
// Wait blocks until the process completes, akin to os/exec.Cmd.Wait
func (x *XCmd) Wait() error {
return errors.Pack(x.cmd.Wait())
}
func (x XContainer) Signal(sig string) error {
return errors.Pack(x.Container.Signal(sig))
}
func (x XContainer) Wait() (*ds.Stat, error) {
stat, err := x.Container.Wait()
return stat, errors.Pack(err)
}
func (x XProc) Signal(sig string) error {
return errors.Pack(x.Proc.Signal(sig))
}
func (x XProc) Wait() (Stat, error) {
stat, err := x.Proc.Wait()
return pack(stat), errors.Pack(err)
}
func pack(stat Stat) Stat {
stat.Exit = errors.Pack(stat.Exit)
return stat
}
func (x XNameserver) Set(rr string) error {
err := x.Nameserver.Set(rr)
return errors.Pack(err)
}
func (x XReader) Read(n int) ([]byte, error) {
p := make([]byte, n)
m, err := x.Reader.Read(p)
return p[:m], errors.Pack(err)
}