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(5) 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(5) 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 %s0 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
, mode, decode_pathname

       and ends with the line:

       end


       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  exam-
       ple, 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 sig-
       nificant 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(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWesu			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Standard			   |
       +-----------------------------+-----------------------------+

SEE ALSO

       mail(1), mailx(1), uucp(1C), uux(1C), attributes(5), environ(5), largefile(5), standards(5)

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.

SunOS 5.10							    6 Aug 2003							      uuencode(1C)