UUENCODE(1C) Communication Commands UUENCODE(1C)
NAME
uuencode, uudecode - encode a binary file, or decode its encoded
representation
SYNOPSIS
uuencode [
source-file]
decode_pathname uuencode [
-m] [
source-file]
decode_pathname uudecode [
-p] [
encoded-file]
uudecode [
-o outfile] [
encoded-file]
DESCRIPTION
These commands encode and decode files as follows:
uuencode The
uuencode utility converts a binary file into an encoded
representation that can be sent using
mail(1). It encodes the contents of
source-file, or the standard input if no
source-file argument is given.
The
decode_pathname argument is required. The
decode_pathname is included
in the encoded file's header as the name of the file into which
uudecode is to place the binary (decoded) data.
uuencode also includes the
permission modes of
source-file (except
setuid,
setgid, and sticky-bits),
so that
decode_pathname is recreated with those same permission modes.
uudecode The
uudecode utility reads an
encoded-file, strips off any leading and
trailing lines added by mailer programs, and recreates the original
binary data with the filename and the mode specified in the header.
The encoded file is an ordinary portable character set text file; it can
be edited by any text editor. It is best only to change the mode or
decode_pathname in the header to avoid corrupting the decoded binary.
OPTIONS
The following options are supported:
uuencode -m Encodes
source-file using Base64 encoding and sends it to standard
output.
uudecode -o outfile Specifies a file pathname that should be used instead of
any pathname contained in the input data. Specifying an
outfile option-argument of
/dev/stdout indicates standard
output.This allows
uudecode to be used in a pipeline.
-p Decodes
encoded-file and sends it to standard output. This
allows
uudecode to be used in a pipeline.
OPERANDS
The following operands are supported by
uuencode and
uudecode:
uuencode decode_pathname The pathname of the file into which the
uudecode utility will place the decoded file. If there are
characters in
decode_pathname that are not in the
portable filename character set, the results are
unspecified.
source-file A pathname of the file to be encoded.
uudecode encoded-file The pathname of a file containing the output of
uuencode.
USAGE
See
largefile(7) for the description of the behavior of
uuencode and
uudecode when encountering files greater than or equal to 2 Gbyte ( 2^31
bytes).
ENVIRONMENT VARIABLES
See
environ(7) for descriptions of the following environment variables
that affect the execution of
uuencode and
uudecode:
LANG,
LC_ALL,
LC_CTYPE,
LC_MESSAGES, and
NLSPATH.
OUTPUT
stdout
uuencode Base64 Algorithm The standard output is a text file, encoded in the character set of the
current locale, that begins with the line:
begin-base64 %s %s\n,
mode,
decode_pathname and ends with the line:
====
In both cases, the lines have no preceding or trailing blank characters.
The encoding process represents 24-bit groups of input bits as output
strings of four encoded characters. Proceeding from left to right, a
24-bit input group is formed by concatenating three 8-bit input groups.
Each 24-bit input group is then treated as four concatenated 6-bit
groups, each of which is translated into a single digit in the Base64
alphabet. When encoding a bit stream by means of the Base64 encoding, the
bit stream is presumed to be ordered with the most-significant bit first.
That is, the first bit in the stream is the high-order bit in the first
byte, and the eighth bit is the low-order bit in the first byte, and so
on. Each 6-bit group is used as an index into an array of 64 printable
characters, as shown in the following table.
Value Encoding Value Encoding Value Encoding Value Encoding
0 A 17 R 34 i 51 z
1 B 18 S 35 j 52 0
2 C 19 T 36 k 53 1
3 D 20 U 37 l 54 2
4 E 21 V 38 m 55 3
5 F 22 W 39 n 56 4
6 G 23 X 40 o 57 5
7 H 24 Y 41 p 58 6
8 I 25 Z 42 q 59 7
9 J 26 a 43 r 60 8
10 K 27 b 44 s 61 9
11 L 28 c 45 t 62 +
12 M 29 d 46 u 63 /
13 N 30 e 47 v
14 O 31 f 48 w (pad) =
15 P 32 g 49 x
16 Q 33 h 50 y
The character referenced by the index is placed in the output string.
The output stream (encoded bytes) is represented in lines of no more than
76 characters each. All line breaks or other characters not found in the
table are ignored by decoding software (see
uudecode).
Special processing is performed if fewer than 24 bits are available at
the end of a message or encapsulated part of a message. A full encoding
quantum is always completed at the end of a message. When fewer than 24
input bits are available in an input group, zero bits are added on the
right to form an integral number of 6-bit groups. Output character
positions that are not required to represent actual input data are set to
the equals (
=) character. Since all Base64 input is an integral number of
octets, only the following cases can arise:
1. The final quantum of encoding input is an integral multiple of
24 bits. Here, the final unit of encoded output is an
integral multiple of four characters with no '
= ' padding.
2. The final quantum of encoding input is exactly 16 bits. Here,
the final unit of encoded output is three characters followed
by one '
=' padding character.
3. The final quantum of encoding input is exactly 8 bits. Here,
the final unit of encoded output is two characters followed by
two '
=' padding characters.
A terminating "
====" evaluates to nothing and denotes the end of the
encoded data.
uuencode Historical Algorithm The standard output is a text file (encoded in the character set of the
current locale) that begins with the line:
begin %s %s\n,
mode,
decode_pathname and ends with the line:
end\n
In both cases, the lines have no preceding or trailing blank characters.
The algorithm that is used for lines between
begin and
end takes three
octets as input and writes four characters of output by splitting the
input at six-bit intervals into four octets, containing data in the lower
six bits only. These octets are converted to characters by adding a value
of
0x20 to each octet, so that each octet is in the range
0x20-0x5f, and
each octet is assumed to represent a printable character. Each octect is
then translated into the corresponding character codes for the codeset in
use in the current locale. For example, the octet
0x41, representing '
A',
would be translated to '
A' in the current codeset, such as
0xc1 if the
codeset were
EBCDIC.
Where the bits of two octets are combined, the least significant bits of
the first octet are shifted left and combined with the most significant
bits of the second octet shifted right. Thus, the three octets
A,
B,
C are converted into the four octets:
0x20 + (( A >> 2 ) & 0x3F)
0x20 + (((A << 4) ((B >> 4) & 0xF)) & 0x3F)
0x20 + (((B << 2) ((C >> 6) & 0x3)) & 0x3F)
0x20 + (( C ) & 0x3F)
These octets are then translated into the local character set.
Each encoded line contains a length character, equal to the number of
characters to be decoded plus
0x20 translated to the local character set
as described above, followed by the encoded characters. The maximum
number of octets to be encoded on each line is 45.
EXIT STATUS
The following exit values are returned:
0 Successful completion.
>0 An error occurred.
ATTRIBUTES
See
attributes(7) for descriptions of the following attributes:
+--------------------+-----------------+
| ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+--------------------+-----------------+
|Interface Stability | Standard |
+--------------------+-----------------+
SEE ALSO
mail(1),
mailx(1),
uucp(1C),
uux(1C),
attributes(7),
environ(7),
largefile(7),
standards(7)NOTES
The size of the encoded file is expanded by 35% (3 bytes become 4, plus
control information), causing it to take longer to transmit than the
equivalent binary.
The user on the remote system who is invoking
uudecode (typically
uucp)
must have write permission on the file specified in the
decode_pathname.
If you invoke
uuencode and then execute
uudecode on a file in the same
directory, you will overwrite the original file.
September 10, 2013
UUENCODE(1C)