   This file documents Taylor UUCP, version 1.06.

   Copyright (C) 1992, 1993, 1994, 1995 Ian Lance Taylor

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "Copying" are included exactly as in the
original, and provided that the entire resulting derived work is
distributed under the terms of a permission notice identical to this
one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "Copying" may be included in
a translation approved by the author instead of in the original English.

Taylor UUCP 1.06
****************

   This is the documentation for the Taylor UUCP package, version 1.06.
The programs were written by Ian Lance Taylor.  The author can be
reached at `<ian@airs.com>', or at
     Ian Lance Taylor
     c/o Cygnus Support
     48 Grove Street
     Somerville, MA 02144
     USA

   There is a mailing list for discussion of the package.  The list is
hosted by Eric Schnoebelen at `cirr.com'.  To join (or get off) the
list, send mail to `taylor-uucp-request@cirr.com'.  Mail to this
address is answered by the majordomo program.  To join the list, send
the message `subscribe ADDRESS' where ADDRESS is your e-mail address.
To send a message to the list, send it to `taylor-uucp@cirr.com'.  The
old list address, `taylor-uucp@gnu.ai.mit.edu', will also work.  There
is an archive of all messages sent to the mailing list at
`ftp.cirr.com'.

Taylor UUCP Copying Conditions
******************************

   This package is covered by the GNU Public License.  See the file
`COPYING' for details.  If you would like to do something with this
package that you feel is reasonable, but you feel is prohibited by the
license, contact me to see if we can work it out.

   The rest of this section is some descriptive text from the Free
Software Foundation.

   All the programs, scripts and documents relating to Taylor UUCP are
"free"; this means that everyone is free to use them and free to
redistribute them on a free basis.  The Taylor UUCP-related programs are
not in the public domain; they are copyrighted and there are
restrictions on their distribution, but these restrictions are designed
to permit everything that a good cooperating citizen would want to do.
What is not allowed is to try to prevent others from further sharing any
version of these programs that they might get from you.

   Specifically, we want to make sure that you have the right to give
away copies of the programs that relate to Taylor UUCP, that you receive
source code or else can get it if you want it, that you can change these
programs or use pieces of them in new free programs, and that you know
you can do these things.

   To make sure that everyone has such rights, we have to forbid you to
deprive anyone else of these rights.  For example, if you distribute
copies of the Taylor UUCP related programs, you must give the recipients
all the rights that you have.  You must make sure that they, too,
receive or can get the source code.  And you must tell them their
rights.

   Also, for our own protection, we must make certain that everyone
finds out that there is no warranty for the programs that relate to
Taylor UUCP.  If these programs are modified by someone else and passed
on, we want their recipients to know that what they have is not what we
distributed, so that any problems introduced by others will not reflect
on our reputation.

   The precise conditions of the licenses for the programs currently
being distributed that relate to Taylor UUCP are found in the General
Public Licenses that accompany them.

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 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 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 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 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 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 uuto, and
     see 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, see 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
     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 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 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 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
     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 tstuu.

Invoking the UUCP Programs
**************************

   This chapter describes how to run the UUCP programs.

Standard Options
================

   All of the UUCP programs support a few standard options.

`-x type'
`--debug type'
     Turn on particular debugging types.  The following types are
     recognized: `abnormal', `chat', `handshake', `uucp-proto',
     `proto', `port', `config', `spooldir', `execute', `incoming',
     `outgoing'.  Not all types of debugging are effective for all
     programs.  See the `debug' configuration command for details
     (see Debugging Levels.).

     Multiple types may be given, separated by commas, and the `--debug'
     option may appear multiple times.  A number may also be given,
     which will turn on that many types from the foregoing list; for
     example, `--debug 2' is equivalent to `--debug abnormal,chat'.  To
     turn on all types of debugging, use `-x all'.

     The `uulog' program uses `-X' rather than `-x' to select the
     debugging type; for `uulog', `-x' has a different meaning, for
     reasons of historical compatibility.

