Taylor UUCP - Introduction to Taylor UUCP

Go to the first, previous, next, last section, table of contents.

# Introduction to Taylor UUCP

General introductions to UUCP are available, and perhaps one day I will write one. In the meantime, here is a very brief one that concentrates on the programs provided by Taylor UUCP.

Taylor UUCP is a complete UUCP package. It is covered by the GNU Public License, which means that the source code is always available. It is composed of several programs; most of the names of these programs are based on earlier UUCP packages.

`uucp`
  The `uucp` program is used to copy file between systems. It is similar to the standard Unix `cp` program, except that you can refer to a file on a remote system by using ``system!'` before the file name. For example, to copy the file ``notes.txt'` to the system ``airs'`, you would say ``uucp notes.txt airs!~/notes.txt'`. In this example ``~'` is used to name the UUCP public directory on ``airs'`. For more details, see section Invoking uucp.
`uux`
  The `uux` program is used to request the execution of a program on a remote system. This is how mail and news are transferred over UUCP. As with `uucp`, programs and files on remote systems may be named by using ``system!'`. For example, to run the `rnews` program on ``airs'`, passing it standard input, you would say ``uux - airs!rnews'`. The ``-'` means to read standard input and set things up such that when `rnews` runs on ``airs'` it will receive the same standard input. For more details, see section Invoking uux.

Neither `uucp` nor `uux` actually do any work immediately. Instead, they queue up requests for later processing. They then start a daemon process which processes the requests and calls up the appropriate systems. Normally the system will also start the daemon periodically to check if there is any work to be done. The advantage of this approach is that it all happens automatically. You don't have to sit around waiting for the files to be transferred. The disadvantage is that if anything goes wrong it might be a while before anybody notices.

`uustat`
  The `uustat` program does many things. By default it will simply list all the jobs you have queued with `uucp` or `uux` that have not yet been processed. You can use `uustat` to remove any of your jobs from the queue. You can also it use it to show the status of the UUCP system in various ways, such as showing the connection status of all the remote systems your system knows about. The system administrator can use `uustat` to automatically discard old jobs while sending mail to the user who requested them. For more details, see section Invoking uustat.
`uuname`
  The `uuname` program by default lists all the remote systems your system knows about. You can also use it to get the name of your local system. It is mostly useful for shell scripts. For more details, see section Invoking uuname.
`uulog`
  The `uulog` program can be used to display entries in the UUCP log file. It can select the entries for a particular system or a particular user. You can use it to see what has happened to your queued jobs in the past. For more details, see section Invoking uulog.
`uuto`
`uupick`
  `uuto` is a simple shell script interface to `uucp`. It will transfer a file, or the contents of a directory, to a remote system, and notify a particular user on the remote system when it arrives. The remote user can then retrieve the file(s) with `uupick`. For more details, see section Invoking uuto, and see section Invoking uupick.
`cu`
  The `cu` program can be used to call up another system and communicate with it as though you were directly connected. It can also do simple file transfers, though it does not provide any error checking. For more details, section Invoking cu.

These eight programs just described, `uucp`, `uux`, `uuto`, `uupick`, `uustat`, `uuname`, `uulog`, and `cu` are the user programs provided by Taylor UUCP. `uucp`, `uux`, and `uuto` add requests to the work queue, `uupick` extracts files from the UUCP public directory, `uustat` examines the work queue, `uuname` examines the configuration files, `uulog` examines the log files, and `cu` just uses the UUCP configuration files.

The real work is actually done by two daemon processes, which are normally run automatically rather than by a user.

`uucico`
  The `uucico` daemon is the program which actually calls the remote system and transfers files and requests. `uucico` is normally started automatically by `uucp` and `uux`. Most systems will also start it periodically to make sure that all work requests are handled. `uucico` checks the queue to see what work needs to be done, and then calls the appropriate systems. If the call fails, perhaps because the phone line is busy, `uucico` leaves the requests in the queue and goes on to the next system to call. It is also possible to force `uucico` to call a remote system even if there is no work to be done for it, so that it can pick up any work that may be queued up remotely. For more details, see section Invoking uucico.
`uuxqt`
  The `uuxqt` daemon processes execution requests made by the `uux` program on remote systems. It also processes requests made on the local system which require files from a remote system. It is normally started by `uucico`. For more details, see section Invoking uuxqt.

Suppose you, on the system ``bantam'`, want to copy a file to the system ``airs'`. You would run the `uucp` command locally, with a command like ``uucp notes.txt airs!~/notes.txt'`. This would queue up a request on ``bantam'` for ``airs'`, and would then start the `uucico` daemon. `uucico` would see that there was a request for ``airs'` and attempt to call it. When the call succeeded, another copy of `uucico` would be started on ``airs'`. The two copies of `uucico` would tell each other what they had to do and transfer the file from ``bantam'` to ``airs'`. When the file transfer was complete the `uucico` on ``airs'` would move it into the UUCP public directory.

UUCP is often used to transfer mail. This is normally done automatically by mailer programs. When ``bantam'` has a mail message to send to ``ian'` at ``airs'`, it executes ``uux - airs!rmail ian'` and writes the mail message to the `uux` process as standard input. The `uux` program, running on ``bantam'`, will read the standard input and store it, as well as the `rmail` request itself, on the work queue for ``airs'`. `uux` will then start the `uucico` daemon. The `uucico` daemon will call up ``airs'`, just as in the `uucp` example, and transfer the work request and the mail message. The `uucico` daemon on ``airs'` will put the files on a local work queue. When the communication session is over, the `uucico` daemon on ``airs'` will start the `uuxqt` daemon. `uuxqt` will see the request on the work queue, and will run ``rmail ian'` with the mail message as standard input. The `rmail` program, which is not part of the UUCP package, is then responsible for either putting the message in the right mailbox on ``airs'` or forwarding the message on to another system.

Taylor UUCP comes with a few other programs that are useful when installing and configuring UUCP.

`uuchk`
  The `uuchk` program reads the UUCP configuration files and displays a rather lengthy description of what it finds. This is useful when configuring UUCP to make certain that the UUCP package will do what you expect it to do. For more details, see section Invoking uuchk.
`uuconv`
  The `uuconv` program can be used to convert UUCP configuration files from one format to another. This can be useful for administrators converting from an older UUCP package. Taylor UUCP is able to read and use old configuration file formats, but some new features can not be selected using the old formats. For more details, see section Invoking uuconv.
`uusched`
  The `uusched` script is provided for compatibility with older UUCP releases. It starts `uucico` to call, one at a time, all the systems for which work has been queued. For more details, see section Invoking uusched.
`tstuu`
  The `tstuu` program is a test harness for the UUCP package; it can help check that the package has been configured and compiled correctly. However, it uses pseudo-terminals, which means that it is less portable than the rest of the package. If it works, it can be useful when initially installing Taylor UUCP. For more details, see section Testing the Compilation.

Go to the first, previous, next, last section, table of contents.