#include "quotearg.h"
#include "xfreopen.h"
-#include "base64.h"
+#define AUTHORS proper_name ("Simon Josefsson")
-/* The official name of this program (e.g., no 'g' prefix). */
-#define PROGRAM_NAME "base64"
+#if BASE_TYPE == 32
+# include "base32.h"
+# define PROGRAM_NAME "base32"
+#else
+# include "base64.h"
+# define PROGRAM_NAME "base64"
+#endif
-#define AUTHORS proper_name ("Simon Josefsson")
static struct option const long_options[] =
{
{
printf (_("\
Usage: %s [OPTION]... [FILE]\n\
-Base64 encode or decode FILE, or standard input, to standard output.\n\
-"), program_name);
+Base%d encode or decode FILE, or standard input, to standard output.\n\
+"), program_name, BASE_TYPE);
emit_stdin_note ();
emit_mandatory_arg_note ();
"), stdout);
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
- fputs (_("\
+ printf (_("\
\n\
-The data are encoded as described for the base64 alphabet in RFC 3548.\n\
+The data are encoded as described for the %s alphabet in RFC 4648.\n\
When decoding, the input may contain newlines in addition to the bytes of\n\
-the formal base64 alphabet. Use --ignore-garbage to attempt to recover\n\
+the formal %s alphabet. Use --ignore-garbage to attempt to recover\n\
from any other non-alphabet bytes in the encoded stream.\n"),
- stdout);
+ PROGRAM_NAME, PROGRAM_NAME);
emit_ancillary_info (PROGRAM_NAME);
}
}
#define ENC_BLOCKSIZE (1024*3*10)
-#define ENC_B64BLOCKSIZE BASE64_LENGTH (ENC_BLOCKSIZE)
+
+#if BASE_TYPE == 32
+# define BASE_LENGTH BASE32_LENGTH
+/* Note that increasing this may decrease performance if --ignore-garbage
+ is used, because of the memmove operation below. */
+# define DEC_BLOCKSIZE (1024*5)
+
+/* Ensure that BLOCKSIZE is a multiple of 5 and 8. */
+verify (ENC_BLOCKSIZE % 40 == 0); /* So padding chars only on last block. */
+verify (DEC_BLOCKSIZE % 40 == 0); /* So complete encoded blocks are used. */
+
+# define base_encode base32_encode
+# define base_decode_context base32_decode_context
+# define base_decode_ctx_init base32_decode_ctx_init
+# define base_decode_ctx base32_decode_ctx
+# define isbase isbase32
+#else
+# define BASE_LENGTH BASE64_LENGTH
/* Note that increasing this may decrease performance if --ignore-garbage
is used, because of the memmove operation below. */
-#define DEC_BLOCKSIZE (1024*3)
-#define DEC_B64BLOCKSIZE BASE64_LENGTH (DEC_BLOCKSIZE)
+# define DEC_BLOCKSIZE (1024*3)
/* Ensure that BLOCKSIZE is a multiple of 3 and 4. */
-verify (ENC_BLOCKSIZE % 12 == 0);
-verify (DEC_BLOCKSIZE % 12 == 0);
+verify (ENC_BLOCKSIZE % 12 == 0); /* So padding chars only on last block. */
+verify (DEC_BLOCKSIZE % 12 == 0); /* So complete encoded blocks are used. */
+
+# define base_encode base64_encode
+# define base_decode_context base64_decode_context
+# define base_decode_ctx_init base64_decode_ctx_init
+# define base_decode_ctx base64_decode_ctx
+# define isbase isbase64
+#endif
static void
wrap_write (const char *buffer, size_t len,
{
size_t current_column = 0;
char inbuf[ENC_BLOCKSIZE];
- char outbuf[ENC_B64BLOCKSIZE];
+ char outbuf[BASE_LENGTH (ENC_BLOCKSIZE)];
size_t sum;
do
if (sum > 0)
{
- /* Process input one block at a time. Note that ENC_BLOCKSIZE %
- 3 == 0, so that no base64 pads will appear in output. */
- base64_encode (inbuf, sum, outbuf, BASE64_LENGTH (sum));
+ /* Process input one block at a time. Note that ENC_BLOCKSIZE
+ is sized so that no pad chars will appear in output. */
+ base_encode (inbuf, sum, outbuf, BASE_LENGTH (sum));
- wrap_write (outbuf, BASE64_LENGTH (sum), wrap_column,
+ wrap_write (outbuf, BASE_LENGTH (sum), wrap_column,
¤t_column, out);
}
}
static void
do_decode (FILE *in, FILE *out, bool ignore_garbage)
{
- char inbuf[DEC_B64BLOCKSIZE];
+ char inbuf[BASE_LENGTH (DEC_BLOCKSIZE)];
char outbuf[DEC_BLOCKSIZE];
size_t sum;
- struct base64_decode_context ctx;
+ struct base_decode_context ctx;
- base64_decode_ctx_init (&ctx);
+ base_decode_ctx_init (&ctx);
do
{
sum = 0;
do
{
- n = fread (inbuf + sum, 1, DEC_B64BLOCKSIZE - sum, in);
+ n = fread (inbuf + sum, 1, BASE_LENGTH (DEC_BLOCKSIZE) - sum, in);
if (ignore_garbage)
{
size_t i;
for (i = 0; n > 0 && i < n;)
- if (isbase64 (inbuf[sum + i]) || inbuf[sum + i] == '=')
+ if (isbase (inbuf[sum + i]) || inbuf[sum + i] == '=')
i++;
else
memmove (inbuf + sum + i, inbuf + sum + i + 1, --n - i);
if (ferror (in))
error (EXIT_FAILURE, errno, _("read error"));
}
- while (sum < DEC_B64BLOCKSIZE && !feof (in));
+ while (sum < BASE_LENGTH (DEC_BLOCKSIZE) && !feof (in));
/* The following "loop" is usually iterated just once.
However, when it processes the final input buffer, we want
if (k == 1 && ctx.i == 0)
break;
n = DEC_BLOCKSIZE;
- ok = base64_decode_ctx (&ctx, inbuf, (k == 0 ? sum : 0), outbuf, &n);
+ ok = base_decode_ctx (&ctx, inbuf, (k == 0 ? sum : 0), outbuf, &n);
if (fwrite (outbuf, 1, n, out) < n)
error (EXIT_FAILURE, errno, _("write error"));
/* True if --decode has been given and we should decode data. */
bool decode = false;
- /* True if we should ignore non-base64-alphabetic characters. */
+ /* True if we should ignore non-base-alphabetic characters. */
bool ignore_garbage = false;
- /* Wrap encoded base64 data around the 76:th column, by default. */
+ /* Wrap encoded data around the 76:th column, by default. */
uintmax_t wrap_column = 76;
initialize_main (&argc, &argv);
#!/usr/bin/perl
-# Exercise base64.
+# Exercise base{32,64}.
# Copyright (C) 2006-2015 Free Software Foundation, Inc.
@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;
# Return the encoding of a string of N 'a's.
-sub enc($)
+sub enc64($)
{
my ($n) = @_;
my %remainder = ( 0 => '', 1 => 'YQ==', 2 => 'YWE=' );
return 'YWFh' x ($n / 3) . $remainder{$n % 3};
}
-# Construct an encoded string of length 4KB, using 3K "a"s.
-my $a3k = enc 3072;
+sub enc32($)
+{
+ my ($n) = @_;
+ my %remainder = ( 0 => '', 1 => 'ME======', 2 => 'MFQQ====',
+ 3 => 'MFQWC===', 4 => 'MFQWCYI=');
+ return 'MFQWCYLB' x ($n / 5) . $remainder{$n % 5};
+}
+
+# Function reference to appropriate encoder
+my $enc;
+
+# An encoded string of length 4KB, using 3K "a"s.
+my $a3k;
my @a3k_nl;
-# A few copies, each with different number of newlines at the start.
-for my $k (0..3)
- {
- (my $t = $a3k) =~ s/^/"\n"x $k/e;
- push @a3k_nl, $t;
- }
# Return a copy of S, with newlines inserted every WIDTH bytes.
# Ensure that the result (if not the empty string) is newline-terminated.
return $s;
}
-my @Tests =
+my @Tests;
+
+sub gen_tests($)
+{
+ my ($prog) = @_;
+ @Tests=
(
['empty', {IN=>''}, {OUT=>""}],
- ['inout', {IN=>'a'}, {OUT=>"YQ==\n"}],
- ['wrap', '--wrap 0', {IN=>'foo'}, {OUT=>'Zm9v'}],
- ['wrap5-39', '--wrap=5', {IN=>'a' x 39}, {OUT=>wrap enc(39),5}],
- ['wrap5-40', '--wrap=5', {IN=>'a' x 40}, {OUT=>wrap enc(40),5}],
- ['wrap5-41', '--wrap=5', {IN=>'a' x 41}, {OUT=>wrap enc(41),5}],
- ['wrap5-42', '--wrap=5', {IN=>'a' x 42}, {OUT=>wrap enc(42),5}],
- ['wrap5-43', '--wrap=5', {IN=>'a' x 43}, {OUT=>wrap enc(43),5}],
- ['wrap5-44', '--wrap=5', {IN=>'a' x 44}, {OUT=>wrap enc(44),5}],
- ['wrap5-45', '--wrap=5', {IN=>'a' x 45}, {OUT=>wrap enc(45),5}],
- ['wrap5-46', '--wrap=5', {IN=>'a' x 46}, {OUT=>wrap enc(46),5}],
-
- ['buf-1', '--decode', {IN=>enc 1}, {OUT=>'a' x 1}],
- ['buf-2', '--decode', {IN=>enc 2}, {OUT=>'a' x 2}],
- ['buf-3', '--decode', {IN=>enc 3}, {OUT=>'a' x 3}],
- ['buf-4', '--decode', {IN=>enc 4}, {OUT=>'a' x 4}],
+ ['inout1', {IN=>'a'x1}, {OUT=>&$enc(1)."\n"}],
+ ['inout2', {IN=>'a'x2}, {OUT=>&$enc(2)."\n"}],
+ ['inout3', {IN=>'a'x3}, {OUT=>&$enc(3)."\n"}],
+ ['inout4', {IN=>'a'x4}, {OUT=>&$enc(4)."\n"}],
+ ['inout5', {IN=>'a'x5}, {OUT=>&$enc(5)."\n"}],
+ ['wrap', '--wrap 0', {IN=>'a'}, {OUT=>&$enc(1)}],
+ ['wrap5-39', '--wrap=5', {IN=>'a' x 39}, {OUT=>wrap &$enc(39),5}],
+ ['wrap5-40', '--wrap=5', {IN=>'a' x 40}, {OUT=>wrap &$enc(40),5}],
+ ['wrap5-41', '--wrap=5', {IN=>'a' x 41}, {OUT=>wrap &$enc(41),5}],
+ ['wrap5-42', '--wrap=5', {IN=>'a' x 42}, {OUT=>wrap &$enc(42),5}],
+ ['wrap5-43', '--wrap=5', {IN=>'a' x 43}, {OUT=>wrap &$enc(43),5}],
+ ['wrap5-44', '--wrap=5', {IN=>'a' x 44}, {OUT=>wrap &$enc(44),5}],
+ ['wrap5-45', '--wrap=5', {IN=>'a' x 45}, {OUT=>wrap &$enc(45),5}],
+ ['wrap5-46', '--wrap=5', {IN=>'a' x 46}, {OUT=>wrap &$enc(46),5}],
+
+ ['buf-1', '--decode', {IN=>&$enc(1)}, {OUT=>'a' x 1}],
+ ['buf-2', '--decode', {IN=>&$enc(2)}, {OUT=>'a' x 2}],
+ ['buf-3', '--decode', {IN=>&$enc(3)}, {OUT=>'a' x 3}],
+ ['buf-4', '--decode', {IN=>&$enc(4)}, {OUT=>'a' x 4}],
# 4KB worth of input.
- ['buf-4k0', '--decode', {IN=>enc 3072+0}, {OUT=>'a' x (3072+0)}],
- ['buf-4k1', '--decode', {IN=>enc 3072+1}, {OUT=>'a' x (3072+1)}],
- ['buf-4k2', '--decode', {IN=>enc 3072+2}, {OUT=>'a' x (3072+2)}],
- ['buf-4k3', '--decode', {IN=>enc 3072+3}, {OUT=>'a' x (3072+3)}],
- ['buf-4km1','--decode', {IN=>enc 3072-1}, {OUT=>'a' x (3072-1)}],
- ['buf-4km2','--decode', {IN=>enc 3072-2}, {OUT=>'a' x (3072-2)}],
- ['buf-4km3','--decode', {IN=>enc 3072-3}, {OUT=>'a' x (3072-3)}],
- ['buf-4km4','--decode', {IN=>enc 3072-4}, {OUT=>'a' x (3072-4)}],
+ ['buf-4k0', '--decode', {IN=>&$enc(3072+0)}, {OUT=>'a' x (3072+0)}],
+ ['buf-4k1', '--decode', {IN=>&$enc(3072+1)}, {OUT=>'a' x (3072+1)}],
+ ['buf-4k2', '--decode', {IN=>&$enc(3072+2)}, {OUT=>'a' x (3072+2)}],
+ ['buf-4k3', '--decode', {IN=>&$enc(3072+3)}, {OUT=>'a' x (3072+3)}],
+ ['buf-4km1','--decode', {IN=>&$enc(3072-1)}, {OUT=>'a' x (3072-1)}],
+ ['buf-4km2','--decode', {IN=>&$enc(3072-2)}, {OUT=>'a' x (3072-2)}],
+ ['buf-4km3','--decode', {IN=>&$enc(3072-3)}, {OUT=>'a' x (3072-3)}],
+ ['buf-4km4','--decode', {IN=>&$enc(3072-4)}, {OUT=>'a' x (3072-4)}],
# Exercise the case in which the final base-64 byte is
# in a buffer all by itself.
['b4k-1', '--decode', {IN=>$a3k_nl[1]}, {OUT=>'a' x (3072+0)}],
['b4k-2', '--decode', {IN=>$a3k_nl[2]}, {OUT=>'a' x (3072+0)}],
['b4k-3', '--decode', {IN=>$a3k_nl[3]}, {OUT=>'a' x (3072+0)}],
-
- ['baddecode', '--decode', {IN=>'a'}, {OUT=>""},
- {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
- ['baddecode2', '--decode', {IN=>'ab'}, {OUT=>"i"},
- {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
- ['baddecode3', '--decode', {IN=>'Zzz'}, {OUT=>"g<"},
- {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
- ['baddecode4', '--decode', {IN=>'Zz='}, {OUT=>"g"},
- {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
- ['baddecode5', '--decode', {IN=>'Z==='}, {OUT=>""},
- {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}]
);
-# For each non-failing test, create a --decode test using the
-# expected output as input. Also, add tests inserting newlines.
-my @new;
-foreach my $t (@Tests)
+ if ($prog eq "base64")
+ {
+ push @Tests, (
+ ['baddecode', '--decode', {IN=>'a'}, {OUT=>""},
+ {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
+ ['baddecode2', '--decode', {IN=>'ab'}, {OUT=>"i"},
+ {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
+ ['baddecode3', '--decode', {IN=>'Zzz'}, {OUT=>"g<"},
+ {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
+ ['baddecode4', '--decode', {IN=>'Zz='}, {OUT=>"g"},
+ {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}],
+ ['baddecode5', '--decode', {IN=>'Z==='}, {OUT=>""},
+ {ERR_SUBST => 's/.*: invalid input//'}, {ERR => "\n"}, {EXIT => 1}]
+ );
+ }
+
+ # For each non-failing test, create a --decode test using the
+ # expected output as input. Also, add tests inserting newlines.
+ my @new;
+ foreach my $t (@Tests)
{
- my $exit_val;
- my $in;
- my @out;
+ my $exit_val;
+ my $in;
+ my @out;
- # If the test has a single option of "--decode", then skip it.
- !ref $t->[1] && $t->[1] eq '--decode'
+ # If the test has a single option of "--decode", then skip it.
+ !ref $t->[1] && $t->[1] eq '--decode'
and next;
- foreach my $e (@$t)
+ foreach my $e (@$t)
{
- ref $e && ref $e eq 'HASH'
+ ref $e && ref $e eq 'HASH'
or next;
- defined $e->{EXIT}
+ defined $e->{EXIT}
and $exit_val = $e->{EXIT};
- defined $e->{IN}
+ defined $e->{IN}
and $in = $e->{IN};
- if (defined $e->{OUT})
+ if (defined $e->{OUT})
{
- my $t = $e->{OUT};
- push @out, $t;
- my $len = length $t;
- foreach my $i (0..$len)
+ my $t = $e->{OUT};
+ push @out, $t;
+ my $len = length $t;
+ foreach my $i (0..$len)
{
- my $u = $t;
- substr ($u, $i, 0) = "\n";
- push @out, $u;
- 10 <= $i
+ my $u = $t;
+ substr ($u, $i, 0) = "\n";
+ push @out, $u;
+ 10 <= $i
and last;
}
}
}
- $exit_val
+ $exit_val
and next;
- my $i = 0;
- foreach my $o (@out)
+ my $i = 0;
+ foreach my $o (@out)
{
- push @new, ["d$i-$t->[0]", '--decode', {IN => $o}, {OUT => $in}];
- ++$i;
+ push @new, ["d$i-$t->[0]", '--decode', {IN => $o}, {OUT => $in}];
+ ++$i;
}
}
-push @Tests, @new;
+ push @Tests, @new;
+}
my $save_temps = $ENV{DEBUG};
my $verbose = $ENV{VERBOSE};
-my $prog = 'base64';
-my $fail = run_tests ($program_name, $prog, \@Tests, $save_temps, $verbose);
+my $fail = 0;
+foreach my $prog (qw(base32 base64))
+ {
+ $enc = $prog eq "base32" ? \&enc32 : \&enc64;
+
+ # Construct an encoded string of length 4KB, using 3K "a"s.
+ $a3k = &$enc(3072);
+ @a3k_nl = ();
+ # A few copies, each with different number of newlines at the start.
+ for my $k (0..3)
+ {
+ (my $t = $a3k) =~ s/^/"\n"x $k/e;
+ push @a3k_nl, $t;
+ }
+
+ gen_tests($prog);
+
+ $fail = run_tests ($program_name, $prog, \@Tests, $save_temps, $verbose);
+ if ($fail != 0)
+ {
+ last;
+ }
+ }
+
exit $fail;
projects / thirdparty / coreutils.git / commitdiff
