Go Back    


Recursive Search Engine for Linux and Unix Man Pages by Neo
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

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_path-
       name 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 con-
		     tained in the input data. Specifying an outfile option-argument of /dev/std-
		     out 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 encoun-
       tering 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  con-
       catenating three 8-bit input groups. Each 24-bit input group  is then treated as four con-
       catenated 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 print-
       able 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 mes-
       sage 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  posi-
       tions that are not required to represent actual input data are set to the equals (=) char-
       acter. 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  charac-
       ters  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 cur-
       rent 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(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), stan-
       dards(5)

NOTES
       The size of the encoded file is expanded by 35% (3 bytes become 4, plus	control  informa-
       tion), 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.11				    6 Aug 2003				     uuencode(1C)
The UNIX and Linux Forums Man Pages : 2014 The UNIX and Linux Forums


All times are GMT -4. The time now is 01:44 AM.