Editing UUCP (section)

==Technology==
Before the widespread availability of [[Internet access]], computers were only connected by smaller [[local area network]]s within a company or organization. They were also often equipped with [[modems]] so they could be used remotely from [[Character terminal#Dumb terminal|character-mode terminals]] via [[dial-up]] [[plain old telephone service|telephone lines]]. UUCP used the computers' modems to dial out to other computers, establishing temporary, point-to-point links between them. Each system in a UUCP network has a list of neighbor systems, with phone numbers, login names and passwords, etc.  When ''work'' (file transfer or command execution requests) is queued for a neighbor system, the {{code|uucico}} program typically calls that system to process the work. The {{code|uucico}} program can also poll its neighbors periodically to check for work queued on their side; this permits neighbors without dial-out capability to participate.

Over time, dial-up links were replaced by Internet connections, and UUCP added a number of new [[link layer]] protocols. These newer connections also reduced the need for UUCP at all, as newer application protocols developed to take advantage of the new networks. Today, UUCP is rarely used over dial-up links, but is occasionally used over [[Internet protocol suite|TCP/IP]].<ref>{{cite web
|url=http://www.airs.com/ian/uucp-doc/uucp_7.html#SEC99
|title=UUCP 'f' Protocol
|access-date=2008-08-04
|author=Ian Lance Taylor
|date=June 2003
|archive-date=2008-07-18
|archive-url=https://web.archive.org/web/20080718235206/http://www.airs.com/ian/uucp-doc/uucp_7.html#SEC99
|url-status=live
}}</ref><ref name=UUCPssh>{{cite web
|url=http://uucpssh.org/
|title=UUCPssh
|access-date=2009-08-09
|author=Fabien Penso
|url-status=usurped
|archive-url=https://web.archive.org/web/20090930074051/http://www.uucpssh.org/
|archive-date=2009-09-30
}}</ref> 
The number of systems involved, as of early 2006, ran between 1500 and 2000 sites across 60 enterprises. UUCP's longevity can be attributed to its low cost, extensive logging, native [[failover]] to dialup, and persistent queue management.

===Sessions===
UUCP is normally started by having a user log into the target system and then running the UUCP program. In most cases, this is automated by logging into a known user account used for transfers, whose account's shell has been set to {{code|uucico}}. Thus, for automated transfers, another machine simply has to open a modem connection to the called machine and log into the known account.

When uucico runs, it will expect to receive commands from another UUCP program on the caller's machine and begin a session. The session has three distinct stages:

# Initial handshake
# File request(s)
# Final handshake

====Initial handshake====
On starting, uucico will respond by sending an identification string, <code>\20Shere=''hostname''\0</code>, where \20 is the control-P character, and \0 is a trailing null. The caller's UUCP responds with <code>\20S''callername'' ''options''\0</code>, where ''options'' is a string containing zero or more Unix-like option switches. These can include packet and window sizes, the maximum supported file size, debugging options, and others.

Depending on the setup of the two systems, the call may end here. For instance, when the caller responds with their system name, the called system may optionally hang up if it does not recognize the caller, sending the <code>RYou are unknown to me\0</code> response string and then disconnecting.

====File requests====
If the two systems successfully handshake, the caller will now begin to send a series of file requests. There are four types:

:'''S''' causes a file to be Sent from the caller to the called system (upload). The from and to names are provided, allowing the filename to be changed on the receiver. When the S command is received on the called system, it responds with SY if it succeeded and it is ready to accept the file, or SNx if it failed, where x is a failure code. If an SY is received by the caller, it begins uploading the file using the protocol selected during the initial handshake (see below). When the transfer is complete, the called system responds with CY if it successfully received the file, or CN5 if it failed.
:'''R''' is a Request for the called system to send a file to the caller (download). It is otherwise similar to S, using RY and RN to indicate the command was accepted and it will begin to send data or had a problem, and expecting a CY and CN5 from the caller at the end of the transfer.
:'''X''' uploads commands to be eXecuted on the called system. This can be used to make that system call another and deliver files to it. The called system responds with XY if it succeeded, or XN if it failed.
:'''H''', for Hangup, indicates the caller is done. The called system responds with HY if it succeeded, or HN if it failed.

====Final handshake====
After sending an H command, the calling system sends a final packet {{code|\20OOOOOO\0}} (control-P, six ohs, null-terminator) and the called system responds with {{code|\20OOOOOO\0}} (control-P, seven ohs, null-terminator). Some systems will simply hang up on the successful reception of the H command and not bother with the final handshake.

===g-protocol===
Within the suite of protocols in UUCP, the underlying g-protocol is responsible for transferring information in an error-free form. The protocol originated as a general-purpose system for packet delivery, and thus offers a number of features that are not used by the UUCP package as a whole. These include a secondary channel that can send command data interspersed with a file transfer, and the ability to renegotiate the packet and window sizes during transmission. These extra features may not be available in some implementations of the UUCP stack.<ref name=faq>{{cite web |url=http://www.math.utah.edu/docs/info/uucp_5.html |title=UUCP Internals Frequently Asked Questions |first=Ian Lance |last=Taylor |date=8 March 1996 |access-date=29 August 2020 |archive-date=6 November 2019 |archive-url=https://web.archive.org/web/20191106212355/http://www.math.utah.edu/docs/info/uucp_5.html |url-status=live }}</ref>

The packet format consisted of a 6-byte header and then between zero and 4096 bytes in the payload. The packet starts with a single \020 (control-P). This is followed by a single byte, known as "K", containing a value of 1 to 8 indicating a packet size from 32 to 4096 bytes, or a 9 indicating a control packet. Many systems only supported K=2, meaning 64 bytes. The next two bytes were a 16-bit checksum of the payload, not including the header. The next byte is the data type and finally, the last byte is the XOR of the header, allowing it to be checked separately from the payload.<ref name=faq/>

The control byte consists of three bit-fields in the format TTXXXYYY. TT is the packet type, 0 for control packets (which also requires K=9 to be valid), 1 for alternate data (not used in UUCP), 2 for data, and 3 indicates a short packet that re-defines the meaning of K. In a data packet, XXX is the packet number for this packet from 0 to 7, and YYY is the last that was received correctly. This provides up to 8 packets in a window. In a control packet, XXX indicates the command and YYY is used for various parameters. For instance, transfers are started by sending a short control packet with TT=0 (control), XXX=7 and YYY the number of packets in a window, then sending another packet with XXX=6 and YYY as the packet length (encoded as it would be in K) and then a third packet that is identical to the first but XXX=5.<ref name=faq/>

g-protocol uses a simple [[sliding window]] system to deal with potentially long latencies between endpoints. The protocol allows packets to size from 32 to 4096 8-bit bytes, and windows that include 1 to 7 packets. In theory, a system using 4k packets and 7 packet windows (4096x7) would offer performance matching or beating the best file-transfer protocols like [[ZMODEM]]. In practice, many early implementations only supported a single setting of 64x3. As a result, the g-protocol has an undeserved reputation for poor performance. Confusion over the packet and window sizes led to the G-protocol, differing only in that it always used 4096x3. Taylor UUCP did not support G, but did support any valid requested window or packet size, so remote systems starting G would work fine with Taylor's g, while two Taylor systems could negotiate even faster connections.<ref name=faq/>

[[Telebit]] modems used [[protocol spoofing]] to improve the performance of g-protocol transfers by noticing end-of-packet markers being sent to the remote system and immediately sending an {{code|ACK}} back to the local host, pretending that the remote system had already received the packet and decoded it correctly. This triggered the software stack on the local computer to send the next packet, so rapidly that the transfer became almost continuous. The data between the two modems was error-corrected using a proprietary protocol based on [[Microcom Networking Protocol|MNP]] that ran over Telebit's half-duplex connections much better than g-protocol would normally,<ref name=faq/> because in the common 64x3 case the remote system would be sending a constant stream of {{code|ACK}}s that would overflow the low-speed return channel. Combined with the modem's naturally higher data rates, up to 23&nbsp;kbps, they greatly improved overall throughput and generally performed about seven times the speed of a 2400 bit/s modem.<ref>{{cite web |url=http://www.umich.edu/~archive/mac/misc/documentation/telecomminfo.txt |title=What You Need To Know About Modems |first=Kenneth |last=Kirksey |date=25 December 1991 |quote=The actual throughput is around 14400 bps. |access-date=29 August 2020 |archive-date=24 October 2020 |archive-url=https://web.archive.org/web/20201024183419/http://www.umich.edu/~archive/mac/misc/documentation/telecomminfo.txt |url-status=live }}</ref> They were widely used on UUCP hosts as they could quickly pay for themselves in reduced long-distance charges.

===Other protocols===
UUCP implementations also include other transfer protocols for use over certain links.

'''f-protocol''' is designed to run over 7-bit error-corrected links. This was originally intended for use on [[X.25]] links, which were popular for a time in the 1980s. It does not packetize data, instead, the entire file is sent as a single long string followed by a whole-file checksum. The similar '''x-protocol''' appears to have seen little or no use. '''d-protocol''' was similar to x, but intended for use on [[Datakit]] networks that connected many of [[Bell Labs]] offices.<ref name=faq/>

'''t-protocol''' originated in the BSD versions of UUCP and like some similar ones, is designed to run over 8-bit error-free [[TCP/IP]] links. It has no error correction at all, and the protocol consists simply of breaking up command and file data into 512 or 1024-byte packets to easily fit within typical TCP frames.

'''e-protocol''' ("e" for Ethernet) was developed by Clem Cole at [[MASSCOMP]] and was widely released by Brian Redman in the later HoneyDanBer versions.  It was developed and released before the t-protocol, but the t-protocol was more commonly used because the BSD version of UUCP was the dominant implementation. The e-protocol differs from the t-protocol only in that commands are not packetized and are instead sent as normal strings, while files are padded to the nearest 20 bytes.<ref name=faq/><ref name=masscomp-uucpmgmt>{{Cite book | title=UUCP Management Guide, Rev C |first=Stephen |last=Talbot |date=February 1988  |series=User Manuals |number=M-UUCP-MG |publisher=Massachusetts Computer Corporation }}</ref>