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 #include "libbb.h"
  14
  15 #if ENABLE_UUDECODE
  16 static void FAST_FUNC read_stduu(FILE *src_stream, FILE *dst_stream, int flags UNUSED_PARAM)
  17 {
  18         char *line;
  19
  20         while ((line = xmalloc_fgetline(src_stream)) != NULL) {
  21                 int encoded_len, str_len;
  22                 char *line_ptr, *dst;
  23
  24                 if (strcmp(line, "end") == 0) {
  25                         return; /* the only non-error exit */
  26                 }
  27
  28                 line_ptr = line;
  29                 while (*line_ptr) {
  30                         *line_ptr = (*line_ptr - 0x20) & 0x3f;
  31                         line_ptr++;
  32                 }
  33                 str_len = line_ptr - line;
  34
  35                 encoded_len = line[0] * 4 / 3;
  36                 /* Check that line is not too short. (we tolerate
  37                  * overly _long_ line to accomodate possible extra '`').
  38                  * Empty line case is also caught here. */
  39                 if (str_len <= encoded_len) {
  40                         break; /* go to bb_error_msg_and_die("short file"); */
  41                 }
  42                 if (encoded_len <= 0) {
  43                         /* Ignore the "`\n" line, why is it even in the encode file ? */
  44                         free(line);
  45                         continue;
  46                 }
  47                 if (encoded_len > 60) {
  48                         bb_error_msg_and_die("line too long");
  49                 }
  50
  51                 dst = line;
  52                 line_ptr = line + 1;
  53                 do {
  54                         /* Merge four 6 bit chars to three 8 bit chars */
  55                         *dst++ = line_ptr[0] << 2 | line_ptr[1] >> 4;
  56                         encoded_len--;
  57                         if (encoded_len == 0) {
  58                                 break;
  59                         }
  60
  61                         *dst++ = line_ptr[1] << 4 | line_ptr[2] >> 2;
  62                         encoded_len--;
  63                         if (encoded_len == 0) {
  64                                 break;
  65                         }
  66
  67                         *dst++ = line_ptr[2] << 6 | line_ptr[3];
  68                         line_ptr += 4;
  69                         encoded_len -= 2;
  70                 } while (encoded_len > 0);
  71                 fwrite(line, 1, dst - line, dst_stream);
  72                 free(line);
  73         }
  74         bb_error_msg_and_die("short file");
  75 }
  76 #endif
  77
  78 #if ENABLE_UUDECODE
  79 int uudecode_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  80 int uudecode_main(int argc UNUSED_PARAM, char **argv)
  81 {
  82         FILE *src_stream;
  83         char *outname = NULL;
  84         char *line;
  85
  86         opt_complementary = "?1"; /* 1 argument max */
  87         getopt32(argv, "o:", &outname);
  88         argv += optind;
  89
  90         if (!argv[0])
  91                 *--argv = (char*)"-";
  92         src_stream = xfopen_stdin(argv[0]);
  93
  94         /* Search for the start of the encoding */
  95         while ((line = xmalloc_fgetline(src_stream)) != NULL) {
  96                 void FAST_FUNC (*decode_fn_ptr)(FILE *src, FILE *dst, int flags);
  97                 char *line_ptr;
  98                 FILE *dst_stream;
  99                 int mode;
 100
 101                 if (strncmp(line, "begin-base64 ", 13) == 0) {
 102                         line_ptr = line + 13;
 103                         decode_fn_ptr = read_base64;
 104                 } else if (strncmp(line, "begin ", 6) == 0) {
 105                         line_ptr = line + 6;
 106                         decode_fn_ptr = read_stduu;
 107                 } else {
 108                         free(line);
 109                         continue;
 110                 }
 111
 112                 /* begin line found. decode and exit */
 113                 mode = bb_strtou(line_ptr, NULL, 8);
 114                 if (outname == NULL) {
 115                         outname = strchr(line_ptr, ' ');
 116                         if ((outname == NULL) || (*outname == '\0')) {
 117                                 break;
 118                         }
 119                         outname++;
 120                 }
 121                 dst_stream = stdout;
 122                 if (NOT_LONE_DASH(outname)) {
 123                         dst_stream = xfopen_for_write(outname);
 124                         fchmod(fileno(dst_stream), mode & (S_IRWXU | S_IRWXG | S_IRWXO));
 125                 }
 126                 free(line);
 127                 decode_fn_ptr(src_stream, dst_stream, /*flags:*/ BASE64_FLAG_UU_STOP + BASE64_FLAG_NO_STOP_CHAR);
 128                 /* fclose_if_not_stdin(src_stream); - redundant */
 129                 return EXIT_SUCCESS;
 130         }
 131         bb_error_msg_and_die("no 'begin' line");
 132 }
 133 #endif
 134
 135 //applet:IF_BASE64(APPLET(base64, _BB_DIR_BIN, _BB_SUID_DROP))
 136
 137 //kbuild:lib-$(CONFIG_BASE64) += uudecode.o
 138
 139 //config:config BASE64
 140 //config:       bool "base64"
 141 //config:       default y
 142 //config:       help
 143 //config:         Base64 encode and decode
 144
 145 //usage:#define base64_trivial_usage
 146 //usage:        "[-d] [FILE]"
 147 //usage:#define base64_full_usage "\n\n"
 148 //usage:       "Base64 encode or decode FILE to standard output"
 149 //usage:     "\nOptions:"
 150 //usage:     "\n        -d      Decode data"
 151 ////usage:     "\n      -w COL  Wrap lines at COL (default 76, 0 disables)"
 152 ////usage:     "\n      -i      When decoding, ignore non-alphabet characters"
 153
 154 #if ENABLE_BASE64
 155 int base64_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 156 int base64_main(int argc UNUSED_PARAM, char **argv)
 157 {
 158         FILE *src_stream;
 159         unsigned opts;
 160
 161         opt_complementary = "?1"; /* 1 argument max */
 162         opts = getopt32(argv, "d");
 163         argv += optind;
 164
 165         if (!argv[0])
 166                 *--argv = (char*)"-";
 167         src_stream = xfopen_stdin(argv[0]);
 168         if (opts) {
 169                 read_base64(src_stream, stdout, /*flags:*/ (char)EOF);
 170         } else {
 171                 enum {
 172                         SRC_BUF_SIZE = 76/4*3,  /* This *MUST* be a multiple of 3 */
 173                         DST_BUF_SIZE = 4 * ((SRC_BUF_SIZE + 2) / 3),
 174                 };
 175                 char src_buf[SRC_BUF_SIZE];
 176                 char dst_buf[DST_BUF_SIZE + 1];
 177                 int src_fd = fileno(src_stream);
 178                 while (1) {
 179                         size_t size = full_read(src_fd, src_buf, SRC_BUF_SIZE);
 180                         if (!size)
 181                                 break;
 182                         if ((ssize_t)size < 0)
 183                                 bb_perror_msg_and_die(bb_msg_read_error);
 184                         /* Encode the buffer we just read in */
 185                         bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
 186                         xwrite(STDOUT_FILENO, dst_buf, 4 * ((size + 2) / 3));
 187                         bb_putchar('\n');
 188                         fflush(stdout);
 189                 }
 190         }
 191
 192         fflush_stdout_and_exit(EXIT_SUCCESS);
 193 }
 194 #endif
 195
 196 /* Test script.
 197 Put this into an empty dir with busybox binary, an run.
 198
 199 #!/bin/sh
 200 test -x busybox || { echo "No ./busybox?"; exit; }
 201 ln -sf busybox uudecode
 202 ln -sf busybox uuencode
 203 >A_null
 204 echo -n A >A
 205 echo -n AB >AB
 206 echo -n ABC >ABC
 207 echo -n ABCD >ABCD
 208 echo -n ABCDE >ABCDE
 209 echo -n ABCDEF >ABCDEF
 210 cat busybox >A_bbox
 211 for f in A*; do
 212     echo uuencode $f
 213     ./uuencode    $f <$f >u_$f
 214     ./uuencode -m $f <$f >m_$f
 215 done
 216 mkdir unpk_u unpk_m 2>/dev/null
 217 for f in u_*; do
 218     ./uudecode <$f -o unpk_u/${f:2}
 219     diff -a ${f:2} unpk_u/${f:2} >/dev/null 2>&1
 220     echo uudecode $f: $?
 221 done
 222 for f in m_*; do
 223     ./uudecode <$f -o unpk_m/${f:2}
 224     diff -a ${f:2} unpk_m/${f:2} >/dev/null 2>&1
 225     echo uudecode $f: $?
 226 done
 227 */