coreutils/uudecode.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Copyright 2003, Glenn McGrath
   4  *
   5  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   6  *
   7  * Based on specification from
   8  * http://www.opengroup.org/onlinepubs/007904975/utilities/uuencode.html
   9  *
  10  * Bugs: the spec doesn't mention anything about "`\n`\n" prior to the
  11  * "end" line
  12  */
  13 //config:config UUDECODE
  14 //config:       bool "uudecode"
  15 //config:       default y
  16 //config:       help
  17 //config:         uudecode is used to decode a uuencoded file.
  18
  19 //applet:IF_UUDECODE(APPLET(uudecode, BB_DIR_USR_BIN, BB_SUID_DROP))
  20
  21 //kbuild:lib-$(CONFIG_UUDECODE) += uudecode.o
  22
  23 //usage:#define uudecode_trivial_usage
  24 //usage:       "[-o OUTFILE] [INFILE]"
  25 //usage:#define uudecode_full_usage "\n\n"
  26 //usage:       "Uudecode a file\n"
  27 //usage:       "Finds OUTFILE in uuencoded source unless -o is given"
  28 //usage:
  29 //usage:#define uudecode_example_usage
  30 //usage:       "$ uudecode -o busybox busybox.uu\n"
  31 //usage:       "$ ls -l busybox\n"
  32 //usage:       "-rwxr-xr-x   1 ams      ams        245264 Jun  7 21:35 busybox\n"
  33
  34 #include "libbb.h"
  35
  36 #if ENABLE_UUDECODE
  37 static void FAST_FUNC read_stduu(FILE *src_stream, FILE *dst_stream, int flags UNUSED_PARAM)
  38 {
  39         char *line;
  40
  41         for (;;) {
  42                 int encoded_len, str_len;
  43                 char *line_ptr, *dst;
  44                 size_t line_len;
  45
  46                 line_len = 64 * 1024;
  47                 line = xmalloc_fgets_str_len(src_stream, "\n", &line_len);
  48                 if (!line)
  49                         break;
  50                 /* Handle both Unix and MSDOS text, and stray trailing spaces */
  51                 str_len = line_len;
  52                 while (--str_len >= 0 && isspace(line[str_len]))
  53                         line[str_len] = '\0';
  54
  55                 if (strcmp(line, "end") == 0) {
  56                         return; /* the only non-error exit */
  57                 }
  58
  59                 line_ptr = line;
  60                 while (*line_ptr) {
  61                         *line_ptr = (*line_ptr - 0x20) & 0x3f;
  62                         line_ptr++;
  63                 }
  64                 str_len = line_ptr - line;
  65
  66                 encoded_len = line[0] * 4 / 3;
  67                 /* Check that line is not too short. (we tolerate
  68                  * overly _long_ line to accommodate possible extra '`').
  69                  * Empty line case is also caught here. */
  70                 if (str_len <= encoded_len) {
  71                         break; /* go to bb_error_msg_and_die("short file"); */
  72                 }
  73                 if (encoded_len <= 0) {
  74                         /* Ignore the "`\n" line, why is it even in the encode file ? */
  75                         free(line);
  76                         continue;
  77                 }
  78                 if (encoded_len > 60) {
  79                         bb_error_msg_and_die("line too long");
  80                 }
  81
  82                 dst = line;
  83                 line_ptr = line + 1;
  84                 do {
  85                         /* Merge four 6 bit chars to three 8 bit chars */
  86                         *dst++ = line_ptr[0] << 2 | line_ptr[1] >> 4;
  87                         encoded_len--;
  88                         if (encoded_len == 0) {
  89                                 break;
  90                         }
  91
  92                         *dst++ = line_ptr[1] << 4 | line_ptr[2] >> 2;
  93                         encoded_len--;
  94                         if (encoded_len == 0) {
  95                                 break;
  96                         }
  97
  98                         *dst++ = line_ptr[2] << 6 | line_ptr[3];
  99                         line_ptr += 4;
 100                         encoded_len -= 2;
 101                 } while (encoded_len > 0);
 102                 fwrite(line, 1, dst - line, dst_stream);
 103                 free(line);
 104         }
 105         bb_error_msg_and_die("short file");
 106 }
 107 #endif
 108
 109 #if ENABLE_UUDECODE
 110 int uudecode_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 111 int uudecode_main(int argc UNUSED_PARAM, char **argv)
 112 {
 113         FILE *src_stream;
 114         char *outname = NULL;
 115         char *line;
 116
 117         opt_complementary = "?1"; /* 1 argument max */
 118         getopt32(argv, "o:", &outname);
 119         argv += optind;
 120
 121         if (!argv[0])
 122                 *--argv = (char*)"-";
 123         src_stream = xfopen_stdin(argv[0]);
 124
 125         /* Search for the start of the encoding */
 126         while ((line = xmalloc_fgetline(src_stream)) != NULL) {
 127                 void FAST_FUNC (*decode_fn_ptr)(FILE *src, FILE *dst, int flags);
 128                 char *line_ptr;
 129                 FILE *dst_stream;
 130                 int mode;
 131
 132                 if (is_prefixed_with(line, "begin-base64 ")) {
 133                         line_ptr = line + 13;
 134                         decode_fn_ptr = read_base64;
 135                 } else if (is_prefixed_with(line, "begin ")) {
 136                         line_ptr = line + 6;
 137                         decode_fn_ptr = read_stduu;
 138                 } else {
 139                         free(line);
 140                         continue;
 141                 }
 142
 143                 /* begin line found. decode and exit */
 144                 mode = bb_strtou(line_ptr, NULL, 8);
 145                 if (outname == NULL) {
 146                         outname = strchr(line_ptr, ' ');
 147                         if (!outname)
 148                                 break;
 149                         outname++;
 150                         trim(outname); /* remove trailing space (and '\r' for DOS text) */
 151                         if (!outname[0])
 152                                 break;
 153                 }
 154                 dst_stream = stdout;
 155                 if (NOT_LONE_DASH(outname)) {
 156                         dst_stream = xfopen_for_write(outname);
 157                         fchmod(fileno(dst_stream), mode & (S_IRWXU | S_IRWXG | S_IRWXO));
 158                 }
 159                 free(line);
 160                 decode_fn_ptr(src_stream, dst_stream, /*flags:*/ BASE64_FLAG_UU_STOP + BASE64_FLAG_NO_STOP_CHAR);
 161                 /* fclose_if_not_stdin(src_stream); - redundant */
 162                 return EXIT_SUCCESS;
 163         }
 164         bb_error_msg_and_die("no 'begin' line");
 165 }
 166 #endif
 167
 168 //applet:IF_BASE64(APPLET(base64, BB_DIR_BIN, BB_SUID_DROP))
 169
 170 //kbuild:lib-$(CONFIG_BASE64) += uudecode.o
 171
 172 //config:config BASE64
 173 //config:       bool "base64"
 174 //config:       default y
 175 //config:       help
 176 //config:         Base64 encode and decode
 177
 178 //usage:#define base64_trivial_usage
 179 //usage:        "[-d] [FILE]"
 180 //usage:#define base64_full_usage "\n\n"
 181 //usage:       "Base64 encode or decode FILE to standard output"
 182 //usage:     "\n        -d      Decode data"
 183 ////usage:     "\n      -w COL  Wrap lines at COL (default 76, 0 disables)"
 184 ////usage:     "\n      -i      When decoding, ignore non-alphabet characters"
 185
 186 #if ENABLE_BASE64
 187 int base64_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 188 int base64_main(int argc UNUSED_PARAM, char **argv)
 189 {
 190         FILE *src_stream;
 191         unsigned opts;
 192
 193         opt_complementary = "?1"; /* 1 argument max */
 194         opts = getopt32(argv, "d");
 195         argv += optind;
 196
 197         if (!argv[0])
 198                 *--argv = (char*)"-";
 199         src_stream = xfopen_stdin(argv[0]);
 200         if (opts) {
 201                 read_base64(src_stream, stdout, /*flags:*/ (char)EOF);
 202         } else {
 203                 enum {
 204                         SRC_BUF_SIZE = 76/4*3,  /* This *MUST* be a multiple of 3 */
 205                         DST_BUF_SIZE = 4 * ((SRC_BUF_SIZE + 2) / 3),
 206                 };
 207                 char src_buf[SRC_BUF_SIZE];
 208                 char dst_buf[DST_BUF_SIZE + 1];
 209                 int src_fd = fileno(src_stream);
 210                 while (1) {
 211                         size_t size = full_read(src_fd, src_buf, SRC_BUF_SIZE);
 212                         if (!size)
 213                                 break;
 214                         if ((ssize_t)size < 0)
 215                                 bb_perror_msg_and_die(bb_msg_read_error);
 216                         /* Encode the buffer we just read in */
 217                         bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
 218                         xwrite(STDOUT_FILENO, dst_buf, 4 * ((size + 2) / 3));
 219                         bb_putchar('\n');
 220                         fflush(stdout);
 221                 }
 222         }
 223
 224         fflush_stdout_and_exit(EXIT_SUCCESS);
 225 }
 226 #endif
 227
 228 /* Test script.
 229 Put this into an empty dir with busybox binary, an run.
 230
 231 #!/bin/sh
 232 test -x busybox || { echo "No ./busybox?"; exit; }
 233 ln -sf busybox uudecode
 234 ln -sf busybox uuencode
 235 >A_null
 236 echo -n A >A
 237 echo -n AB >AB
 238 echo -n ABC >ABC
 239 echo -n ABCD >ABCD
 240 echo -n ABCDE >ABCDE
 241 echo -n ABCDEF >ABCDEF
 242 cat busybox >A_bbox
 243 for f in A*; do
 244     echo uuencode $f
 245     ./uuencode    $f <$f >u_$f
 246     ./uuencode -m $f <$f >m_$f
 247 done
 248 mkdir unpk_u unpk_m 2>/dev/null
 249 for f in u_*; do
 250     ./uudecode <$f -o unpk_u/${f:2}
 251     diff -a ${f:2} unpk_u/${f:2} >/dev/null 2>&1
 252     echo uudecode $f: $?
 253 done
 254 for f in m_*; do
 255     ./uudecode <$f -o unpk_m/${f:2}
 256     diff -a ${f:2} unpk_m/${f:2} >/dev/null 2>&1
 257     echo uudecode $f: $?
 258 done
 259 */