4. Configuring TRAMP for use

TRAMP is (normally) fully functional when it is initially installed. It is initially configured to use the scp program to connect to the remote host. So in the easiest case, you just type C-x C-f and then enter the filename `/[user@machine]/path/to.file'.

On some hosts, there are problems with opening a connection. These are related to the behavior of the remote shell. See See section 4.10 Remote shell setup hints, for details on this.

If you do not wish to use these commands to connect to the remote host, you should change the default connection and transfer method that TRAMP uses. There are several different methods that TRAMP can use to connect to remote machines and transfer files (see section 4.1 Types of connections made to remote machines.).

If you don't know which method is right for you, see See section 4.5 Selecting a default method.

4.1 Types of connections made to remote machines.

There are two basic types of transfer methods, each with its own advantages and limitations. Both types of connection make use of a remote shell access program such as rsh, ssh or telnet to connect to the remote machine.

This connection is used to perform many of the operations that TRAMP requires to make the remote file system transparently accessible from the local machine. It is only when visiting files that the methods differ.

Loading or saving a remote file requires that the content of the file be transfered between the two machines. The content of the file can be transfered over the same connection used to log in to the remote machine or the file can be transfered through another connection using a remote copy program such as rcp, scp or rsync. The former are called inline methods, the latter are called out-of-band methods or external transfer methods (external methods for short).

The performance of the external transfer methods is generally better than that of the inline methods, at least for large files. This is caused by the need to encode and decode the data when transferring inline.

The one exception to this rule are the scp based transfer methods. While these methods do see better performance when actually transferring files, the overhead of the cryptographic negotiation at startup may drown out the improvement in file transfer times.

External transfer methods should be configured such a way that they don't require a password (with ssh-agent, or such alike). If it isn't possible, you should consider 4.8 Reusing passwords for several connections., otherwise you will be prompted for a password every copy action.

A variant of the inline methods are the multi-hop methods. These methods allow you to connect a remote host using a number `hops', each of which connects to a different host. This is useful if you are in a secured network where you need to go through a bastion host to connect to the outside world.

4.2 Inline methods

The inline methods in TRAMP are quite powerful and can work in situations where you cannot use an external transfer program to connect. Inline methods are the only methods that work when connecting to the remote machine via telnet. (There are also strange inline methods which allow you to transfer files between user identities rather than hosts, see below.)

These methods depend on the existence of a suitable encoding and decoding command on remote machine. Locally, TRAMP may be able to use features of XEmacs to decode and encode the files or it may require access to external commands to perform that task.

TRAMP checks the availability and usability of commands like mimencode (part of the metamail package) or uuencode on the remote host. The first reliable command will be used. The search path can be customized, see 4.9 How TRAMP finds and uses programs on the remote machine..

If both commands aren't available on the remote host, TRAMP transfers a small piece of Perl code to the remote host, and tries to apply it for encoding and decoding.

`rsh'

Connect to the remote host with rsh. Due to the unsecure connection it is recommended for very local host topology only.

On operating systems which provide the command remsh instead of rsh, you can use the method `remsh'. This is true for HP-UX or Cray UNICOS, for example.

`ssh'

Connect to the remote host with ssh. This is identical to the previous option except that the ssh package is used, making the connection more secure.

There are also two variants, `ssh1' and `ssh2', that call `ssh -1' and `ssh -2', respectively. This way, you can explicitly select whether you want to use the SSH protocol version 1 or 2 to connect to the remote host. (You can also specify in `~/.ssh/config', the SSH configuration file, which protocol should be used, and use the regular `ssh' method.)

Two other variants, `ssh1_old' and `ssh2_old', use the ssh1 and ssh2 commands explicitly. If you don't know what these are, you do not need these options.

All the methods based on ssh have an additional kludgy feature: you can specify a host name which looks like `host#42' (the real host name, then a hash sign, then a port number). This means to connect to the given host but to also pass -p 42 as arguments to the ssh command.

`telnet'

