Provided by: mosh_1.3.2-2.1build1_amd64 bug

NAME

       mosh - mobile shell with roaming and intelligent local echo

SYNOPSIS

       mosh [options] [--] [user@]host [command...]

DESCRIPTION

       mosh   (mobile  shell)  is  a  remote  terminal  application  that  supports  intermittent
       connectivity, allows roaming, and provides speculative local echo and line editing of user
       keystrokes.

       Compared with ssh, mosh is more robust — its connections stay up across sleeps and changes
       in the client's IP address — and more responsive, because  the  protocol  is  tolerant  of
       packet  loss  and  the  client can echo most keystrokes immediately, without waiting for a
       network round-trip.

       mosh uses ssh to establish a connection to the remote host and authenticate with  existing
       means  (e.g.,  public-key  authentication  or  a password). mosh executes the unprivileged
       mosh-server helper program on the server, then closes the SSH connection  and  starts  the
       mosh-client, which establishes a long-lived datagram connection over UDP.

       To  improve  responsiveness,  mosh runs a predictive model of the server's behavior in the
       background, trying to guess  the  effect  of  each  keystroke  on  the  screen.  It  makes
       predictions  for  normal typing, backspace, and the left- and right-arrow keys. When it is
       confident, mosh displays the predictions without waiting for the  server.  The  predictive
       model must prove itself anew on each row of the terminal and after each control character,
       so mosh avoids echoing passwords or non-echoing editor commands.

       By default, mosh shows its predictions only on high-latency connections and to smooth  out
       network  glitches.  (On  longer-latency  links,  the  predicted cells are underlined until
       confirmed by the server.) Occasional echo mistakes are corrected within a  network  round-
       trip and do not cause lasting effect.

       mosh  does  not  support  X  forwarding or the non-interactive uses of SSH, including port
       forwarding or sshfs. mosh works through typical client-side  network  address  translators
       but  requires  UDP  to  pass  between  client  and server. By default, mosh uses the ports
       between 60000 and 61000, but allows the user to request a particular UDP port instead.

       Currently, mosh has limited support  for  IPv6,  dual-stack  networks,  and  servers  with
       multiple addresses.  At session start, it will select a single IPv4 or IPv6 server address
       to connect to for the lifetime of the session.

       mosh will do its best to arrange a UTF-8 character set locale on the  client  and  server.
       The  client  must  have locale-related environment variables that specify UTF-8. mosh will
       pass these client variables to the mosh-server on its command line, but in most cases they
       will  not  need  to  be  used.  mosh-server  first  attempts to use its own locale-related
       environment variables,  which  come  from  the  system  default  configuration  (sometimes
       /etc/default/locale)  or  from  having  been  passed over the SSH connection. But if these
       variables don't call for the use of  UTF-8,  mosh-server  will  apply  the  locale-related
       environment variables from the client and try again.