`-I file'
`--config file'
     Set the main configuration file to use.  See config File.
     When this option is used, the programs will revoke any setuid
     privileges.

`-v'
`--version'
     Report version information and exit.

`--help'
     Print a help message and exit.

Invoking uucp
=============

uucp Description
----------------

     uucp [options] `source-file' `destination-file'
     uucp [options] `source-file'... `destination-directory'

   The `uucp' command copies files between systems.  Each `file'
argument is either a file name on the local machine or is of the form
`system!file'.  The latter is interpreted as being on a remote system.

   When `uucp' is used with two non-option arguments, the contents of
the first file are copied to the second.  With more than two non-option
arguments, each source file is copied into the destination directory.

   A file may be transferred to or from `system2' via `system1' by
using `system1!system2!file'.

   Any file name that does not begin with `/' or `~' will be prepended
with the current directory (unless the `-W' or `--noexpand' options are
used).  For example, if you are in the directory `/home/ian', then
`uucp foo remote!bar' is equivalent to `uucp /home/ian/foo
remote!/home/ian/bar'.  Note that the resulting file name may not be
valid on a remote system.

   A file name beginning with a simple `~' starts at the UUCP public
directory; a file name beginning with `~name' starts at the home
directory of the named user.  The `~' is interpreted on the appropriate
system.  Note that some shells will interpret an initial `~' before
`uucp' sees it; to avoid this the `~' must be quoted.

   The shell metacharacters `?' `*' `[' and `]' are interpreted on the
appropriate system, assuming they are quoted to prevent the shell from
interpreting them first.

   The file copy does not take place immediately, but is queued up for
the `uucico' daemon; the daemon is started immediately unless the `-r'
or `--nouucico' option is given.  The next time the remote system is
called, the file(s) will be copied.  See Invoking uucico.

   The file mode is not preserved, except for the execute bit.  The
resulting file is owned by the uucp user.

uucp Options
------------

   The following options may be given to `uucp'.

`-c'
`--nocopy'
     Do not copy local source files to the spool directory.  If they are
     removed before being processed by the `uucico' daemon, the copy
     will fail.  The files must be readable by the `uucico' daemon, and
     by the invoking user.

`-C'
`--copy'
     Copy local source files to the spool directory.  This is the
     default.

`-d'
`--directories'
     Create all necessary directories when doing the copy.  This is the
     default.

`-f'
`--nodirectories'
     If any necessary directories do not exist for the destination file
     name, abort the copy.

`-R'
`--recursive'
     If any of the source file names are directories, copy their
     contents recursively to the destination (which must itself be a
     directory).

`-g grade'
`--grade grade'
     Set the grade of the file transfer command.  Jobs of a higher
     grade are executed first.  Grades run `0' to `9', `A' to `Z', `a'
     to `z', from high to low.  See When to Call.

`-m'
`--mail'
     Report completion or failure of the file transfer by sending mail.

`-n user'
`--notify user'
     Report completion or failure of the file transfer by sending mail
     to the named user on the destination system.

`-r'
`--nouucico'
     Do not start the `uucico' daemon immediately; merely queue up the
     file transfer for later execution.

`-j'
`--jobid'
     Print the jobid on standard output.  The job may be later
     cancelled by passing this jobid to the `-kill' switch of `uustat'.
     See Invoking uustat.

     It is possible for some complex operations to produce more than one
     jobid, in which case each will be printed on a separate line.  For
     example
          uucp sys1!~user1/file1 sys2!~user2/file2 ~user3
     will generate two separate jobs, one for the system `sys1' and one
     for the system `sys2'.

`-W'
`--noexpand'
     Do not prepend remote relative file names with the current
     directory.