Connect to the remote host with telnet. This is as unsecure as the `rsh' method.

`su'

This method does not connect to a remote host at all, rather it uses the su program to allow you to edit files as another user.

`sudo'

This is similar to the `su' method, but it uses sudo rather than su to become a different user.

Note that sudo must be configured to allow you to start a shell as the user. It would be nice if it was sufficient if ls and mimencode were allowed, but that is not easy to implement, so I haven't got around to it, yet.

`sshx'

As you would expect, this is similar to `ssh', only a little different. Whereas `ssh' opens a normal interactive shell on the remote host, this option uses `ssh -t -t host -l user /bin/sh' to open a connection. This is useful for users where the normal login shell is set up to ask them a number of questions when logging in. This procedure avoids these questions, and just gives TRAMP a more-or-less `standard' login shell to work with.

Note that this procedure does not eliminate questions asked by ssh itself. For example, ssh might ask "Are you sure you want to continue connecting?" if the host key of the remote host is not known. TRAMP does not know how to deal with such a question (yet), therefore you will need to make sure that you can log in without such questions.

This is also useful for Windows users where ssh, when invoked from an XEmacs buffer, tells them that it is not allocating a pseudo tty. When this happens, the login shell is wont to not print any shell prompt, which confuses TRAMP mightily. For reasons unknown, some Windows ports for ssh require the doubled `-t' option.

This supports the `-p' kludge.

`krlogin'

This method is also similar to `ssh'. It only uses the krlogin -x command to log in to the remote host.

`plink'

This method is mostly interesting for Windows users using the PuTTY implementation of SSH. It uses `plink -ssh' to log in to the remote host.

Additionally, the method `plink1' is provided, which calls `plink -1 -ssh' in order to use SSH protocol version 1 explicitly.

CCC: Do we have to connect to the remote host once from the command line to accept the SSH key? Maybe this can be made automatic?

CCC: Does plink support the `-p' option? TRAMP will support that, anyway.

4.3 External transfer methods

The external transfer methods operate through multiple channels, using the remote shell connection for many actions while delegating file transfers to an external transfer utility.

This saves the overhead of encoding and decoding that multiplexing the transfer through the one connection has with the inline methods.

If you want to use an external transfer method you should be able to execute the transfer utility to copy files to and from the remote machine without any interaction.

This means that you will need to use ssh-agent if you use the scp program for transfers, or maybe your version of scp accepts a password on the command line.(2) If you use rsync via ssh then the same rule must apply to that connection.

If you cannot get an external method to run without asking for a password you should consider 4.8 Reusing passwords for several connections..

`rcp' -- rsh and rcp

This method uses the rsh and rcp commands to connect to the remote machine and transfer files. This is probably the fastest connection method available.

The alternative method `remcp' uses the remsh and rcp commands. It should be applied on machines where remsh is used instead of rsh.

`scp' -- ssh and scp

Using ssh to connect to the remote host and scp to transfer files between the machines is the best method for securely connecting to a remote machine and accessing files.

The performance of this option is also quite good. It may be slower than the inline methods when you often open and close small files however. The cost of the cryptographic handshake at the start of an scp session can begin to absorb the advantage that the lack of encoding and decoding presents.

There are also two variants, `scp1' and `scp2', that call `ssh -1' and `ssh -2', respectively. This way, you can explicitly select whether you want to use the SSH protocol version 1 or 2 to connect to the remote host. (You can also specify in `~/.ssh/config', the SSH configuration file, which protocol should be used, and use the regular `scp' method.)

Two other variants, `scp1_old' and `scp2_old', use the ssh1 and ssh2 commands explicitly. If you don't know what these are, you do not need these options.

All the ssh based methods support the kludgy `-p' feature where you can specify a port number to connect to in the host name. For example, the host name `host#42' tells TRAMP to specify `-p 42' in the argument list for ssh.