OPTIONS

       Options  named   --experimental-*  are  subject to change or removal in future versions of
       Mosh; their design or function is not yet final.

       command
              Command to run on remote host. By default, mosh executes a login shell.

       --client=PATH
              path to client helper on local machine (default: "mosh-client")

       --server=COMMAND
              command to run server helper on remote machine (default: "mosh-server")

              The server helper  is  unprivileged  and  can  be  installed  in  the  user's  home
              directory.

              This  option  can  be used to set environment variables for the server by using the
              env(1) command to wrap the actual server command.  See mosh-server(1) for available
              environment variables.

       --ssh=COMMAND
              OpenSSH command to remotely execute mosh-server on remote machine (default: "ssh")

              An alternate ssh port can be specified with, e.g., --ssh="ssh -p 2222".

       --ssh-pty
              --no-ssh-pty Enable or disable ssh's use of a pty when connecting to a remote host.
              The default is enabled.

       --predict=WHEN
              Controls  use  of  speculative  local  echo.  WHEN  defaults  to  `adaptive'  (show
              predictions  on  slower  links  and to smooth out network glitches) and can also be
              `always` or `never'.

              The MOSH_PREDICTION_DISPLAY environment variable controls this setting  permanently
              and can adopt the same three values.

              Even  on  `always',  mosh  will  only  show  predictions when it is confident. This
              generally means a previous prediction on the same row  of  the  terminal  has  been
              confirmed by the server, without any intervening control character keystrokes.

       -a     Synonym for --predict=always

       -n     Synonym for --predict=never

       --family=inet
              Only use IPv4 for the SSH connection and Mosh session.

       --family=inet6
              Only  use  IPv6  for  the  SSH connection and Mosh session.  This and the following
              modes require Perl's IO::Socket::IP or IO::Socket::INET6 modules.

       --family=auto
              Autodetect IPv4 or IPv6 for hosts that only have  addresses  in  a  single  family.
              Hosts  with  both  IPv4  and  IPv6  addresses  will raise an error, and require re-
              invocation of mosh with another --family option.

       --family=all
              Choose an address from all available IPv4 or  IPv6  address,  even  for  dual-stack
              hosts.   This  is the most convenient option, but requires dual-stack connectivity,
              and Mosh 1.2.5 or later on the server, when roaming with dual-stack servers.

       --family=prefer-inet
              Similar to --family=all, but attempt connects to the IPv4 addresses first.  This is
              the default.

       --family=prefer-inet6
              Similar to --family=all, but attempt connects to the IPv6 addresses first.

       -4     Synonym for --family=inet

       -6     Synonym for --family=inet6

       -p PORT[:PORT2], --port=PORT[:PORT2]
              Use  a  particular  server-side UDP port or port range, for example, if this is the
              only port that is forwarded through a firewall to the server. With -p 0, the server
              will  let  the  operating  system  pick an available UDP port. Otherwise, mosh will
              choose a port between 60000 and 61000. Please note that this option does not affect
              the server-side port used by SSH.

       --bind-server={ssh|any|IP}
              Control the IP address that the mosh-server binds to.

              The  default is `ssh', in which case the server will reply from the IP address that
              the SSH connection came from (as found in the SSH_CONNECTION environment variable).
              This is useful for multihomed servers.

              With --bind-server=any, the server will reply on the default interface and will not
              bind to a particular IP address. This can be  useful  if  the  connection  is  made
              through  sslh  or  another  tool  that makes the SSH connection appear to come from
              localhost.

              With --bind-server=IP, the server will attempt to bind to the specified IP address.

       --no-init
              Do not send the smcup initialization string and rmcup  deinitialization  string  to
              the client's terminal. On many terminals this disables alternate screen mode.

       --local
              Invoke  mosh-server  locally,  without  using  ssh.   This option requires the host
              argument to be a local, numeric IPv4/IPv6  address.   This  option  is  useful  for
              testing.

       --experimental-remote-ip={proxy|local|remote}
              Select the method used to discover the IP address that the mosh-client connects to.

              The  default  is proxy, which uses SSH's --ssh-proxy-command option to generate and
              report the exact address that ssh uses to connect to the remote host.  This  option
              is  generally  the  most  compatible with hosts and other options configured in ssh
              configuration files.  However, this may not work for some  configurations,  or  for
              environments  where a ssh bastion host forwards to a remote machine.  It only works
              with OpenSSH.

              With remote, the server's SSH_CONNECTION environment variable will be  used.   This
              is useful for environments where ssh forwarding is used, or the --ssh-proxy-command
              option is used for other purposes.

              With local, Mosh resolves the hostname given on its command  line,  and  uses  that
              address  for  both ssh and Mosh connections.  This option ignores any configuration
              in ssh_config for the same hostname.

ESCAPE SEQUENCES

       The default escape character used by Mosh is ASCII RS (decimal  30).   This  is  typically
       typed  as Ctrl-^ or Ctrl-Shift-6, on US English keyboards.  Users of non-English keyboards
       may find it difficult or impossible to type the default escape character, and may need  to
       change  the  escape  character.   See  the description of MOSH_ESCAPE_KEY, below.  In this
       description, the configured escape character is represented as Esc.

       There are two slightly different modes for escape sequences, depending whether the  escape
       character is printable or not.

       If  the  escape  character  is  a printable character, it must be prefixed with a newline,
       similar to OpenSSH.  To send the escape character itself, type it twice.   If  the  escape
       character is set to ~, mosh will behave much like OpenSSH.

       If  the  escape  character is a non-printable control character, no prefix is used and the
       escape character is recognized at any time.  To send the escape character itself, type the
       escape character, then its corresponding ASCII character (for Ctrl-^ you would type ^, for
       Ctrl-B you would type B).

       The escape sequence to shut down the connection is Esc .. The sequence Esc Ctrl-Z suspends
       the client.  Any other sequence passes both characters through to the server.

ENVIRONMENT VARIABLES

       These  variables are not actually interpreted by mosh(1) itself, but are passed through to
       mosh-server(1).  They are described here for ease of use.

       MOSH_ESCAPE_KEY
              When set, this configures the escape character used for local commands.  The escape
              character  may be set to any ASCII character in the range 1-127.  The variable must
              be set with a single literal ASCII character.  Control characters are set with  the
              actual ASCII control character, not with a printable representation such as "^B".

       MOSH_PREDICTION_DISPLAY
              Controls  local  echo  as  described  above.   The command-line flag overrides this
              variable.

       MOSH_TITLE_NOPREFIX
              When set, inhibits prepending "[mosh]" to window title.

SEE ALSO

       mosh-client(1), mosh-server(1).

       Project home page: https://mosh.org

AUTHOR

       mosh was written by Keith Winstein <mosh-devel@mit.edu>.

BUGS

       Please  report  bugs  to  mosh-devel@mit.edu.  Users  may  also  subscribe  to  the  mosh-
       users@mit.edu mailing list, at
       http://mailman.mit.edu/mailman/listinfo/mosh-users

                                            April 2013                                    MOSH(1)