← Commit list

20900489a

Denys Vlasenko

2020-11-26

SUCCESS Duration: 149s

Subject

base32: new applet

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

coreutils/uudecode.c +108 -10 include/libbb.h +3 -0 libbb/uuencode.c +81 -3

coreutils/uudecode.c+108 -10

@@ -168,9 +168,11 @@ int uudecode_main(int argc UNUSED_PARAM, char **argv)
	}
	#endif

-	//applet:IF_BASE64(APPLET(base64, BB_DIR_BIN, BB_SUID_DROP))
-
-	//kbuild:lib-$(CONFIG_BASE64) += uudecode.o
+	//config:config BASE32
+	//config: bool "base32 (4.9 kb)"
+	//config: default y
+	//config: help
+	//config: Base32 encode and decode

	//config:config BASE64
	//config: bool "base64 (4.9 kb)"
@@ -178,6 +180,14 @@ int uudecode_main(int argc UNUSED_PARAM, char **argv)
	//config: help
	//config: Base64 encode and decode

+	//usage:#define base32_trivial_usage
+	//usage: "[-d] [FILE]"
+	//usage:#define base32_full_usage "\n\n"
+	//usage: "Base32 encode or decode FILE to standard output"
+	//usage: "\n -d Decode data"
+	////usage: "\n -w COL Wrap lines at COL (default 76, 0 disables)"
+	////usage: "\n -i When decoding, ignore non-alphabet characters"
+
	//usage:#define base64_trivial_usage
	//usage: "[-d] [FILE]"
	//usage:#define base64_full_usage "\n\n"
@@ -186,9 +196,77 @@ int uudecode_main(int argc UNUSED_PARAM, char **argv)
	////usage: "\n -w COL Wrap lines at COL (default 76, 0 disables)"
	////usage: "\n -i When decoding, ignore non-alphabet characters"