`rsync' -- ssh and rsync

Using the ssh command to connect securely to the remote machine and the rsync command to transfer files is almost identical to the `scp' method.

While rsync performs much better than scp when transferring files that exist on both hosts, this advantage is lost if the file exists only on one side of the connection.

The rsync based method may be considerably faster than the rcp based methods when writing to the remote system. Reading files to the local machine is no faster than with a direct copy.

This method supports the `-p' hack.

`scpx' -- ssh and scp

As you would expect, this is similar to `scp', only a little different. Whereas `scp' opens a normal interactive shell on the remote host, this option uses `ssh -t -t host -l user /bin/sh' to open a connection. This is useful for users where the normal login shell is set up to ask them a number of questions when logging in. This procedure avoids these questions, and just gives TRAMP a more-or-less `standard' login shell to work with.

This is also useful for Windows users where ssh, when invoked from an XEmacs buffer, tells them that it is not allocating a pseudo tty. When this happens, the login shell is wont to not print any shell prompt, which confuses TRAMP mightily.

This method supports the `-p' hack.

`scpc' -- ssh and scp

Newer versions of `ssh' (for example OpenSSH 4) offer an option `ControlMaster'. This allows `scp' to reuse an existing `ssh' channel, which increases performance.

Before you use this method, you shall check whether your `ssh' implementation does support this option. Try from the command line

ssh localhost -o ControlMaster=yes

This method supports the `-p' hack.

`pscp' -- plink and pscp

This method is similar to `scp', but it uses the plink command to connect to the remote host, and it uses pscp for transferring the files. These programs are part of PuTTY, an SSH implementation for Windows.

CCC: Does plink support the `-p' hack?

`fcp' -- fsh and fcp

This method is similar to `scp', but it uses the fsh command to connect to the remote host, and it uses fcp for transferring the files. fsh/fcp are a front-end for ssh which allow for reusing the same ssh session for submitting several commands. This avoids the startup overhead of scp (which has to establish a secure connection whenever it is called). Note, however, that you can also use one of the inline methods to achieve a similar effect.

This method uses the command `fsh host -l user /bin/sh -i' to establish the connection, it does not work to just say fsh host -l user.

There is no inline method using fsh as the multiplexing provided by the program is not very useful in our context. TRAMP opens just one connection to the remote host and then keeps it open, anyway.

`ftp'

This is not a native TRAMP method. Instead of, it forwards all requests to EFS. This works only for unified filenames, see 10. Debatable Issues and What Was Decided.

`smb' -- smbclient

This is another not natural TRAMP method. It uses the smbclient command on different Unices in order to connect to an SMB server. An SMB server might be a Samba (or CIFS) server on another UNIX host or, more interesting, a host running MS Windows. So far, it is tested towards MS Windows NT, MS Windows 2000, and MS Windows XP.

The first directory in the localname must be a share name on the remote host. Remember, that the $ character in which default shares usually end, must be written $$ due to environment variable substitution in file names. If no share name is given (i.e. remote directory /), all available shares are listed.

Since authorization is done on share level, you will be prompted always for a password if you access another share on the same host. This can be suppressed by 4.8 Reusing passwords for several connections..

MS Windows uses for authorization both a user name and a domain name. Because of this, the TRAMP syntax has been extended: you can specify a user name which looks like user%domain (the real user name, then a percent sign, then the domain name). So, to connect to the machine melancholia as user daniel of the domain BIZARRE, and edit `.emacs' in the home directory (share daniel$) I would specify the filename `/[smb/daniel%BIZARRE@melancholia]/daniel$$/.emacs'.

The domain name as well as the user name are optional. If no user name is specified at all, the anonymous user (without password prompting) is assumed. This is different from all other TRAMP methods, where in such a case the local user name is taken.

The `smb' method supports the `-p' hack.

