uucp_intro - UNIX-to-UNIX Copy Program (UUCP) introductory
information
The UNIX-to-UNIX Copy Program (UUCP) is a group of programs
that support communications between two computers
running UNIX operating systems.
Tru64 UNIX supports the HoneyDanBer version of UUCP. The
UUCP system enables batched, error-free file transfer and
remote command execution between two UNIX systems. The
UUCP system is most frequently used to transfer electronic
mail, network news, and public domain software over lowspeed,
low-cost communications links.
A worldwide network that functions through the informal
cooperation of the user community has grown up around
UUCP. The UUCP network is a series of point-to-point
links, with the majority of sites located in Europe and
North America.
The UUCP protocol itself supports only direct connections
between two systems. However, electronic news and mail
delivery depend on third-party forwarding. To facilitate
mail and news delivery, most connected sites are willing
to relay files for other sites. The UUCP network depends
on direct distance dialing networks and off-peak long distance
rates for its continued functioning.
The UUCP Software [Toc] [Back]
The UUCP software contains the following components: System
directories that contain UUCP files and programs.
Configuration files that contain information needed to
establish remote connections and determine access permissions.
These files are used to describe the UUCP operating
environment to the uucico daemon. Configuration
files specify, for example, remote system names,
times of data transfer, valid login names, passwords,
and the commands that can be executed on a
system. Administrative files that are used primarily
in transferring data between computers
Log files record both successful and failed data
transfers by the administrative files. Logs can
occupy much disk space unless you regularly delete
some of them. The UUCP system provides facilities
for pruning log files.
Spool or queue files contain the data and transfer
requests that are issued from the uucp and uucico
commands. There are several types of spool files:
Execution files are generated only by the uux command.
They contain the commands to be executed on
the remote system. By convention, execution files
are named X.filename. Command files are created by
both the uucp and uux commands. They contain commands
for transferring files to remote systems. By
convention, command files are named C.filename.
Data files contain the data that is transferred to
remote systems. They are created by the uucp and
uux commands. By convention, data files are named
D.filename. Public directories that contain the
files transferred by UUCP. User commands that perform
the basic UUCP functions, such as file transfer
and remote command execution.
The uucp and uux commands allow remote file copy
and command execution, respectively. Both commands
allow users to specify remote system names in pathnames.
The uucp and cp commands use similar syntax. However,
cp works immediately and copies files on the
local system, while uucp operates in batch mode and
allows file transfers between two systems. User
requests are queued to public spool files where
they wait for further processing by the uucico daemon
(UNIX-to-UNIX copy-in, copy-out program).
The uux command provides a shell-like environment
for issuing commands on remote systems. As the user
works, the uux command generates an execute file
that is sent to a spool directory to await transfer
to a remote system. Administrative commands, such
as programs that enable you to configure and maintain
UUCP. Daemon programs that handle file transfers,
communications with TCP/IP, scheduling of
work, and remote command executions.
The uucico daemon, together with its subprocesses,
manages machine-to-machine communications. It works
through control and log files, as well as a set of
public directories that contain the requests generated
by the uucp and uux commands.
The UUCP system can use any of several physical and transport
layer protocols. The uucico daemon supports both
direct and remote connections through a serial interface.
Typically, remote connections use modems and direct distance
dialing networks. The UUCP system uses error-correcting
modem protocols to ensure data integrity during
transfer.
The uucpd daemon supports UUCP over TCP/IP networks. It
performs login and password authentication before it
starts the uucico daemon. This configuration option allows
you to take advantage of high-speed local area networks in
order to do batched file transfers. Note that TCP/IP does
not replace UUCP protocols; it serves as a transport mechanism
only.
Because users on remote systems can log in, transfer
files, and execute commands, UUCP is a potential security
problem for the local system. The UUCP system does provide
a means to restrict what users can do on the local system,
and likewise local UUCP users can be similarly restricted
by remote systems.
Although many installations use UUCP to support electronic
mail and news only, UUCP is not restricted to these uses.
For systems without LAN connections, UUCP can provide data
transfer capabilities not otherwise available.
The UUCP File and Directory Structure [Toc] [Back]
The UUCP system uses several directories and files to
track its activities. These directories and files
include: Public directories with unrestricted access
rights Administrative directories and subfiles Configuration
files Lock files
Most UUCP directories and files are included when the
software is installed. Some administrative files are created
by various UUCP programs as they run.
The UUCP public directory (/var/spool/uucppublic) contains
files transferred to the local system from other systems.
The files remain in the public directory until users claim
them or until the commands requested by users on remote
systems are executed by the uuxqt daemon. If the files
were sent to the UUCP public directory with the uuto command,
the user must claim them with the uupick command.
Otherwise they can copy the files from that directory manually.
The uucppublic directory, which contains a subdirectory
for each remote system that sends files to the
local system, is created when UUCP is installed.
The UUCP configuration files reside in the /usr/lib/uucp
directory. You configure these files for systems at your
site. You must configure the following files: Systems
Devices Permissions
Configuring the other files is optional.
The configuration files contain information about remote
systems contacted by UUCP, the devices used to contact
these systems, the times to contact the systems, and the
level of access that remote systems can have to the local
system. Some configuration files also specify limits on
UUCP activities to prevent the local system from becoming
overloaded.
For details about UUCP configuration files, refer to the
Network Administration: Services manual.
Whenever UUCP connects to a remote computer, it makes a
lock file for both the local and remote communication
devices in the /var/spool/locks directory. Lock files on
remote devices prevent other instances of the uucico daemon
from establishing duplicate connections to the same
remote system. When a local device contains a lock file,
UUCP waits until the device becomes available, or it uses
another device for communications.
The UUCP Daemons [Toc] [Back]
Normally, on an OSF/1 system, UUCP components reside in
the /usr/adm, /usr/lbin, and /etc/uucp directories. However,
on the Tru64 UNIX system, the UUCP daemons are
stored in the /usr/lib/uucp directory, except for the
uucpd daemon, which is stored in the /usr/sbin directory.
The following table lists the daemons and their functions.
--------------------------------------------------
Name Function
--------------------------------------------------
uucico Manages file transfers
uusched Manages job scheduling
uuxqt Performs remote command execution
uucpd Enables UUCP connections through TCP/IP
--------------------------------------------------
In a typical configuration, the cron daemon automatically
starts the uucico, uusched, and uuxqt commands according
to a schedule set by the system administrator. For testing
and debugging the UUCP configuration, the daemons also can
be started by someone with superuser privileges.
See cron(8) for more information.
The uucico Daemon [Toc] [Back]
The uucico daemon transports the files required to send
data from one UNIX system to another UNIX system. Most
UUCP directories are created when UUCP is installed; however,
the uucico daemon also creates some files during its
operation. The uucico daemon performs the following tasks:
Scans spool directories for jobs Contacts remote systems
at times you specify Selects data transfer protocols
Exchanges jobs with remote systems Logs jobs requested and
completed
When the uucico daemon initiates contact with remote systems,
it operates in master mode. In this mode, the uucico
daemon starts another slave process on the remote system.
When it operates in master mode, the uucico daemon
attempts to process jobs queued on its local system; in
slave mode the uucico daemon carries out requests made by
a remote uucico process. Once the uucico daemon is finished
processing its locally queued jobs on the remote
system, the two processes can switch their roles as master
and slave in order to exchange data in both directions.
The uucp and uux commands each start the uucico daemon to
transfer command, data, and execute files to the designated
system. The uucico daemon is also started periodically
by the uusched daemon, which handles the transfer of
files queued in the local spooling directory.
Once started by the uusched daemon, the uucico daemon
attempts to contact other systems and execute the instructions
in the command files. To execute those instructions,
the uucico daemon checks the /usr/lib/uucp/Systems
file to find an entry for the system to be called. Then,
it checks the Systems file entry to see if the current
time is a valid time to call. If so, it checks the Type
and Class fields in the Systems file, and searches the
/usr/lib/uucp/Devices file to find a device that matches
these fields.
After it finds a device, the uucico daemon checks the
/var/spool/locks directory to ensure that the device is
not locked by another process. If the device is locked,
the daemon checks for another device of the requested type
and speed, and uses it, if available.
When no device is available, the daemon returns to the
Systems file to find another entry for the remote system.
If one exists, the daemon repeats the process of searching
for a device. If none is found, the daemon records the
attempt to contact the remote system in the file
/var/spool/uucp/.Status/SystemName and goes on to process
the next request. The command file remains in the queue,
and the uucico daemon repeats the transfer attempt.
When the uucico daemon reaches the remote system, it logs
in using the information in the local Systems file pertaining
to the remote system file. Logging in causes an
instance of the uucico daemon to be invoked on the remote
system.
The two daemons, one on each system, work together to make
the transfer. The uucico daemon on the calling system
controls the link, specifying the requests to be performed.
The uucico daemon on the remote system checks the
local permissions to see whether they allow the request to
be performed. If so, the file transfer starts.
After the uucico daemon on the calling system finishes
transferring all the requests it has for the remote system,
it sends a hang-up request. When the remote uucico
daemon has transactions to send to the calling system, it
denies the hang-up request, and the two daemons reverse
roles.
The /usr/lib/uucp/Permissions file on either the local or
the remote system can forbid the daemons to reverse roles.
In such cases, the remote system must wait to transfer
files until it calls the local system. When nothing is
left to be transferred in either direction, the two daemons
hang up. Throughout the transfer process, the uucico
daemons on both systems write messages in UUCP log and
error files.
The uusched Daemon [Toc] [Back]
The uusched daemon schedules the transfer of files that
are queued in the local spooling directory
/var/spool/uucp. When the uusched daemon is invoked, it
scans the spooling directory for command files, then randomizes
the files and starts the uucico daemon, which
actually transfers the files.
The uuxqt Daemon [Toc] [Back]
The uuxqt daemon interprets execution files created on a
remote system and transferred to the local system by the
uucico daemon. Normally, the uucico daemon starts the
uuxqt process to execute queued X* files. The uuxqt daemon
searches the spool directory for command execution
requests. When it locates such a request, the uuxqt daemon
checks for necessary files and permissions and then, if
permitted, executes the specified command.
The uucpd Daemon [Toc] [Back]
The uucpd daemon handles communications between UUCP and
TCP/IP. This daemon enables users on systems linked over a
local area network to establish UUCP connections to other
systems. Its job is to perform login authentication before
transferring control to the uucico daemon, which completes
the data transfer. The uucpd daemon is started by the
inetd daemon, after configuring the /etc/inetd.conf and
/etc/services files, and is not required to be running on
the local side.
For details, refer to the Network Administration: Services
manual.
Commands: ct(1) ,cu , tip(1) ,uucico , uucleanup(8), uuencode(1), uulog(1), uuname(1), uupick(1), uusched(8),
uusend(1), uustat(1), uuto(1), uux(1), uuxqt(1)
Network Administration: Services
uucp_intro(7)
[ Back ] |
