```
func waitPts(ctx *VmContext) {
        conn, err := UnixSocketConnect(ctx.TtySockName)
        if err != nil {
                glog.Error("Cannot connect to tty socket ", err.Error())
                ctx.Hub <- &InitFailedEvent{
                        Reason: "Cannot connect to tty socket " + err.Error(),
                }
                return
        }

        glog.V(1).Info("tty socket connected")

        go waitTtyMessage(ctx, conn.(*net.UnixConn))
        for {
                res, err := readTtyMessage(conn.(*net.UnixConn))
                if err != nil {
                        glog.V(1).Info("tty socket closed, quit the reading goroutine ", err.Error())
                        ctx.Hub <- &Interrupted{Reason: "tty socket failed " + err.Error()}
                        close(ctx.ptys.channel)
                        return
                }
                if ta, ok := ctx.ptys.ttys[res.session]; ok {
                        if len(res.message) == 0 {
                                glog.V(1).Infof("session %d closed by peer, close pty", res.session)
                                ctx.ptys.Close(ctx, res.session)
                        } else {
                                for _, tty := range ta.attachments {
                                        if tty.Stdout != nil {
                                                _, err := tty.Stdout.Write(res.message)
                                                if err != nil {
                                                        glog.V(1).Infof("fail to write session %d, close pty attachment", res.session)
                                                        ctx.ptys.Detach(ctx, res.session, tty)
                                                }
                                        }
                                }
                        }
                }
        }
}
```