`-t'
`--uuto'
     This option is used by the `uuto' shell script; see Invoking uuto.
     It causes `uucp' to interpret the final argument as
     `system!user'.  The file(s) are sent to `~/receive/USER/LOCAL' on
     the remote system, where USER is from the final argument and LOCAL
     is the local UUCP system name.  Also, `uucp' will act as though
     `--notify user' were specified.

`-x type'
`--debug type'
`-I file'
`--config file'
`-v'
`--version'
`--help'
     See Standard Options.

Invoking uux
============

uux Description
---------------

     uux [options] command

   The `uux' command is used to execute a command on a remote system,
or to execute a command on the local system using files from remote
systems.  The command is not executed immediately; the request is queued
until the `uucico' daemon calls the system and transfers the necessary
files.  The daemon is started automatically unless one of the `-r' or
`--nouucico' options is given.

   The actual command execution is done by the `uuxqt' daemon on the
appropriate system.

   File arguments can be gathered from remote systems to the execution
system, as can standard input.  Standard output may be directed to a
file on a remote system.

   The command name may be preceded by a system name followed by an
exclamation point if it is to be executed on a remote system.  An empty
system name is taken as the local system.

   Each argument that contains an exclamation point is treated as
naming a file.  The system which the file is on is before the
exclamation point, and the file name on that system follows it.  An
empty system name is taken as the local system; this form must be used
to transfer a file to a command being executed on a remote system.  If
the file name is not absolute, the current working directory will be
prepended to it; the result may not be meaningful on the remote system.
A file name may begin with `~/', in which case it is relative to the
UUCP public directory on the appropriate system.  A file name may begin
with `~name/', in which case it is relative to the home directory of the
named user on the appropriate system.

   Standard input and output may be redirected as usual; the file names
used may contain exclamation points to indicate that they are on remote
systems.  Note that the redirection characters must be quoted so that
they are passed to `uux' rather than interpreted by the shell.  Append
redirection (`>>') does not work.

   All specified files are gathered together into a single directory
before execution of the command begins.  This means that each file must
have a distinct name.  For example,
     uux 'sys1!diff sys2!~user1/foo sys3!~user2/foo >!foo.diff'
   will fail because both files will be copied to `sys1' and stored
under the name `foo'.

   Arguments may be quoted by parentheses to avoid interpretation of
exclamation points.  This is useful when executing the `uucp' command
on a remote system.

   Most systems restrict the commands which may be executed using
`uux'.  Many permit only the execution of `rmail' and `rnews'.

   A request to execute an empty command (e.g., `uux sys!') will create
a poll file for the specified system; see Calling Other Systems
for an example of why this might be useful.

uux Options
-----------

   The following options may be given to `uux'.

`-'
`-p'
`--stdin'
     Read standard input up to end of file, and use it as the standard
     input for the command to be executed.

`-c'
`--nocopy'
     Do not copy local files to the spool directory.  This is the
     default.  If they are removed before being processed by the
     `uucico' daemon, the copy will fail.  The files must be readable
     by the `uucico' daemon, as well as the by the invoker of `uux'.

`-C'
`--copy'
     Copy local files to the spool directory.

`-l'
`--link'
     Link local files into the spool directory.  If a file can not be
     linked because it is on a different device, it will be copied
     unless one of the `-c' or `--nocopy' options also appears (in
     other words, use of `--link' switches the default from `--nocopy'
     to `--copy').  If the files are changed before being processed by
     the `uucico' daemon, the changed versions will be used.  The files
     must be readable by the `uucico' daemon, as well as by the invoker
     of `uux'.

