Jtdcftul

SSH sessions may break due to numerous and possibly unavoidable reasons.

A useful utility which can be used to mitigate problems caused by this is called screen. Screen is a powerful utility that allows you to control multiple terminals which will stay alive independently of the ssh session. For example, if you run screen in an ssh session you will see a new terminal open and you can use that to run jobs. Lets say your ssh session dies in the process. Running screen -d then screen -r will reopen the last session and you will be able to continue from there. Make sure you read some of the documentation before using it.

Client configuration

Try creating the file:

~/.ssh/config

Add the contents:

Host *

  ServerAliveInterval 30

  ServerAliveCountMax 5

Now ssh to your server and see if your problem is fixed. ClientAliveInterval option is only useful when configuring the ssh server (aka sshd), it does not change a thing on the ssh client side, so don't use it in the above configuration file.

This will send a hello-are-you-there signal to the server if no packets have been received in the preceding 30 seconds (as specified above). However, if the number of consecutive hello-are-you-there signals reach ServerAliveCountMax then ssh will disconnect from the server. This value is defaulting to 3 (so 3*30 = 90 seconds without server activity), increase it if it suits your needs. There are alot more config options to the .ssh/config file and you could read:

Using an SSH Config File

For more information on other options. You may not want to apply this to every server you connect to which this example will. Or restrain it to only a particular server by replacing the line Host * with Host <IP> (replace by an IP address, see ssh_config man page).

Server configuration

Similarly you can tell the server to be gentle with your clients. The configuration file is /etc/ssh/sshd_config.

ClientAliveInterval 20

ClientAliveCountMax 5

You can either deactivate it by setting ClientAliveInterval to 0 or tweak ClientAliveInterval and ClientAliveCountMax to set a maximum ssh client inactivity without responding to the probes. One advantage of this settings over TCPKeepAlive is that the signals are sent through the encrypted channels, so it is less likely to be spoofable.

I'm remotely upgrading an Ubuntu server from lucid to precise and lost the ssh connection in the middle of the upgrade with the message "Write failed. Brocken pipe". ClientAliveInterval and ServerAliveInterval did nothing. The solution is to turn on TCPKeepAlive options in client ssh:

TCPKeepAlive yes

in

/etc/ssh/ssh_config

For the client, edit your ~/.ssh/config (or /etc/ssh/ssh_config) file as follow:

Host *

  TCPKeepAlive yes

  ServerAliveInterval 120

TCPKeepAlive - Specifies whether the system should send TCP keepalive
messages to the other side. If they are sent, death of the connection
or crash of one of the machines will be properly noticed. However,
this means that connections will die if the route is down temporarily,
and some people find it annoying (The default is 'yes').

ServerAliveInterval - Sets a timeout interval in seconds after which
if no data has been received from the server, ssh(1) will send a
message through the encrypted channel to request a response from the
server. The default is 0, indicating that these messages will not be
sent to the server.

For the server, edit your /etc/ssh/sshd_config as:

ClientAliveInterval 600

ClientAliveCountMax 0

If you want ssh client to exit (timeout) automatically after 10 minutes (600 seconds).

ClientAliveCountMax – This indicates the total number of checkalive
message sent by the ssh server without getting any response from the
ssh client. Default is 3.

ClientAliveInterval – This indicates the timeout in seconds. After x
number of seconds, ssh server will send a message to the client asking
for response. Deafult is 0 (server will not send message to client to
check.).

See also: What do the options ServerAliveInterval and ClientAliveInterval in sshd_config do, precisely?

I absolutely love Mosh. I frequently ssh into a server, close my laptop and go to a cafe, open it up and carry on as if nothing changed.

Mosh (mobile shell)

Remote terminal application that allows roaming, supports intermittent
connectivity, and provides intelligent local
echo and line editing of user keystrokes.

Mosh is a replacement for SSH. It's more robust and responsive,
especially over Wi-Fi, cellular, and long-distance links.

Mosh is free software, available for GNU/Linux, FreeBSD, Solaris, Mac OS X, and Android.

For me, I was getting Write failed: Broken pipe even when I was actively typing in vim or at the shell prompt. I couldn't browse the internet locally either for awhile either. (I was connecting remotely to Ubuntu using Terminal.)

Others in my network stream a lot of video from Netflix and other places. I can't prove it, but I suspect its an ISP or router issue. For example, Verizon and Netflix are pointing fingers at each other for their customer's network problems.

If you've got a dial-up connection and are streaming video or music with a simultaneous SSH or telnet connection, it's inevitable at some point you'll get a broken pipe message. Upgrading my ISPs broadband package seemed to make my broken connection less frequent.

I have a script on the remote server that never seems to fails, regardless of the SSH configuration client or server.

#!/bin/bash

while true; do date; sleep 10; done;

Save it to some dummy.sh file and quickly run it before you minimize the window or move away from it. It will keep printing the current time stamp on the server and keeps your connection alive as long as the connection is not dropped by any other reason. When you get back to that terminal, just hit CTRL+C and keep working.

You can add these args every time you invoke ssh: -o ServerAliveInterval=15 -o ServerAliveCountMax=3

You don't have to edit /etc/ssh/*config files if you do this.

You can create an bash alias or function or script to make this easy.

E.g. these bash functions, you can add into your .bashrc, do_ssh is used manually to turn on keepalives. do_ssh_pty is used within scripts to set pty and avoid prompts.

do_ssh() {

    ssh -o ServerAliveInterval=15 -o ServerAliveCountMax=3 $*

}



do_ssh_pty() {

    ssh -tt -o "BatchMode=yes" -o "StrictHostKeyChecking=no" -o ServerAliveInterval=15 -o ServerAliveCountMax=3 $*

}

Now do_ssh user@host can be used or do_ssh user@host <args> <command> and keepalives will be active.

I posted my answer here, as it was not a Ubuntu VM.

https://unix.stackexchange.com/questions/259225/packet-write-wait-broken-pipe-even-leaving-top-running

ssh -o IPQoS=throughput user@host