Please note: If XEmacs runs locally under MS Windows, this method isn't available. Instead of, you can use UNC file names like `//melancholia/daniel$$/.emacs'. The only disadvantage is that there's no possibility to specify another user name.

4.4 Connecting to a remote host using multiple hops

Sometimes, the methods described before are not sufficient. Sometimes, it is not possible to connect to a remote host using a simple command. For example, if you are in a secured network, you might have to log in to a `bastion host' first before you can connect to the outside world. Of course, the target host may also require a bastion host. The format of multi-hop filenames is slightly different than the format of normal TRAMP methods.

A multi-hop file name specifies a method, a number of hops, and a localname (path name on the remote system). The method name is always `multi'.

Each hop consists of a hop method specification, a user name and a host name. The hop method can be an inline method only. The following hop methods are (currently) available:

`telnet'

Uses the well-known telnet program to connect to the host. Whereas user name and host name are supplied in the file name, the user is queried for the password.

`rsh'

This uses rsh to connect to the host. You do not need to enter a password unless rsh explicitly asks for it.

The variant `remsh' uses the remsh command. It should be applied on machines where remsh is used instead of rsh.

`ssh'

This uses ssh to connect to the host. You might have to enter a password or a pass phrase.

`su'

This method does not actually contact a different host, but it allows you to become a different user on the host you're currently on. This might be useful if you want to edit files as root, but the remote host does not allow remote root logins. In this case you can use `telnet', `rsh' or `ssh' to connect to the remote host as a non-root user, then use an `su' hop to become root. But `su' need not be the last hop in a sequence, you could also use it somewhere in the middle, if the need arises.

Even though you must specify both user and host with an `su' hop, the host name is ignored and only the user name is used.

`sudo'

This is similar to the `su' hop, except that it uses sudo rather than su to become a different user.

Some people might wish to use port forwarding with ssh or maybe they have to use a nonstandard port. This can be accomplished by putting a stanza in `~/.ssh/config' for the account which specifies a different port number for a certain host name. But it can also be accomplished within TRAMP, by adding a multi-hop method. For example:

