GNU Info

(tramp)Default Method

---

Next: Customizing Methods Prev: Multi-hop Methods Up: Configuration

---

Enter node , (file) or (file)node

Selecting a default method
==========================

When you select an appropriate transfer method for your typical usage
you should set the variable `tramp-default-method' to reflect that
choice.  This variable controls which method will be used when a method
is not specified in the TRAMP file name.  For example:

     (setq tramp-default-method "scp")

   You can also specify different methods for certain user/host
combinations, via the variable `tramp-default-method-alist'.  For
example, the following two lines specify to use the `ssh' method for
all user names matching `john' and the `rsync' method for all host
names matching `lily'.  The third line specifies to use the `su' method
for the user `root' on the machine `localhost'.

     (add-to-list 'tramp-default-method-alist '("" "john" "ssh"))
     (add-to-list 'tramp-default-method-alist '("lily" "" "rsync"))
     (add-to-list 'tramp-default-method-alist
                  '("\\`localhost\\'" "\\`root\\'" "su"))

See the documentation for the variable `tramp-default-method-alist' for
more details.

   External transfer methods are normally preferable to inline transfer
methods, giving better performance. They may not be useful if you use
many remote machines where you cannot log in without a password.

   Note: Inline methods.  Note: External transfer methods.  Note:
Multi-hop Methods.

   Another consideration with the selection of transfer methods is the
environment you will use them in and, especially when used over the
Internet, the security implications of your preferred method.

   The `rsh' and `telnet' methods send your password as plain text as
you log in to the remote machine, as well as transferring the files in
such a way that the content can easily be read from other machines.

   If you need to connect to remote systems that are accessible from the
Internet, you should give serious thought to using `ssh' based methods
to connect. These provide a much higher level of security, making it a
non-trivial exercise for someone to obtain your password or read the
content of the files you are editing.

Which method is the right one for me?
-------------------------------------

Given all of the above, you are probably thinking that this is all fine
and good, but it's not helping you to choose a method!  Right you are.
As a developer, we don't want to boss our users around but give them
maximum freedom instead.  However, the reality is that some users would
like to have some guidance, so here I'll try to give you this guidance
without bossing you around.  You tell me whether it works ...

   My suggestion is to use an inline method.  For large files,
out-of-band methods might be more efficient, but I guess that most
people will want to edit mostly small files.

   I guess that these days, most people can access a remote machine by
using `ssh'.  So I suggest that you use the `ssh' method.  So, type
`C-x C-f /ssh:root@otherhost:/etc/motd <RET>' to edit the `/etc/motd'
file on the other host.

   If you can't use `ssh' to log in to the remote host, then select a
method that uses a program that works.  For instance, Windows users
might like the `plink' method which uses the PuTTY implementation of
`ssh'.  Or you use Kerberos and thus like `krlogin'.

   For the special case of editing files on the local host as another
user, see the `su' or `sudo' method.

   People who edit large files may want to consider `scp' instead of
`ssh', or `pscp' instead of `plink'.  These out-of-band methods are
faster than inline methods for large files.  Note, however, that
out-of-band methods suffer from some limitations.  Please try first
whether you really get a noticeable speed advantage from using an
out-of-band method!  Maybe even for large files, inline methods are
fast enough.

   The reason why I'm suggesting to use inline methods is that they work
even if the remote end is asking you for a password.  Out-of-band
methods don't work in this situation.  Also, multi-hop methods are
inherently inline.