-	#if ENABLE_BASE64
-	int base64_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-	int base64_main(int argc UNUSED_PARAM, char **argv)
+	// APPLET_ODDNAME:name main location suid_type help
+	//applet:IF_BASE32(APPLET_ODDNAME(base32, baseNUM, BB_DIR_BIN, BB_SUID_DROP, base32))
+	//applet:IF_BASE64(APPLET_ODDNAME(base64, baseNUM, BB_DIR_BIN, BB_SUID_DROP, base64))
+
+	//kbuild:lib-$(CONFIG_BASE64) += uudecode.o
+	//kbuild:lib-$(CONFIG_BASE32) += uudecode.o
+
+	#if ENABLE_BASE32 \|\| ENABLE_BASE64
+
+	# if ENABLE_BASE32
+	static void bb_b32encode(char p, const void src, int length)
+	{
+	#define tbl bb_uuenc_tbl_base32
+	const unsigned char *s = src;
+
+	/* Transform 5x8 bits to 8x5 bits */
+	while (length > 0) {
+	unsigned cur, next;
+
+	length--;
+	cur = *s++;
+	*p++ = tbl[cur >> 3]; // xxxxx--- -------- -------- -------- --------
+	cur &= 7;
+
+	next = 0;
+	if (--length >= 0)
+	next = *s++;
+	*p++ = tbl[(cur << 2) + (next >> 6)]; // -----xxx xx------ -------- -------- --------
+	cur = next & 0x3f;
+
+	*p++ = tbl[cur >> 1]; // -------- --xxxxx- -------- -------- --------
+	cur &= 1;
+
+	next = 0;
+	if (--length >= 0)
+	next = *s++;
+	*p++ = tbl[(cur << 4) + (next >> 4)]; // -------- -------x xxxx---- -------- --------
+	cur = next & 0xf;
+
+	next = 0;
+	if (--length >= 0)
+	next = *s++;
+	*p++ = tbl[(cur << 1) + (next >> 7)]; // -------- -------- ----xxxx x------- --------
+	cur = next & 0x7f;
+
+	*p++ = tbl[cur >> 2]; // -------- -------- -------- -xxxxx-- --------
+	cur &= 3;
+
+	next = 0;
+	if (--length >= 0)
+	next = *s++;
+	*p++ = tbl[(cur << 3) + (next >> 5)]; // -------- -------- -------- ------xx xxx-----
+	cur = next & 0x1f;
+
+	*p++ = tbl[cur]; // -------- -------- -------- -------- ---xxxxx
+	}
+	#undef tbl
+	/* Zero-terminate */
+	*p = '\0';
+	/* Pad as necessary */
+	length = ((-length) * 3) >> 1; /* -4 => 6 pad chars, -3 => 4, -2 => 3, -1 => 1 */
+	while (length--) {
+	*--p = '=';
+	}
+	}
+	# else
+	void bb_b32encode(char p, const void src, int length); /* undefined */
+	# endif
+
+	int baseNUM_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+	int baseNUM_main(int argc UNUSED_PARAM, char **argv)
	{
	FILE *src_stream;
	unsigned opts;
@@ -200,7 +278,10 @@ int base64_main(int argc UNUSED_PARAM, char **argv)
	--argv = (char)"-";
	src_stream = xfopen_stdin(argv[0]);
	if (opts) {
-	read_base64(src_stream, stdout, /flags:/ (unsigned char)EOF);
+	int flags = (unsigned char)EOF;
+	if (ENABLE_BASE32 && (!ENABLE_BASE64 \|\| applet_name[4] == '3'))
+	flags = ((unsigned char)EOF) \| BASE64_32;
+	read_base64(src_stream, stdout, flags);
	} else {
	enum {
	SRC_BUF_SIZE = 76 / 4 * 3, /* this MUST be a multiple of 3 */
@@ -210,14 +291,31 @@ int base64_main(int argc UNUSED_PARAM, char **argv)
	char dst_buf[DST_BUF_SIZE + 1];
	int src_fd = fileno(src_stream);
	while (1) {
-	size_t size = full_read(src_fd, src_buf, SRC_BUF_SIZE);
+	size_t size;
+	if (ENABLE_BASE32 && (!ENABLE_BASE64 \|\| applet_name[4] == '3'))
+	size = 72 / 8 * 5;
+	//FIXME: wrong, default width of base32 is not 72, but 76 chars
+	//(not a multiple of 8 - requires adding wrapping logic)
+	//when this is fixed, can implement -w COL too
+	else
+	size = SRC_BUF_SIZE;
+
+	size = full_read(src_fd, src_buf, size);
	if (!size)
	break;
	if ((ssize_t)size < 0)
	bb_simple_perror_msg_and_die(bb_msg_read_error);
+
	/* Encode the buffer we just read in */
-	bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
-	xwrite(STDOUT_FILENO, dst_buf, 4 * ((size + 2) / 3));
+	if (ENABLE_BASE32 && (!ENABLE_BASE64 \|\| applet_name[4] == '3')) {
+	bb_b32encode(dst_buf, src_buf, size);
+	size = 8 * ((size + 4) / 5);
+	} else {
+	bb_uuencode(dst_buf, src_buf, size, bb_uuenc_tbl_base64);
+	size = 4 * ((size + 2) / 3);
+	}
+
+	xwrite(STDOUT_FILENO, dst_buf, size);
	bb_putchar('\n');
	fflush(stdout);
	}

include/libbb.h+3 -0

@@ -2026,14 +2026,17 @@ char percent_decode_in_place(char str, int strict) FAST_FUNC;


	extern const char bb_uuenc_tbl_base64[] ALIGN1;
+	extern const char bb_uuenc_tbl_base32[] ALIGN1;
	extern const char bb_uuenc_tbl_std[] ALIGN1;
	void bb_uuencode(char store, const void s, int length, const char *tbl) FAST_FUNC;
	enum {
	BASE64_FLAG_UU_STOP = 0x100,
+	BASE64_32 = 0x200, /* base32 */
	/* Sign-extends to a value which never matches fgetc result: */
	BASE64_FLAG_NO_STOP_CHAR = 0x80,
	};
	const char decode_base64(char pp_dst, const char src) FAST_FUNC;
+	const char decode_base32(char pp_dst, const char src) FAST_FUNC;
	void read_base64(FILE src_stream, FILE dst_stream, int flags) FAST_FUNC;

	typedef struct md5_ctx_t {

libbb/uuencode.c+81 -3

@@ -8,7 +8,8 @@
	*/
	#include "libbb.h"

-	/* Conversion table. for base 64 */
+	/* Conversion tables */
+	/* for base 64 */
	const char bb_uuenc_tbl_base64[65 + 1] ALIGN1 = {
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
@@ -21,7 +22,16 @@ const char bb_uuenc_tbl_base64[65 + 1] ALIGN1 = {
	'=' /* termination character */,
	'\0' /* needed for uudecode.c only */
	};
-
+	#if ENABLE_BASE32
+	const char bb_uuenc_tbl_base32[33 + 1] ALIGN1 = {
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', '2', '3', '4', '5', '6', '7',
+	'=',
+	'\0'
+	};
+	#endif
	const char bb_uuenc_tbl_std[65] ALIGN1 = {
	'`', '!', '"', '#', '$', '%', '&', '\'',
	'(', ')', '*', '+', ',', '-', '.', '/',
@@ -153,6 +163,68 @@ const char* FAST_FUNC decode_base64(char *pp_dst, const char src)
	return src_tail;
	}

+	#if ENABLE_BASE32
+	const char* FAST_FUNC decode_base32(char *pp_dst, const char src)
+	{
+	char dst = pp_dst;
+	const char *src_tail;
+
+	while (1) {
+	unsigned char five_bit[8];
+	int count = 0;
+
+	/* Fetch up to eight 5-bit values */
+	src_tail = src;
+	while (count < 8) {
+	char *table_ptr;
+	int ch;
+
+	/* Get next _valid_ character.
+	* bb_uuenc_tbl_base32[] contains this string:
+	* 0 1 2 3
+	* 01234567890123456789012345678901
+	* "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567="
+	*/
+	do {
+	ch = *src;
+	if (ch == '\0') {
+	if (count == 0) {
+	src_tail = src;
+	}
+	goto ret;
+	}
+	src++;
+	table_ptr = strchr(bb_uuenc_tbl_base32, toupper(ch));
+	} while (!table_ptr);
+
+	/* Convert encoded character to decimal */
+	ch = table_ptr - bb_uuenc_tbl_base32;
+
+	/* ch is 32 if char was '=', otherwise 0..31 */
+	if (ch == 32)
+	break;
+	five_bit[count] = ch;
+	count++;
+	}
+
+	/* Transform 5-bit values to 8-bit ones */
+	if (count > 1) // xxxxx xxx-- ----- ----- ----- ----- ----- -----
+	*dst++ = five_bit[0] << 3 \| five_bit[1] >> 2;
+	if (count > 3) // ----- ---xx xxxxx x---- ----- ----- ----- -----
+	*dst++ = five_bit[1] << 6 \| five_bit[2] << 1 \| five_bit[3] >> 4;
+	if (count > 4) // ----- ----- ----- -xxxx xxxx- ----- ----- -----
+	*dst++ = five_bit[3] << 4 \| five_bit[4] >> 1;
+	if (count > 6) // ----- ----- ----- ----- ----x xxxxx xx--- -----
+	*dst++ = five_bit[4] << 7 \| five_bit[5] << 2 \| five_bit[6] >> 3;
+	if (count > 7) // ----- ----- ----- ----- ----- ----- --xxx xxxxx
+	*dst++ = five_bit[6] << 5 \| five_bit[7];
+	} /* while (1) */
+	ret:
+	*pp_dst = dst;
+	return src_tail;
+	}
+	#endif
+
	/*
	* Decode base64 encoded stream.
	* Can stop on EOF, specified char, or on uuencode-style "====" line:
@@ -163,6 +235,7 @@ void FAST_FUNC read_base64(FILE src_stream, FILE dst_stream, int flags)
	/* Note that EOF _can_ be passed as exit_char too */
	#define exit_char ((int)(signed char)flags)
	#define uu_style_end (flags & BASE64_FLAG_UU_STOP)
+	#define base32 (flags & BASE64_32)

	/* uuencoded files have 61 byte lines. Use 64 byte buffer
	* to process line at a time.
@@ -204,7 +277,12 @@ void FAST_FUNC read_base64(FILE src_stream, FILE dst_stream, int flags)
	return;

	out_tail = out_buf;
-	in_tail = decode_base64(&out_tail, in_buf);
+	#if ENABLE_BASE32
+	if (base32)
+	in_tail = decode_base32(&out_tail, in_buf);
+	else
+	#endif
+	in_tail = decode_base64(&out_tail, in_buf);

	fwrite(out_buf, (out_tail - out_buf), 1, dst_stream);