libbb/uuencode.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Copyright 2003, Glenn McGrath
   4  * Copyright 2006, Rob Landley <rob@landley.net>
   5  * Copyright 2010, Denys Vlasenko
   6  *
   7  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
   8  */
   9
  10 #include "libbb.h"
  11
  12 /* Conversion table.  for base 64 */
  13 const char bb_uuenc_tbl_base64[65 + 1] ALIGN1 = {
  14         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
  15         'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  16         'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
  17         'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
  18         'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  19         'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
  20         'w', 'x', 'y', 'z', '0', '1', '2', '3',
  21         '4', '5', '6', '7', '8', '9', '+', '/',
  22         '=' /* termination character */,
  23         '\0' /* needed for uudecode.c only */
  24 };
  25
  26 const char bb_uuenc_tbl_std[65] ALIGN1 = {
  27         '`', '!', '"', '#', '$', '%', '&', '\'',
  28         '(', ')', '*', '+', ',', '-', '.', '/',
  29         '0', '1', '2', '3', '4', '5', '6', '7',
  30         '8', '9', ':', ';', '<', '=', '>', '?',
  31         '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  32         'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
  33         'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
  34         'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
  35         '`' /* termination character */
  36 };
  37
  38 /*
  39  * Encode bytes at S of length LENGTH to uuencode or base64 format and place it
  40  * to STORE.  STORE will be 0-terminated, and must point to a writable
  41  * buffer of at least 1+BASE64_LENGTH(length) bytes.
  42  * where BASE64_LENGTH(len) = (4 * ((LENGTH + 2) / 3))
  43  */
  44 void FAST_FUNC bb_uuencode(char *p, const void *src, int length, const char *tbl)
  45 {
  46         const unsigned char *s = src;
  47
  48         /* Transform the 3x8 bits to 4x6 bits */
  49         while (length > 0) {
  50                 unsigned s1, s2;
  51
  52                 /* Are s[1], s[2] valid or should be assumed 0? */
  53                 s1 = s2 = 0;
  54                 length -= 3; /* can be >=0, -1, -2 */
  55                 if (length >= -1) {
  56                         s1 = s[1];
  57                         if (length >= 0)
  58                                 s2 = s[2];
  59                 }
  60                 *p++ = tbl[s[0] >> 2];
  61                 *p++ = tbl[((s[0] & 3) << 4) + (s1 >> 4)];
  62                 *p++ = tbl[((s1 & 0xf) << 2) + (s2 >> 6)];
  63                 *p++ = tbl[s2 & 0x3f];
  64                 s += 3;
  65         }
  66         /* Zero-terminate */
  67         *p = '\0';
  68         /* If length is -2 or -1, pad last char or two */
  69         while (length) {
  70                 *--p = tbl[64];
  71                 length++;
  72         }
  73 }
  74
  75 /*
  76  * Decode base64 encoded string. Stops on '\0'.
  77  *
  78  * Returns: pointer to the undecoded part of source.
  79  * If points to '\0', then the source was fully decoded.
  80  * (*pp_dst): advanced past the last written byte.
  81  */
  82 const char* FAST_FUNC decode_base64(char **pp_dst, const char *src)
  83 {
  84         char *dst = *pp_dst;
  85         const char *src_tail;
  86
  87         while (1) {
  88                 unsigned char six_bit[4];
  89                 int count = 0;
  90
  91                 /* Fetch up to four 6-bit values */
  92                 src_tail = src;
  93                 while (count < 4) {
  94                         char *table_ptr;
  95                         int ch;
  96
  97                         /* Get next _valid_ character.
  98                          * bb_uuenc_tbl_base64[] contains this string:
  99                          *  0         1         2         3         4         5         6
 100                          *  01234567890123456789012345678901234567890123456789012345678901234
 101                          * "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
 102                          */
 103                         do {
 104                                 ch = *src;
 105                                 if (ch == '\0') {
 106                                         if (count == 0) {
 107                                                 /* Example:
 108                                                  * If we decode "QUJD <NUL>", we want
 109                                                  * to return ptr to NUL, not to ' ',
 110                                                  * because we did fully decode
 111                                                  * the string (to "ABC").
 112                                                  */
 113                                                 src_tail = src;
 114                                         }
 115                                         goto ret;
 116                                 }
 117                                 src++;
 118                                 table_ptr = strchr(bb_uuenc_tbl_base64, ch);
 119 //TODO: add BASE64_FLAG_foo to die on bad char?
 120                         } while (!table_ptr);
 121
 122                         /* Convert encoded character to decimal */
 123                         ch = table_ptr - bb_uuenc_tbl_base64;
 124
 125                         /* ch is 64 if char was '=', otherwise 0..63 */
 126                         if (ch == 64)
 127                                 break;
 128                         six_bit[count] = ch;
 129                         count++;
 130                 }
 131
 132                 /* Transform 6-bit values to 8-bit ones.
 133                  * count can be < 4 when we decode the tail:
 134                  * "eQ==" -> "y", not "y NUL NUL".
 135                  * Note that (count > 1) is always true,
 136                  * "x===" encoding is not valid:
 137                  * even a single zero byte encodes as "AA==".
 138                  * However, with current logic we come here with count == 1
 139                  * when we decode "==" tail.
 140                  */
 141                 if (count > 1)
 142                         *dst++ = six_bit[0] << 2 | six_bit[1] >> 4;
 143                 if (count > 2)
 144                         *dst++ = six_bit[1] << 4 | six_bit[2] >> 2;
 145                 if (count > 3)
 146                         *dst++ = six_bit[2] << 6 | six_bit[3];
 147                 /* Note that if we decode "AA==" and ate first '=',
 148                  * we just decoded one char (count == 2) and now we'll
 149                  * do the loop once more to decode second '='.
 150                  */
 151         } /* while (1) */
 152  ret:
 153         *pp_dst = dst;
 154         return src_tail;
 155 }
 156
 157 /*
 158  * Decode base64 encoded stream.
 159  * Can stop on EOF, specified char, or on uuencode-style "====" line:
 160  * flags argument controls it.
 161  */
 162 void FAST_FUNC read_base64(FILE *src_stream, FILE *dst_stream, int flags)
 163 {
 164 /* Note that EOF _can_ be passed as exit_char too */
 165 #define exit_char    ((int)(signed char)flags)
 166 #define uu_style_end (flags & BASE64_FLAG_UU_STOP)
 167
 168         /* uuencoded files have 61 byte lines. Use 64 byte buffer
 169          * to process line at a time.
 170          */
 171         enum { BUFFER_SIZE = 64 };
 172
 173         char in_buf[BUFFER_SIZE + 2];
 174         char out_buf[BUFFER_SIZE / 4 * 3 + 2];
 175         char *out_tail;
 176         const char *in_tail;
 177         int term_seen = 0;
 178         int in_count = 0;
 179
 180         while (1) {
 181                 while (in_count < BUFFER_SIZE) {
 182                         int ch = fgetc(src_stream);
 183                         if (ch == exit_char) {
 184                                 if (in_count == 0)
 185                                         return;
 186                                 term_seen = 1;
 187                                 break;
 188                         }
 189                         if (ch == EOF) {
 190                                 term_seen = 1;
 191                                 break;
 192                         }
 193                         /* Prevent "====" line to be split: stop if we see '\n'.
 194                          * We can also skip other whitespace and skirt the problem
 195                          * of files with NULs by stopping on any control char or space:
 196                          */
 197                         if (ch <= ' ')
 198                                 break;
 199                         in_buf[in_count++] = ch;
 200                 }
 201                 in_buf[in_count] = '\0';
 202
 203                 /* Did we encounter "====" line? */
 204                 if (uu_style_end && strcmp(in_buf, "====") == 0)
 205                         return;
 206
 207                 out_tail = out_buf;
 208                 in_tail = decode_base64(&out_tail, in_buf);
 209
 210                 fwrite(out_buf, (out_tail - out_buf), 1, dst_stream);
 211
 212                 if (term_seen) {
 213                         /* Did we consume ALL characters? */
 214                         if (*in_tail == '\0')
 215                                 return;
 216                         /* No */
 217                         bb_error_msg_and_die("truncated base64 input");
 218                 }
 219
 220                 /* It was partial decode */
 221                 in_count = strlen(in_tail);
 222                 memmove(in_buf, in_tail, in_count);
 223         }
 224 }