func ExampleClient_Listen() { config := &ssh.ClientConfig{ User: "******", Auth: []ssh.AuthMethod{ ssh.Password("password"), }, } // Dial your ssh server. conn, err := ssh.Dial("tcp", "localhost:22", config) if err != nil { log.Fatalf("unable to connect: %s", err) } defer conn.Close() // Request the remote side to open port 8080 on all interfaces. l, err := conn.Listen("tcp", "0.0.0.0:8080") if err != nil { log.Fatalf("unable to register tcp forward: %v", err) } defer l.Close() // Serve HTTP with your SSH server acting as a reverse proxy. http.Serve(l, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) { fmt.Fprintf(resp, "Hello world!\n") })) }
func ExampleSession_RequestPty() { // Create client config config := &ssh.ClientConfig{ User: "******", Auth: []ssh.AuthMethod{ ssh.Password("password"), }, } // Connect to ssh server conn, err := ssh.Dial("tcp", "localhost:22", config) if err != nil { log.Fatalf("unable to connect: %s", err) } defer conn.Close() // Create a session session, err := conn.NewSession() if err != nil { log.Fatalf("unable to create session: %s", err) } defer session.Close() // Set up terminal modes modes := ssh.TerminalModes{ ssh.ECHO: 0, // disable echoing ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud } // Request pseudo terminal if err := session.RequestPty("xterm", 80, 40, modes); err != nil { log.Fatalf("request for pseudo terminal failed: %s", err) } // Start remote shell if err := session.Shell(); err != nil { log.Fatalf("failed to start shell: %s", err) } }
func ExampleDial() { // An SSH client is represented with a ClientConn. Currently only // the "password" authentication method is supported. // // To authenticate with the remote server you must pass at least one // implementation of AuthMethod via the Auth field in ClientConfig. config := &ssh.ClientConfig{ User: "******", Auth: []ssh.AuthMethod{ ssh.Password("yourpassword"), }, } client, err := ssh.Dial("tcp", "yourserver.com:22", config) if err != nil { panic("Failed to dial: " + err.Error()) } // Each ClientConn can support multiple interactive sessions, // represented by a Session. session, err := client.NewSession() if err != nil { panic("Failed to create session: " + err.Error()) } defer session.Close() // Once a Session is created, you can execute a single command on // the remote side using the Run method. var b bytes.Buffer session.Stdout = &b if err := session.Run("/usr/bin/whoami"); err != nil { panic("Failed to run: " + err.Error()) } fmt.Println(b.String()) }
func connect(ctx *cli.Context) { if len(ctx.Args()) != 1 { log.Fatal("Error: Must provide name of droplet.") } name := ctx.Args().First() tokenSource := &TokenSource{ AccessToken: APIKey, } oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource) client := godo.NewClient(oauthClient) droplet, err := FindDropletByName(client, name) if err != nil { log.Fatal(err) } var ip string for _, n := range droplet.Networks.V4 { if n.Type == "public" { ip = n.IPAddress } } endpoint := fmt.Sprintf("%s:%d", ip, 22) methods, err := authMethods(ctx) if err != nil { log.Fatal(err) } user := "******" if strings.Contains(droplet.Image.Slug, "coreos") { user = "******" } c := &ssh.ClientConfig{ User: user, Auth: methods, } conn, err := ssh.Dial("tcp", endpoint, c) if err != nil { log.Fatal("Unable to connect.", err.Error()) } session, err := conn.NewSession() if err != nil { log.Fatal(err.Error()) } session.Stdout = os.Stdout session.Stderr = os.Stderr session.Stdin = os.Stdin defer session.Close() modes := ssh.TerminalModes{ ssh.ECHO: 1, } fd := os.Stdin.Fd() var ( termWidth, termHeight int ) if term.IsTerminal(fd) { oldState, err := term.MakeRaw(fd) if err != nil { log.Fatal(err) } defer term.RestoreTerminal(fd, oldState) winsize, err := term.GetWinsize(fd) if err != nil { termWidth = 80 termHeight = 24 } else { termWidth = int(winsize.Width) termHeight = int(winsize.Height) } } if err := session.RequestPty("xterm", termWidth, termHeight, modes); err != nil { session.Close() log.Fatalf("request for pseudo terminal failed: %s", err) } if err == nil { err = session.Shell() } if err != nil { log.Fatal(err) } 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 } log.Fatal(err) } }