(add-to-list
 'tramp-multi-connection-function-alist
 '("sshf" tramp-multi-connect-rlogin "ssh %h -l %u -p 4400%n"))

Now you can use an `sshf' hop which connects to port 4400 instead of the standard port.

4.5 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 "ssh")

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.

See section 4.2 Inline methods. See section 4.3 External transfer methods. See section 4.4 Connecting to a remote host using multiple hops.

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.

4.5.1 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' methods. They offer shortened syntax for the `root' account, like `/[su/]/etc/motd'.

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.

4.6 Using Non-Standard Methods

There is a variable tramp-methods which you can change if the predefined methods don't seem right.

For the time being, I'll refer you to the Lisp documentation of that variable, accessible with C-h v tramp-methods RET.

4.7 Selecting config files for user/host name completion

The variable tramp-completion-function-alist is intended to customize which files are taken into account for user and host name completion (see section 5.3 Filename completion). For every method, it keeps a set of configuration files, accompanied by a Lisp function able to parse that file. Entries in tramp-completion-function-alist have the form (method pair1 pair2 ...).

Each pair is composed of (function file). function is responsible to extract user names and host names from file for completion. There are two functions which access this variable:

Function: tramp-get-completion-function method

This function returns the list of completion functions for method.

Example:

(tramp-get-completion-function "rsh") => ((tramp-parse-rhosts "/etc/hosts.equiv") (tramp-parse-rhosts "~/.rhosts"))

Function: tramp-set-completion-function method function-list

This function sets function-list as list of completion functions for method.

Example:

(tramp-set-completion-function "ssh" '((tramp-parse-sconfig "/etc/ssh_config") (tramp-parse-sconfig "~/.ssh/config"))) => ((tramp-parse-sconfig "/etc/ssh_config") (tramp-parse-sconfig "~/.ssh/config"))

The following predefined functions parsing configuration files exist:

tramp-parse-rhosts

This function parses files which are syntactical equivalent to `~/.rhosts'. It returns both host names and user names, if specified.

tramp-parse-shosts

This function parses files which are syntactical equivalent to `~/.ssh/known_hosts'. Since there are no user names specified in such files, it can return host names only.

tramp-parse-sconfig

This function returns the host nicknames defined by Host entries in `~/.ssh/config' style files.

tramp-parse-shostkeys

SSH2 parsing of directories `/etc/ssh2/hostkeys/*' and `~/ssh2/hostkeys/*'. Hosts are coded in file names `hostkey_portnumber_host-name.pub'. User names are always nil.

tramp-parse-sknownhosts

Another SSH2 style parsing of directories like `/etc/ssh2/knownhosts/*' and `~/ssh2/knownhosts/*'. This case, hosts names are coded in file names `host-name.algorithm.pub'. User names are always nil.

tramp-parse-hosts

A function dedicated to `/etc/hosts' style files. It returns host names only.

tramp-parse-passwd

A function which parses `/etc/passwd' like files. Obviously, it can return user names only.

tramp-parse-netrc

Finally, a function which parses `~/.netrc' like files.

If you want to keep your own data in a file, with your own structure, you might provide such a function as well. This function must meet the following conventions:

Function: my-tramp-parse file

file must be either a file name on your host, or nil. The function must return a list of (user host), which are taken as candidates for user and host name completion.

Example:

(my-tramp-parse "~/.my-tramp-hosts") => ((nil "toto") ("daniel" "melancholia"))

4.8 Reusing passwords for several connections.

Sometimes it is necessary to connect to the same remote host several times. Reentering passwords again and again would be annoying, when the chosen method does not support access without password prompt through own configuration.

By default, TRAMP caches the passwords entered by you. They will be reused next time if a connection needs them for the same user name and host name, independently of the connection method.

Passwords are not saved permanently, that means the password caching is limited to the lifetime of your XEmacs session. You can influence the lifetime of password caching by customizing the variable password-cache-expiry. The value is the number of seconds how long passwords are cached. Setting it to nil disables the expiration.

A password is removed from the cache if a connection isn't established successfully. You can remove a password from the cache also by executing M-x tramp-clear-passwd in a buffer containing a related remote file or directory.

If you don't like this feature for security reasons, password caching can be disabled totally by customizing the variable password-cache (setting it to nil).

Implementation Note: password caching is based on the package password.el in No Gnus. For the time being, it is activated only when this package is seen in the load-path while loading TRAMP. It will be activated mandatory once No Gnus has found its way into XEmacs.

4.9 How TRAMP finds and uses programs on the remote machine.

TRAMP depends on a number of programs on the remote host in order to function, including ls, test, find and cat.

In addition to these required tools, there are various tools that may be required based on the connection method. See 4.2 Inline methods and 4.3 External transfer methods for details on these.

Certain other tools, such as perl (or perl5) and grep will be used if they can be found. When they are available, they are used to improve the performance and accuracy of remote file access.

When TRAMP connects to the remote machine, it searches for the programs that it can use. The variable tramp-remote-path controls the directories searched on the remote machine.

By default, this is set to a reasonable set of defaults for most machines. It is possible, however, that your local (or remote ;) system administrator has put the tools you want in some obscure local directory.

In this case, you can still use them with TRAMP. You simply need to add code to your `.emacs' to add the directory to the remote path. This will then be searched by TRAMP when you connect and the software found.

To add a directory to the remote search path, you could use code such as:

;; We load TRAMP to define the variable.
(require 'tramp)
;; We have perl in "/usr/local/perl/bin"
(add-to-list 'tramp-remote-path "/usr/local/perl/bin")

4.10 Remote shell setup hints

As explained in the 1. An overview of TRAMP section, TRAMP connects to the remote host and talks to the shell it finds there. Of course, when you log in, the shell executes its init files. Suppose your init file requires you to enter the birth date of your mother; clearly TRAMP does not know this and hence fails to log you in to that host.

There are different possible strategies for pursuing this problem. One strategy is to enable TRAMP to deal with all possible situations. This is a losing battle, since it is not possible to deal with all situations. The other strategy is to require you to set up the remote host such that it behaves like TRAMP expects. This might be inconvenient because you have to invest a lot of effort into shell setup before you can begin to use TRAMP.

The package, therefore, pursues a combined approach. It tries to figure out some of the more common setups, and only requires you to avoid really exotic stuff. For example, it looks through a list of directories to find some programs on the remote host. And also, it knows that it is not obvious how to check whether a file exists, and therefore it tries different possibilities. (On some hosts and shells, the command test -e does the trick, on some hosts the shell builtin doesn't work but the program /usr/bin/test -e or /bin/test -e works. And on still other hosts, ls -d is the right way to do this.)

Below you find a discussion of a few things that TRAMP does not deal with, and that you therefore have to set up correctly.

shell-prompt-pattern

After logging in to the remote host, TRAMP has to wait for the remote shell startup to finish before it can send commands to the remote shell. The strategy here is to wait for the shell prompt. In order to recognize the shell prompt, the variable shell-prompt-pattern has to be set correctly to recognize the shell prompt on the remote host.

Note that TRAMP requires the match for shell-prompt-pattern to be at the end of the buffer. Many people have something like the following as the value for the variable: "^[^>$][>$] *". Now suppose your shell prompt is a <b> c $ . In this case, TRAMP recognizes the > character as the end of the prompt, but it is not at the end of the buffer.

tramp-shell-prompt-pattern

This regular expression is used by TRAMP in the same way as shell-prompt-pattern, to match prompts from the remote shell. This second variable exists because the prompt from the remote shell might be different from the prompt from a local shell -- after all, the whole point of TRAMP is to log in to remote hosts as a different user. The default value of tramp-shell-prompt-pattern is the same as the default value of shell-prompt-pattern, which is reported to work well in many circumstances.

tset and other questions

Some people invoke the tset program from their shell startup scripts which asks the user about the terminal type of the shell. Maybe some shells ask other questions when they are started. TRAMP does not know how to answer these questions. There are two approaches for dealing with this problem. One approach is to take care that the shell does not ask any questions when invoked from TRAMP. You can do this by checking the TERM environment variable, it will be set to dumb when connecting.

The variable tramp-terminal-type can be used to change this value to dumb.

The other approach is to teach TRAMP about these questions. See the variables tramp-actions-before-shell and tramp-multi-actions (for multi-hop connections).

Environment variables named like users in `.profile'

If you have a user named frumple and set the variable FRUMPLE in your shell environment, then this might cause trouble. Maybe rename the variable to FRUMPLE_DIR or the like.

This weird effect was actually reported by a TRAMP user!

Non-Bourne commands in `.profile'

After logging in to the remote host, TRAMP issues the command exec /bin/sh. (Actually, the command is slightly different.) When /bin/sh is executed, it reads some init files, such as `~/.shrc' or `~/.profile'.

Now, some people have a login shell which is not /bin/sh but a Bourne-ish shell such as bash or ksh. Some of these people might put their shell setup into the files `~/.shrc' or `~/.profile'. This way, it is possible for non-Bourne constructs to end up in those files. Then, exec /bin/sh might cause the Bourne shell to barf on those constructs.

As an example, imagine somebody putting export FOO=bar into the file `~/.profile'. The standard Bourne shell does not understand this syntax and will emit a syntax error when it reaches this line.

Another example is the tilde (~) character, say when adding `~/bin' to $PATH. Many Bourne shells will not expand this character, and since there is usually no directory whose name consists of the single character tilde, strange things will happen.

What can you do about this?

Well, one possibility is to make sure that everything in `~/.shrc' and `~/.profile' on all remote hosts is Bourne-compatible. In the above example, instead of export FOO=bar, you might use FOO=bar; export FOO instead.

The other possibility is to put your non-Bourne shell setup into some other files. For example, bash reads the file `~/.bash_profile' instead of `~/.profile', if the former exists. So bash aficionados just rename their `~/.profile' to `~/.bash_profile' on all remote hosts, and Bob's your uncle.

The TRAMP developers would like to circumvent this problem, so if you have an idea about it, please tell us. However, we are afraid it is not that simple: before saying exec /bin/sh, TRAMP does not know which kind of shell it might be talking to. It could be a Bourne-ish shell like ksh or bash, or it could be a csh derivative like tcsh, or it could be zsh, or even rc. If the shell is Bourne-ish already, then it might be prudent to omit the exec /bin/sh step. But how to find out if the shell is Bourne-ish?

4.11 Auto-save and Backup configuration

Normally, XEmacs writes backup files to the same directory as the original files, but this behavior can be changed via the variable bkup-backup-directory-info. In connection with TRAMP, this can have unexpected side effects. Suppose that you specify that all backups should go to the directory `~/.emacs.d/backups/', and then you edit the file `/[su/root@localhost]/etc/secretfile'. The effect is that the backup file will be owned by you and not by root, thus possibly enabling others to see it even if they were not intended to see it.

When bkup-backup-directory-info is nil (the default), such problems do not occur.

Therefore, it is useful to set special values for TRAMP files. For example, the following statement effectively `turns off' the effect of bkup-backup-directory-info for TRAMP files:

(require 'backup-dir)
(add-to-list 'bkup-backup-directory-info
             (list tramp-file-name-regexp ""))

Another possibility is to use the TRAMP variable tramp-bkup-backup-directory-info. This variable has the same meaning like bkup-backup-directory-info. If a TRAMP file is backed up, and DIRECTORY is an absolute local file name, DIRECTORY is prepended with the TRAMP file name prefix of the file to be backed up.

Example:

(require 'backup-dir)
(add-to-list 'bkup-backup-directory-info
             (list "." "~/.emacs.d/backups/" 'full-path))
(setq tramp-bkup-backup-directory-info bkup-backup-directory-info)

The backup file name of `/[su/root@localhost]/etc/secretfile' would be `/[su/root@localhost]~/.emacs.d/backups/![su!root@localhost]!etc!secretfile~'

The same problem can happen with auto-saving files. For this purpose you can set the variable auto-save-directory to a proper value.

4.12 Issues with Cygwin ssh

This section needs a lot of work! Please help.

The recent Cygwin installation of ssh works only with a Cygwinized XEmacs. You can check it by typing M-x eshell, and starting ssh test.machine. The problem is evident if you see a message like this:

Pseudo-terminal will not be allocated because stdin is not a terminal.

Older ssh versions of Cygwin are told to cooperate with TRAMP selecting `sshx' as the connection method. You can find information about setting up Cygwin in their FAQ at http://cygwin.com/faq/.

If you wish to use the `scpx' connection method, then you might have the problem that XEmacs calls scp with a Windows filename such as c:/foo. The Cygwin version of scp does not know about Windows filenames and interprets this as a remote filename on the host c.

One possible workaround is to write a wrapper script for `scp' which converts the Windows filename to a Cygwinized filename.

If you want to use either `ssh' based method on Windows, then you might encounter problems with ssh-agent. Using this program, you can avoid typing the pass-phrase every time you log in. However, if you start XEmacs from a desktop shortcut, then the environment variable SSH_AUTH_SOCK is not set and so XEmacs and thus TRAMP and thus ssh and scp started from TRAMP cannot communicate with ssh-agent. It works better to start XEmacs from the shell.

If anyone knows how to start ssh-agent under Windows in such a way that desktop shortcuts can profit, please holler. I don't really know anything at all about Windows...

This document was generated by XEmacs shared group account on December, 19 2009 using texi2html 1.65.