`-g grade'
`--grade grade'
     Set the grade of the file transfer command.  Jobs of a higher
     grade are executed first.  Grades run `0' to `9', `A' to `Z', `a'
     to `z', from high to low.  See When to Call.

`-n'
`--notification=no'
     Do not send mail about the status of the job, even if it fails.

`-z'
`--notification=error'
     Send mail about the status of the job if an error occurs.  For many
     `uuxqt' daemons, including the Taylor UUCP `uuxqt', this is the
     default action; for those, `--notification=error' will have no
     effect.  However, some `uuxqt' daemons will send mail if the job
     succeeds, unless the `--notification=error' option is used.  Some
     other `uuxqt' daemons will not send mail even if the job fails,
     unless the `--notification=error' option is used.

`-a address'
`--requestor address'
     Report job status, as controlled by the `--notification' option, to
     the specified mail address.

`-r'
`--nouucico'
     Do not start the `uucico' daemon immediately; merely queue up the
     execution request for later processing.

`-j'
`--jobid'
     Print the jobid on standard output.  A jobid will be generated for
     each file copy operation required to execute the command.  These
     file copies may be later cancelled by passing the jobid to the
     `-kill' switch of `uustat'.  See Invoking uustat.  Cancelling
     any file copies will make it impossible to complete execution of
     the job.

`-x type'
`--debug type'
`-v'
`--version'
`--help'
     See Standard Options.

uux Examples
------------

   Here are some examples of using `uux'.

     uux -z - sys1!rmail user1
   This will execute the command `rmail user1' on the system `sys1',
giving it as standard input whatever is given to `uux' as standard
input.  If a failure occurs, mail will be sent to the user who ran the
command.

     uux 'diff -c sys1!~user1/file1 sys2!~user2/file2 >!file.diff'
   This will fetch the two named files from system `sys1' and system
`sys2' and execute `diff', putting the result in `file.diff' in the
current directory on the local system.  The current directory must be
writable by the `uuxqt' daemon for this to work.

     uux 'sys1!uucp ~user1/file1 (sys2!~user2/file2)'
   Execute `uucp' on the system `sys1' copying `file1' (on system
`sys1') to `sys2'.  This illustrates the use of parentheses for quoting.

Invoking uustat
===============

uustat Description
------------------

     uustat -a
     uustat --all
     uustat [-eKRiMNQ] [-sS system] [-uU user] [-cC command] [-oy hours]
            [-B lines] [--executions] [--kill-all] [--rejuvenate-all]
            [--prompt] [--mail] [--notify] [--no-list] [--system system]
            [--not-system system] [--user user] [--not-user user]
            [--command command] [--not-command command] [--older-than hours]
            [--younger-than hours] [--mail-lines lines]
     uustat [-kr jobid] [--kill jobid] [--rejuvenate jobid]
     uustat -q [-sS system] [-oy hours] [--system system]
            [--not-system system ] [--older-than hours] [--younger-than hours]
     uustat --list [-sS system] [-oy hours] [--system system ]
            [--not-system system] [--older-than hours] [--younger-than hours]
     uustat -m
     uustat --status
     uustat -p
     uustat --ps

   The `uustat' command can display various types of status information
about the UUCP system.  It can also be used to cancel or rejuvenate
requests made by `uucp' or `uux'.

   With no options, `uustat' displays all jobs queued up for the
invoking user, as if given the `--user' option with the appropriate
argument.

   If any of the `-a', `--all', `-e', `--executions', `-s', `--system',
`-S', `--not-system', `-u', `--user', `-U', `--not-user', `-c',
`--command', `-C', `--not-command', `-o', `--older-than', `-y', or
`--younger-than' options are given, then all jobs which match the
combined specifications are displayed.

   The `-K' or `--kill-all' option may be used to kill off a selected
group of jobs, such as all jobs more than 7 days old.

uustat Options
--------------

   The following options may be given to `uustat'.

`-a'
`--all'
     List all queued file transfer requests.

`-e'
`--executions'
     List queued execution requests rather than queued file transfer
     requests.  Queued execution requests are processed by `uuxqt'
     rather than `uucico'.  Queued execution requests may be waiting for
     some file to be transferred from a remote system.  They are
     created by an invocation of `uux'.

