func (c *cliClient) Start() { oldState, err := terminal.MakeRaw(0) if err != nil { panic(err.Error()) } defer terminal.Restore(0, oldState) signal.Notify(make(chan os.Signal), os.Interrupt) wrapper, interruptChan := NewTerminalWrapper(os.Stdin) wrapper.SetErrorOnInterrupt(true) c.interrupt = interruptChan c.termWrapper = wrapper c.term = terminal.NewTerminal(wrapper, "> ") if width, height, err := terminal.GetSize(0); err == nil { c.term.SetSize(width, height) } c.loadUI() if c.writerChan != nil { c.save() } if c.writerChan != nil { close(c.writerChan) <-c.writerDone } if c.fetchNowChan != nil { close(c.fetchNowChan) } if c.stateLock != nil { c.stateLock.Close() } }
func updateTerminalSize(term *terminal.Terminal) { width, height, err := terminal.GetSize(0) if err != nil { return } term.SetSize(width, height) }
// makeSession initializes a gossh.Session connected to the invoking process's stdout/stderr/stdout. // If the invoking session is a terminal, a TTY will be requested for the SSH session. // It returns a gossh.Session, a finalizing function used to clean up after the session terminates, // and any error encountered in setting up the session. func makeSession(client *SSHForwardingClient) (session *gossh.Session, finalize func(), err error) { session, err = client.NewSession() if err != nil { return } if err = client.ForwardAgentAuthentication(session); err != nil { return } session.Stdout = os.Stdout session.Stderr = os.Stderr session.Stdin = os.Stdin modes := gossh.TerminalModes{ gossh.ECHO: 1, // enable echoing gossh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud gossh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud } fd := int(os.Stdin.Fd()) if terminal.IsTerminal(fd) { var termWidth, termHeight int var oldState *terminal.State oldState, err = terminal.MakeRaw(fd) if err != nil { return } finalize = func() { session.Close() terminal.Restore(fd, oldState) } termWidth, termHeight, err = terminal.GetSize(fd) if err != nil { return } err = session.RequestPty("xterm-256color", termHeight, termWidth, modes) } else { finalize = func() { session.Close() } } return }
func ui(startTime time.Time, nf int, c <-chan uiMsg, done chan<- struct{}) { defer close(done) var fileDoneCount int var bytes, lastBytes uint64 lastTime := startTime p := func(m string, nl bool) { if terminal.IsTerminal(syscall.Stdout) { width := defaultTerminalWidth if w, _, err := terminal.GetSize(syscall.Stdout); err == nil { width = w } fmt.Printf("\r%-*s\r%s", width-1, "", m) } else { fmt.Print(m) } if nl { fmt.Printf("\n") } } for msg := range c { now := time.Now() if msg.bytes != nil { bytes = *msg.bytes } if msg.msg != nil { p(*msg.msg, true) } if msg.fileDone != nil { if *verbose { p(fmt.Sprintf("Done: %q", path.Base(*msg.fileDone)), true) } fileDoneCount++ } elapsed := now.Sub(startTime) p(fmt.Sprintf("%d/%d files. %d workers. %sB in %s = %sBps. Current: %sBps", fileDoneCount, nf, *numWorkers, humanize(float64(bytes), 3), roundSeconds(elapsed), humanize(float64(bytes)/elapsed.Seconds(), 1), humanize(float64(bytes-lastBytes)/now.Sub(lastTime).Seconds(), 1), ), false) lastBytes = bytes lastTime = now } fmt.Printf("\n") }
func repoString(u string, s int, l string) string { url := strings.TrimPrefix(u, "https://github.com/") w, _, _ := terminal.GetSize(0) urlLen := utf8.RuneCountInString(url) starLen := utf8.RuneCountInString(strconv.Itoa(s)) langLen := utf8.RuneCountInString(l) // If the terminal has no width return an unformatted string if w < 1 { return fmt.Sprintf("%s %d %s\n", url, s, l) } spaceLen := w - urlLen - starLen - langLen - 1 if spaceLen < 1 { spaceLen := w - starLen - langLen - 1 spaces := strings.Repeat(" ", spaceLen) return fmt.Sprintf("%s\n%s%d %s\n", url, spaces, s, l) } spaces := strings.Repeat(" ", spaceLen) return fmt.Sprintf("%s%s%d %s\n", url, spaces, s, l) }
// returns a progress bar fitting the terminal width given a progress percentage func ProgressBar(progress int) (progressBar string) { var width int if runtime.GOOS == "windows" { // we'll just assume it's standard terminal width width = 80 } else { width, _, _ = terminal.GetSize(0) } // take off 26 for extra info (e.g. percentage) width = width - 26 // get the current progress currentProgress := (progress * width) / 100 progressBar = "[" // fill up progress for i := 0; i < currentProgress; i++ { progressBar = progressBar + "=" } progressBar = progressBar + ">" // fill the rest with spaces for i := width; i > currentProgress; i-- { progressBar = progressBar + " " } // end the progressbar progressBar = progressBar + "] " + fmt.Sprintf("%3d", progress) + "%%" return progressBar }
func main() { flag.Parse() oldState, err := terminal.MakeRaw(0) if err != nil { panic(err.Error()) } defer terminal.Restore(0, oldState) term := terminal.NewTerminal(os.Stdin, "> ") if width, height, err := terminal.GetSize(0); err == nil { term.SetSize(width, height) } if len(*configFile) == 0 { homeDir := os.Getenv("HOME") if len(homeDir) == 0 { homeDir = "/" } *configFile = homeDir + "/.xmpp-client" } config, err := ParseConfig(*configFile) if err != nil { alert(term, "Failed to parse config file: "+err.Error()) config = new(Config) if !enroll(config, term) { return } config.filename = *configFile config.Save() } password := config.Password if len(password) == 0 { if password, err = term.ReadPassword(fmt.Sprintf("Password for %s (will not be saved to disk): ", config.Account)); err != nil { alert(term, "Failed to read password: "******"@", 2) if len(parts) != 2 { alert(term, "invalid username (want user@domain): "+config.Account) return } user := parts[0] domain := parts[1] var addr string addrTrusted := false if len(config.Server) > 0 && config.Port > 0 { addr = fmt.Sprintf("%s:%d", config.Server, config.Port) addrTrusted = true } else { if len(config.Proxies) > 0 { alert(term, "Cannot connect via a proxy without Server and Port being set in the config file as an SRV lookup would leak information.") return } host, port, err := xmpp.Resolve(domain) if err != nil { alert(term, "Failed to resolve XMPP server: "+err.Error()) return } addr = fmt.Sprintf("%s:%d", host, port) } var dialer proxy.Dialer for i := len(config.Proxies) - 1; i >= 0; i-- { u, err := url.Parse(config.Proxies[i]) if err != nil { alert(term, "Failed to parse "+config.Proxies[i]+" as a URL: "+err.Error()) return } if dialer == nil { dialer = proxy.Direct } if dialer, err = proxy.FromURL(u, dialer); err != nil { alert(term, "Failed to parse "+config.Proxies[i]+" as a proxy: "+err.Error()) return } } xmppConfig := &xmpp.Config{ Log: &lineLogger{term, nil}, Create: *createAccount, TrustedAddress: addrTrusted, Archive: false, } if len(config.RawLogFile) > 0 { rawLog, err := os.OpenFile(config.RawLogFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600) if err != nil { alert(term, "Failed to open raw log file: "+err.Error()) return } lock := new(sync.Mutex) in := rawLogger{ out: rawLog, prefix: []byte("<- "), lock: lock, } out := rawLogger{ out: rawLog, prefix: []byte("-> "), lock: lock, } in.other, out.other = &out, &in xmppConfig.InLog = &in xmppConfig.OutLog = &out defer in.flush() defer out.flush() } if dialer != nil { info(term, "Making connection to "+addr+" via proxy") if xmppConfig.Conn, err = dialer.Dial("tcp", addr); err != nil { alert(term, "Failed to connect via proxy: "+err.Error()) return } } conn, err := xmpp.Dial(addr, user, domain, password, xmppConfig) if err != nil { alert(term, "Failed to connect to XMPP server: "+err.Error()) return } s := Session{ account: config.Account, conn: conn, term: term, conversations: make(map[string]*otr.Conversation), knownStates: make(map[string]string), privateKey: new(otr.PrivateKey), config: config, pendingRosterChan: make(chan *rosterEdit), pendingSubscribes: make(map[string]string), lastActionTime: time.Now(), } info(term, "Fetching roster") //var rosterReply chan xmpp.Stanza rosterReply, _, err := s.conn.RequestRoster() if err != nil { alert(term, "Failed to request roster: "+err.Error()) return } conn.SignalPresence("") s.input = Input{ term: term, uidComplete: new(priorityList), } commandChan := make(chan interface{}) go s.input.ProcessCommands(commandChan) stanzaChan := make(chan xmpp.Stanza) go s.readMessages(stanzaChan) s.privateKey.Parse(config.PrivateKey) s.timeouts = make(map[xmpp.Cookie]time.Time) info(term, fmt.Sprintf("Your fingerprint is %x", s.privateKey.Fingerprint())) ticker := time.NewTicker(1 * time.Second) MainLoop: for { select { case now := <-ticker.C: haveExpired := false for _, expiry := range s.timeouts { if now.After(expiry) { haveExpired = true break } } if !haveExpired { continue } newTimeouts := make(map[xmpp.Cookie]time.Time) for cookie, expiry := range s.timeouts { if now.After(expiry) { s.conn.Cancel(cookie) } else { newTimeouts[cookie] = expiry } } s.timeouts = newTimeouts case edit := <-s.pendingRosterChan: if !edit.isComplete { info(s.term, "Please edit "+edit.fileName+" and run /rostereditdone when complete") s.pendingRosterEdit = edit continue } if s.processEditedRoster(edit) { s.pendingRosterEdit = nil } else { alert(s.term, "Please reedit file and run /rostereditdone again") } case rosterStanza, ok := <-rosterReply: if !ok { alert(s.term, "Failed to read roster: "+err.Error()) return } if s.roster, err = xmpp.ParseRoster(rosterStanza); err != nil { alert(s.term, "Failed to parse roster: "+err.Error()) return } for _, entry := range s.roster { s.input.AddUser(entry.Jid) } info(s.term, "Roster received") case cmd, ok := <-commandChan: if !ok { warn(term, "Exiting because command channel closed") break MainLoop } s.lastActionTime = time.Now() switch cmd := cmd.(type) { case quitCommand: for to, conversation := range s.conversations { msgs := conversation.End() for _, msg := range msgs { s.conn.Send(to, string(msg)) } } break MainLoop case versionCommand: replyChan, cookie, err := s.conn.SendIQ(cmd.User, "get", xmpp.VersionQuery{}) if err != nil { alert(s.term, "Error sending version request: "+err.Error()) continue } s.timeouts[cookie] = time.Now().Add(5 * time.Second) go s.awaitVersionReply(replyChan, cmd.User) case rosterCommand: info(s.term, "Current roster:") maxLen := 0 for _, item := range s.roster { if maxLen < len(item.Jid) { maxLen = len(item.Jid) } } for _, item := range s.roster { line := " " line += item.Jid numSpaces := 1 + (maxLen - len(item.Jid)) for i := 0; i < numSpaces; i++ { line += " " } line += item.Subscription + "\t" + item.Name if state, ok := s.knownStates[item.Jid]; ok { line += "\t" + state } info(s.term, line) } case rosterEditCommand: if s.pendingRosterEdit != nil { warn(s.term, "Aborting previous roster edit") s.pendingRosterEdit = nil } rosterCopy := make([]xmpp.RosterEntry, len(s.roster)) copy(rosterCopy, s.roster) go s.editRoster(rosterCopy) case rosterEditDoneCommand: if s.pendingRosterEdit == nil { warn(s.term, "No roster edit in progress. Use /rosteredit to start one") continue } go s.loadEditedRoster(*s.pendingRosterEdit) case confirmCommand: s.handleConfirmOrDeny(cmd.User, true /* confirm */) case denyCommand: s.handleConfirmOrDeny(cmd.User, false /* deny */) case addCommand: s.conn.SendPresence(cmd.User, "subscribe", "" /* generate id */) case msgCommand: conversation, ok := s.conversations[cmd.to] var msgs [][]byte message := []byte(cmd.msg) // Automatically tag all outgoing plaintext // messages with a whitespace tag that // indicates that we support OTR. if config.OTRAutoAppendTag && (!bytes.Contains(message, []byte("?OTR"))) { message = append(message, OTRWhitespaceTag...) } if ok { var err error msgs, err = conversation.Send(message) if err != nil { alert(s.term, err.Error()) break } } else { msgs = [][]byte{[]byte(message)} } for _, message := range msgs { s.conn.Send(cmd.to, string(message)) } case otrCommand: s.conn.Send(string(cmd.User), otr.QueryMessage) case otrInfoCommand: info(term, fmt.Sprintf("Your OTR fingerprint is %x", s.privateKey.Fingerprint())) for to, conversation := range s.conversations { if conversation.IsEncrypted() { fpr := conversation.TheirPublicKey.Fingerprint() isVerifiedFingerprint := len(s.config.UserIdForFingerprint(fpr)) > 0 info(s.term, fmt.Sprintf("Secure session with %s underway:", to)) info(s.term, fmt.Sprintf(" Fingerprint for %s: %x", to, fpr)) info(s.term, fmt.Sprintf(" Session ID for %s: %x", to, conversation.SSID)) if isVerifiedFingerprint { info(s.term, fmt.Sprintf(" Identity key for %s is verified", to)) } else { alert(s.term, fmt.Sprintf(" Identity key for %s is not verified. You should use /otr-auth or /otr-authqa to verify their identity", to)) } } } case endOTRCommand: to := string(cmd.User) conversation, ok := s.conversations[to] if !ok { alert(s.term, "No secure session established") break } msgs := conversation.End() for _, msg := range msgs { s.conn.Send(to, string(msg)) } case authQACommand: to := string(cmd.User) conversation, ok := s.conversations[to] if !ok { alert(s.term, "Can't authenticate without a secure conversation established") break } msgs, err := conversation.Authenticate(cmd.Question, []byte(cmd.Secret)) if err != nil { alert(s.term, "Error while starting authentication with "+to+": "+err.Error()) } for _, msg := range msgs { s.conn.Send(to, string(msg)) } } case rawStanza, ok := <-stanzaChan: if !ok { warn(term, "Exiting because channel to server closed") break MainLoop } switch stanza := rawStanza.Value.(type) { case *xmpp.ClientMessage: s.processClientMessage(stanza) case *xmpp.ClientPresence: s.processPresence(stanza) case *xmpp.ClientIQ: if stanza.Type != "get" && stanza.Type != "set" { continue } reply := s.processIQ(stanza) if reply == nil { reply = xmpp.ErrorReply{ Type: "cancel", Error: xmpp.ErrorBadRequest{}, } } if err := s.conn.SendIQReply(stanza.From, "result", stanza.Id, reply); err != nil { alert(term, "Failed to send IQ message: "+err.Error()) } default: info(term, fmt.Sprintf("%s %s", rawStanza.Name, rawStanza.Value)) } } } os.Stdout.Write([]byte("\n")) }
// Shell opens a shell connection on the servives ssh address. func Shell(app *schemas.Application, service *schemas.Service) error { // Make sure we're in raw mode. termState, err := terminal.MakeRaw(int(os.Stdin.Fd())) if err != nil { if prompt.IsNotTerminal(err) { return errors.ErrIORedirection } return errors.NewStackError(err) } defer terminal.Restore(int(os.Stdin.Fd()), termState) // Get terminal size. cols, rows, err := terminal.GetSize(int(os.Stdout.Fd())) if err != nil { if prompt.IsNotTerminal(err) { return errors.ErrIORedirection } return errors.NewStackError(err) } // Open an SSH connection to the address. config := &ssh.ClientConfig{User: "******", Auth: []ssh.AuthMethod{ ssh.Password("password"), }} client, err := ssh.Dial("tcp", service.SSHAddr, config) if err != nil { return errors.NewStackError(err) } defer client.Close() // Start a session on the client. session, err := client.NewSession() if err != nil { return errors.NewStackError(err) } defer session.Close() session.Stdout = prompt.NewAnsiWriter(os.Stdout) session.Stderr = prompt.NewAnsiWriter(os.Stderr) // Create a stdin pipe copying os.Stdin to it. stdin, err := session.StdinPipe() if err != nil { return errors.NewStackError(err) } defer stdin.Close() go func() { io.Copy(stdin, prompt.NewAnsiReader(os.Stdin)) }() log.Println("magenta", "Welcome to Bowery Services.") log.Println("magenta", "---------------------------------------------") log.Println("magenta", "Name:", service.Name) log.Println("magenta", "Application:", app.ID) log.Println("magenta", "Time:", time.Now()) log.Println("magenta", "---------------------------------------------") // Start a shell session. termModes := ssh.TerminalModes{ ssh.ECHO: 1, ssh.TTY_OP_ISPEED: 14400, ssh.TTY_OP_OSPEED: 14400, } err = session.RequestPty("xterm", rows, cols, termModes) if err == nil { err = session.Shell() } if err != nil { return errors.NewStackError(err) } // Wait for the session. err = session.Wait() if err != nil && err != io.EOF { // Ignore the error if it's an ExitError with an empty message, // this occurs when you do CTRL+c and then run exit cmd which isn't an // actual error. waitMsg, ok := err.(*ssh.ExitError) if ok && waitMsg.Msg() == "" { return nil } return errors.NewStackError(err) } return nil }