`-s system'
`--system system'
     List all jobs queued up for the named system.  These options may be
     specified multiple times, in which case all jobs for all the named
     systems will be listed.  If used with `--list', only the systems
     named will be listed.

`-S system'
`--not-system system'
     List all jobs queued for systems other than the one named.  These
     options may be specified multiple times, in which case no jobs
     from any of the specified systems will be listed.  If used with
     `--list', only the systems not named will be listed.  These
     options may not be used with `-s' or `--system'.

`-u user'
`--user user'
     List all jobs queued up for the named user.  These options may be
     specified multiple times, in which case all jobs for all the named
     users will be listed.

`-U user'
`--not-user user'
     List all jobs queued up for users other than the one named.  These
     options may be specified multiple times, in which case no jobs
     from any of the specified users will be listed.  These options may
     not be used with `-u' or `--user'.

`-c command'
`--command command'
     List all jobs requesting the execution of the named command.  If
     `command' is `ALL' this will list all jobs requesting the
     execution of some command (as opposed to simply requesting a file
     transfer).  These options may be specified multiple times, in
     which case all jobs requesting any of the commands will be listed.

`-C command'
`--not-command command'
     List all jobs requesting execution of some command other than the
     named command, or, if `command' is `ALL', list all jobs that simply
     request a file transfer (as opposed to requesting the execution of
     some command).  These options may be specified multiple times, in
     which case no job requesting one of the specified commands will be
     listed.  These options may not be used with `-c' or `--command'.

`-o hours'
`--older-than hours'
     List all queued jobs older than the given number of hours.  If
     used with `--list', only systems whose oldest job is older than
     the given number of hours will be listed.

`-y hours'
`--younger-than hours'
     List all queued jobs younger than the given number of hours.  If
     used with `--list', only systems whose oldest job is younger than
     the given number of hours will be listed.

`-k jobid'
`--kill jobid'
     Kill the named job.  The job id is shown by the default output
     format, as well as by the `-j' or `--jobid' options to `uucp' or
     `uux'.  A job may only be killed by the user who created the job,
     or by the UUCP administrator, or the superuser.  The `-k' or
     `--kill' options may be used multiple times on the command line to
     kill several jobs.

`-r jobid'
`--rejuvenate jobid'
     Rejuvenate the named job.  This will mark it as having been
     invoked at the current time, affecting the output of the `-o',
     `--older-than', `-y', or `--younger-than' options, possibly
     preserving it from any automated cleanup daemon.  The job id is
     shown by the default output format, as well as by the `-j' or
     `--jobid' options to `uucp' or `uux'.  A job may only be
     rejuvenated by the user who created the job, or by the UUCP
     administrator, or the superuser.  The `-r' or `--rejuvenate'
     options may be used multiple times on the command line to
     rejuvenate several jobs.

`-q'
`--list'
     Display the status of commands, executions and conversations for
     all remote systems for which commands or executions are queued.
     The `-s', `--system', `-S', `--not-system', `-o', `--older-than',
     `-y', and `--younger-than' options may be used to restrict the
     systems which are listed.  Systems for which no commands or
     executions are queued will never be listed.

`-m'
`--status'
     Display the status of conversations for all remote systems.

`-p'
`--ps'
     Display the status of all processes holding UUCP locks on systems
     or ports.

`-i'
`--prompt'
     For each listed job, prompt whether to kill the job or not.  If the
     first character of the input line is `y' or `Y', the job will be
     killed.

`-K'
`--kill-all'
     Automatically kill each listed job.  This can be useful for
     automatic cleanup scripts, in conjunction with the `--mail' and
     `--notify' options.

`-R'
`--rejuvenate-all'
     Automatically rejuvenate each listed job.  This may not be used
     with `--kill-all'.

`-M'
`--mail'
     For each listed job, send mail to the UUCP administrator.  If the
     job is killed (due to `--kill-all', or `--prompt' with an
     affirmative response) the mail will indicate that.  A comment
     specified by the `--comment' option may be included.  If the job
     is an execution, the initial portion of its standard input will be
     included in the mail message; the number of lines to include may
     be set with the `--mail-lines' option (the default is 100).  If
     the standard input contains null characters, it is assumed to be a
     binary file and is not included.

`-N'
`--notify'
     For each listed job, send mail to the user who requested the job.
     The mail is identical to that sent by the `-M' or `--mail' options.

`-W comment'
`--comment comment'
     Specify a comment to be included in mail sent with the `-M',
     `--mail', `-N', or `--notify' options.

`-B lines'
`--mail-lines lines'
     When the `-M', `--mail', `-N', or `--notify' options are used to
     send mail about an execution with standard input, this option
     controls the number of lines of standard input to include in the
     message.  The default is 100.

`-Q'
`--no-list'
     Do not actually list the job, but only take any actions indicated
     by the `-i', `--prompt', `-K', `--kill-all', `-M', `--mail', `-N'
     or `--notify' options.

`-x type'
`--debug type'
`-I file'
`--config file'
`-v'
`--version'
`--help'
     See Standard Options.

uustat Examples
---------------

     uustat --all
   Display status of all jobs.  A sample output line is as follows:
     bugsA027h bugs ian 04-01 13:50 Executing rmail ian@airs.com (sending 12 bytes)
   The format is
     jobid system user queue-date command (size)
   The jobid may be passed to the `--kill' or `--rejuvenate' options.
The size indicates how much data is to be transferred to the remote
system, and is absent for a file receive request.  The `--system',
`--not-system', `--user', `--not-user', `--command', `--not-command',
`--older-than', and `--younger-than' options may be used to control
which jobs are listed.

     uustat --executions
   Display status of queued up execution requests.  A sample output line
is as follows:
     bugs bugs!ian 05-20 12:51 rmail ian
   The format is
     system requestor queue-date command
   The `--system', `--not-system', `--user', `--not-user', `--command',
`--not-command', `--older-than', and `--younger-than' options may be
used to control which requests are listed.

     uustat --list
   Display status for all systems with queued up commands.  A sample
output line is as follows:
     bugs            4C (1 hour)   0X (0 secs) 04-01 14:45 Dial failed
   This indicates the system, the number of queued commands, the age of
the oldest queued command, the number of queued local executions, the
age of the oldest queued execution, the date of the last conversation,
and the status of that conversation.

     uustat --status
   Display conversation status for all remote systems.  A sample output
line is as follows:
     bugs           04-01 15:51 Conversation complete
   This indicates the system, the date of the last conversation, and the
status of that conversation.  If the last conversation failed, `uustat'
will indicate how many attempts have been made to call the system.  If
the retry period is currently preventing calls to that system, `uustat'
also displays the time when the next call will be permitted.

     uustat --ps
   Display the status of all processes holding UUCP locks.  The output
format is system dependent, as `uustat' simply invokes `ps' on each
process holding a lock.

     uustat -c rmail -o 168 -K -Q -M -N -W "Queued for over 1 week"
   This will kill all `rmail' commands that have been queued up waiting
for delivery for over 1 week (168 hours).  For each such command, mail
will be sent both to the UUCP administrator and to the user who
requested the rmail execution.  The mail message sent will include the
string given by the `-W' option.  The `-Q' option prevents any of the
jobs from being listed on the terminal, so any output from the program
will be error messages.

Invoking uuname
===============

     uuname [-a] [--aliases]
     uuname -l
     uuname --local

   By default, the `uuname' program simply lists the names of all the
remote systems mentioned in the UUCP configuration files.

   The `uuname' program may also be used to print the UUCP name of the
local system.

   The `uuname' program is mainly for use by shell scripts.

   The following options may be given to `uuname'.

`-a'
`--aliases'
     List all aliases for remote systems, as well as their canonical
     names.  Aliases may be specified in the `sys' file (see Naming the System.).

`-l'
`--local'
     Print the UUCP name of the local system, rather than listing the
     names of all the remote systems.

`-x type'
`--debug type'
`-I file'
`--config file'
`-v'
`--version'
`--help'
     See Standard Options.

Invoking uulog
==============

     uulog [-#] [-n lines] [-sf system] [-u user] [-DSF] [--lines lines]
           [--system system] [--user user] [--debuglog] [--statslog]
           [--follow] [--follow=system]

   The `uulog' program may be used to display the UUCP log file.
Different options may be used to select which parts of the file to
display.

`-#'
`-n lines'
`--lines lines'
     Here `#' is a number; e.g., `-10'.  The specified number of lines
     is displayed from the end of the log file.  The default is to
     display the entire log file, unless the `-f', `-F', or `--follow'
     options are used, in which case the default is to display 10 lines.

`-s system'
`--system system'
     Display only log entries pertaining to the specified system.

`-u user'
`--user user'
     Display only log entries pertaining to the specified user.

`-D'
`--debuglog'
     Display the debugging log file.

`-S'
`--statslog'
     Display the statistics log file.

`-F'
`--follow'
     Keep displaying the log file forever, printing new lines as they
     are appended to the log file.

`-f system'
`--follow=system'
     Keep displaying the log file forever, displaying only log entries
     pertaining to the specified system.

`-X type'
`--debug type'
`-I file'
`--config file'
`-v'
`--version'
`--help'
     See Standard Options.  Note that `uulog' specifies the
     debugging type using `-X' rather than the usual `-x'.

   The operation of `uulog' depends to some degree upon the type of log
files generated by the UUCP programs.  This is a compile time option.
If the UUCP programs have been compiled to use HDB style log files,
`uulog' changes in the following ways:

   * The new options `-x' and `--uuxqtlog' may be used to list the
     `uuxqt' log file.

   * It is no longer possible to omit all arguments: one of `-s',
     `--system', `-f', `--follow=system', `-D', `--debuglog', `-S',
     `--statslog', `-x', or `--uuxqtlog' must be used.

   * The option `--system ANY' may be used to list log file entries
     which do not pertain to any particular system.

Invoking uuto
=============

     uuto files... system!user

   The `uuto' program may be used to conveniently send files to a
particular user on a remote system.  It will arrange for mail to be sent
to the remote user when the files arrive on the remote system, and he or
she may easily retrieve the files using the `uupick' program (see
Invoking uupick.).  Note that `uuto' does not provide any
security--any user on the remote system can examine the files.

   The last argument specifies the system and user name to which to send
the files.  The other arguments are the files or directories to be sent.

   The `uuto' program is actually just a trivial shell script which
invokes the `uucp' program with the appropriate arguments.  Any option
which may be given to `uucp' may also be given to `uuto'.  See
Invoking uucp.

Invoking uupick
===============

     uupick [-s system] [--system system]

   The `uupick' program is used to conveniently retrieve files
transferred by the `uuto' program.

   For each file transferred by `uuto', `uupick' will display the
source system, the file name, and whether the name refers to a regular
file or a directory.  It will then wait for the user to specify an
action to take.  One of the following commands must be entered:

`q'
     Quit out of `uupick'.

`RETURN'
     Skip the file.

`m [directory]'
     Move the file or directory to the specified directory.  If no
     directory is specified, the file is moved to the current directory.

`a [directory]'
     Move all files from this system to the specified directory.  If no
     directory is specified, the files are moved to the current
     directory.

`p'
     List the file on standard output.

`d'
     Delete the file.

`! [command]'
     Execute `command' as a shell escape.

   The `-s' or `--system' option may be used to restrict `uupick' to
only present files transferred from a particular system.  The `uupick'
program also supports the standard UUCP program options; see
Standard Options.