Glenn McGrath <bug1@netconnect.com.au>
* Added mktemp, contributed by Daniel Jacobowitz <dan@debian.org>
* Added setkeycodes, for those that have wierd keyboard buttons.
+ * Added md5sum, uuencode and uudecode -- thanks to Alfred M. Szmidt
+ <ams@trillian.itslinux.org> for contributing these.
* Added 'grep -v' option (inverted search) and updated
docs accordingly. -beppu
* Wrote which
# Set the following to `true' to make a debuggable build.
# Leave this set to `false' for production use.
# eg: `make DODEBUG=true tests'
-DODEBUG = false
+DODEBUG = true
# If you want a static binary, turn this on.
DOSTATIC = false
#ifdef BB_MATH
{"math", math_main, _BB_DIR_USR_BIN},
#endif
+#ifdef BB_MD5SUM
+ {"md5sum", md5sum_main, _BB_DIR_USR_BIN},
+#endif
#ifdef BB_MKDIR
{"mkdir", mkdir_main, _BB_DIR_BIN},
#endif
#ifdef BB_UPTIME
{"uptime", uptime_main, _BB_DIR_USR_BIN},
#endif
+#ifdef BB_UUENCODE
+ {"uuencode", uuencode_main, _BB_DIR_USR_BIN},
+#endif
+#ifdef BB_UUDECODE
+ {"uudecode", uudecode_main, _BB_DIR_USR_BIN},
+#endif
#ifdef BB_USLEEP
{"usleep", usleep_main, _BB_DIR_BIN},
#endif
#ifdef BB_MATH
{"math", math_main, _BB_DIR_USR_BIN},
#endif
+#ifdef BB_MD5SUM
+ {"md5sum", md5sum_main, _BB_DIR_USR_BIN},
+#endif
#ifdef BB_MKDIR
{"mkdir", mkdir_main, _BB_DIR_BIN},
#endif
#ifdef BB_UPTIME
{"uptime", uptime_main, _BB_DIR_USR_BIN},
#endif
+#ifdef BB_UUENCODE
+ {"uuencode", uuencode_main, _BB_DIR_USR_BIN},
+#endif
+#ifdef BB_UUDECODE
+ {"uudecode", uudecode_main, _BB_DIR_USR_BIN},
+#endif
#ifdef BB_USLEEP
{"usleep", usleep_main, _BB_DIR_BIN},
#endif
#define BB_LSMOD
#define BB_MAKEDEVS
#define BB_MATH
+#define BB_MD5SUM
#define BB_MKDIR
#define BB_MKFIFO
#define BB_MKFS_MINIX
#define BB_WC
#define BB_WHICH
#define BB_WHOAMI
+#define BB_UUENCODE
+#define BB_UUDECODE
#define BB_UMOUNT
#define BB_UNIQ
#define BB_UNAME
/* Parse options */
while (--argc >= 0 && *argv && (**argv == '-')) {
- while (*++(*argv))
+ while (*++(*argv)) {
switch (**argv) {
case 'R':
recursiveFlag = TRUE;
fprintf(stderr, invalid_option, invocationName, **argv);
usage(appUsage);
}
+ }
argv++;
}
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = (long)
(blocks_used * 100.0 / (blocks_used + s.f_bavail) + 0.5);
- /* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */
if (strcmp(device, "/dev/root") == 0) {
/* Adjusts device to be the real root device,
* or leaves device alone if it can't find it */
--- /dev/null
+/* md5sum.c - Compute MD5 checksum of files or strings according to the
+ * definition of MD5 in RFC 1321 from April 1992.
+ * Copyright (C) 1995-1999 Free Software Foundation, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu> */
+/* Hacked to work with BusyBox by Alfred M. Szmidt <ams@trillian.itslinux.org> */
+
+#include "internal.h"
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.h>
+
+//----------------------------------------------------------------------------
+//--------md5.c
+//----------------------------------------------------------------------------
+
+/* md5.c - Functions to compute MD5 message digest of files or memory blocks
+ * according to the definition of MD5 in RFC 1321 from April 1992.
+ * Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ *
+ * NOTE: The canonical source of this file is maintained with the GNU C
+ * Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <endian.h>
+
+#include "internal.h"
+//----------------------------------------------------------------------------
+//--------md5.h
+//----------------------------------------------------------------------------
+
+/* md5.h - Declaration of functions and data types used for MD5 sum
+ computing library functions.
+ Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ NOTE: The canonical source of this file is maintained with the GNU C
+ Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+#ifndef _MD5_H
+#define _MD5_H 1
+
+#include <stdio.h>
+
+#if defined HAVE_LIMITS_H || _LIBC
+# include <limits.h>
+#endif
+
+/* The following contortions are an attempt to use the C preprocessor
+ to determine an unsigned integral type that is 32 bits wide. An
+ alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
+ doing that would require that the configure script compile and *run*
+ the resulting executable. Locally running cross-compiled executables
+ is usually not possible. */
+
+#ifdef _LIBC
+# include <sys/types.h>
+typedef u_int32_t md5_uint32;
+#else
+# if defined __STDC__ && __STDC__
+# define UINT_MAX_32_BITS 4294967295U
+# else
+# define UINT_MAX_32_BITS 0xFFFFFFFF
+# endif
+
+/* If UINT_MAX isn't defined, assume it's a 32-bit type.
+ This should be valid for all systems GNU cares about because
+ that doesn't include 16-bit systems, and only modern systems
+ (that certainly have <limits.h>) have 64+-bit integral types. */
+
+# ifndef UINT_MAX
+# define UINT_MAX UINT_MAX_32_BITS
+# endif
+
+# if UINT_MAX == UINT_MAX_32_BITS
+ typedef unsigned int md5_uint32;
+# else
+# if USHRT_MAX == UINT_MAX_32_BITS
+ typedef unsigned short md5_uint32;
+# else
+# if ULONG_MAX == UINT_MAX_32_BITS
+ typedef unsigned long md5_uint32;
+# else
+ /* The following line is intended to evoke an error.
+ Using #error is not portable enough. */
+ "Cannot determine unsigned 32-bit data type."
+# endif
+# endif
+# endif
+#endif
+
+#undef __P
+#if defined (__STDC__) && __STDC__
+#define __P(x) x
+#else
+#define __P(x) ()
+#endif
+
+/* Structure to save state of computation between the single steps. */
+struct md5_ctx
+{
+ md5_uint32 A;
+ md5_uint32 B;
+ md5_uint32 C;
+ md5_uint32 D;
+
+ md5_uint32 total[2];
+ md5_uint32 buflen;
+ char buffer[128];
+};
+
+/*
+ * The following three functions are build up the low level used in
+ * the functions `md5_stream' and `md5_buffer'.
+ */
+
+/* Initialize structure containing state of computation.
+ (RFC 1321, 3.3: Step 3) */
+extern void md5_init_ctx __P ((struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+ initialization function update the context for the next LEN bytes
+ starting at BUFFER.
+ It is necessary that LEN is a multiple of 64!!! */
+extern void md5_process_block __P ((const void *buffer, size_t len,
+ struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+ initialization function update the context for the next LEN bytes
+ starting at BUFFER.
+ It is NOT required that LEN is a multiple of 64. */
+extern void md5_process_bytes __P ((const void *buffer, size_t len,
+ struct md5_ctx *ctx));
+
+/* Process the remaining bytes in the buffer and put result from CTX
+ in first 16 bytes following RESBUF. The result is always in little
+ endian byte order, so that a byte-wise output yields to the wanted
+ ASCII representation of the message digest.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
+
+
+/* Put result from CTX in first 16 bytes following RESBUF. The result is
+ always in little endian byte order, so that a byte-wise output yields
+ to the wanted ASCII representation of the message digest.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
+
+
+/* Compute MD5 message digest for bytes read from STREAM. The
+ resulting message digest number will be written into the 16 bytes
+ beginning at RESBLOCK. */
+extern int md5_stream __P ((FILE *stream, void *resblock));
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
+ result is always in little endian byte order, so that a byte-wise
+ output yields to the wanted ASCII representation of the message
+ digest. */
+extern void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
+
+#endif
+
+//----------------------------------------------------------------------------
+//--------end of md5.h
+//----------------------------------------------------------------------------
+
+#define SWAP(n) (n)
+
+/* This array contains the bytes used to pad the buffer to the next
+ 64-byte boundary. (RFC 1321, 3.1: Step 1) */
+static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
+
+/* Initialize structure containing state of computation.
+ (RFC 1321, 3.3: Step 3) */
+void md5_init_ctx(struct md5_ctx *ctx)
+{
+ ctx->A = 0x67452301;
+ ctx->B = 0xefcdab89;
+ ctx->C = 0x98badcfe;
+ ctx->D = 0x10325476;
+
+ ctx->total[0] = ctx->total[1] = 0;
+ ctx->buflen = 0;
+}
+
+/* Put result from CTX in first 16 bytes following RESBUF. The result
+ must be in little endian byte order.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
+{
+ ((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
+ ((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
+ ((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
+ ((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
+
+ return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+ prolog according to the standard and write the result to RESBUF.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
+{
+ /* Take yet unprocessed bytes into account. */
+ md5_uint32 bytes = ctx->buflen;
+ size_t pad;
+
+ /* Now count remaining bytes. */
+ ctx->total[0] += bytes;
+ if (ctx->total[0] < bytes)
+ ++ctx->total[1];
+
+ pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
+ memcpy(&ctx->buffer[bytes], fillbuf, pad);
+
+ /* Put the 64-bit file length in *bits* at the end of the buffer. */
+ *(md5_uint32 *) & ctx->buffer[bytes + pad] = SWAP(ctx->total[0] << 3);
+ *(md5_uint32 *) & ctx->buffer[bytes + pad + 4] =
+ SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
+
+ /* Process last bytes. */
+ md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
+
+ return md5_read_ctx(ctx, resbuf);
+}
+
+/* Compute MD5 message digest for bytes read from STREAM. The
+ resulting message digest number will be written into the 16 bytes
+ beginning at RESBLOCK. */
+int md5_stream(FILE *stream, void *resblock)
+{
+ /* Important: BLOCKSIZE must be a multiple of 64. */
+#define BLOCKSIZE 4096
+ struct md5_ctx ctx;
+ char buffer[BLOCKSIZE + 72];
+ size_t sum;
+
+ /* Initialize the computation context. */
+ md5_init_ctx(&ctx);
+
+ /* Iterate over full file contents. */
+ while (1) {
+ /* We read the file in blocks of BLOCKSIZE bytes. One call of the
+ computation function processes the whole buffer so that with the
+ next round of the loop another block can be read. */
+ size_t n;
+ sum = 0;
+
+ /* Read block. Take care for partial reads. */
+ do {
+ n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+ sum += n;
+ }
+ while (sum < BLOCKSIZE && n != 0);
+ if (n == 0 && ferror(stream))
+ return 1;
+
+ /* If end of file is reached, end the loop. */
+ if (n == 0)
+ break;
+
+ /* Process buffer with BLOCKSIZE bytes. Note that
+ BLOCKSIZE % 64 == 0
+ */
+ md5_process_block(buffer, BLOCKSIZE, &ctx);
+ }
+
+ /* Add the last bytes if necessary. */
+ if (sum > 0)
+ md5_process_bytes(buffer, sum, &ctx);
+
+ /* Construct result in desired memory. */
+ md5_finish_ctx(&ctx, resblock);
+ return 0;
+}
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
+ result is always in little endian byte order, so that a byte-wise
+ output yields to the wanted ASCII representation of the message
+ digest. */
+void *md5_buffer(const char *buffer, size_t len, void *resblock)
+{
+ struct md5_ctx ctx;
+
+ /* Initialize the computation context. */
+ md5_init_ctx(&ctx);
+
+ /* Process whole buffer but last len % 64 bytes. */
+ md5_process_bytes(buffer, len, &ctx);
+
+ /* Put result in desired memory area. */
+ return md5_finish_ctx(&ctx, resblock);
+}
+
+void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
+{
+ /* When we already have some bits in our internal buffer concatenate
+ both inputs first. */
+ if (ctx->buflen != 0) {
+ size_t left_over = ctx->buflen;
+ size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+ memcpy(&ctx->buffer[left_over], buffer, add);
+ ctx->buflen += add;
+
+ if (left_over + add > 64) {
+ md5_process_block(ctx->buffer, (left_over + add) & ~63, ctx);
+ /* The regions in the following copy operation cannot overlap. */
+ memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
+ (left_over + add) & 63);
+ ctx->buflen = (left_over + add) & 63;
+ }
+
+ buffer = (const char *) buffer + add;
+ len -= add;
+ }
+
+ /* Process available complete blocks. */
+ if (len > 64) {
+ md5_process_block(buffer, len & ~63, ctx);
+ buffer = (const char *) buffer + (len & ~63);
+ len &= 63;
+ }
+
+ /* Move remaining bytes in internal buffer. */
+ if (len > 0) {
+ memcpy(ctx->buffer, buffer, len);
+ ctx->buflen = len;
+ }
+}
+
+/* These are the four functions used in the four steps of the MD5 algorithm
+ and defined in the RFC 1321. The first function is a little bit optimized
+ (as found in Colin Plumbs public domain implementation). */
+/* #define FF(b, c, d) ((b & c) | (~b & d)) */
+#define FF(b, c, d) (d ^ (b & (c ^ d)))
+#define FG(b, c, d) FF (d, b, c)
+#define FH(b, c, d) (b ^ c ^ d)
+#define FI(b, c, d) (c ^ (b | ~d))
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+ It is assumed that LEN % 64 == 0. */
+void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
+{
+ md5_uint32 correct_words[16];
+ const md5_uint32 *words = buffer;
+ size_t nwords = len / sizeof(md5_uint32);
+ const md5_uint32 *endp = words + nwords;
+ md5_uint32 A = ctx->A;
+ md5_uint32 B = ctx->B;
+ md5_uint32 C = ctx->C;
+ md5_uint32 D = ctx->D;
+
+ /* First increment the byte count. RFC 1321 specifies the possible
+ length of the file up to 2^64 bits. Here we only compute the
+ number of bytes. Do a double word increment. */
+ ctx->total[0] += len;
+ if (ctx->total[0] < len)
+ ++ctx->total[1];
+
+ /* Process all bytes in the buffer with 64 bytes in each round of
+ the loop. */
+ while (words < endp) {
+ md5_uint32 *cwp = correct_words;
+ md5_uint32 A_save = A;
+ md5_uint32 B_save = B;
+ md5_uint32 C_save = C;
+ md5_uint32 D_save = D;
+
+ /* First round: using the given function, the context and a constant
+ the next context is computed. Because the algorithms processing
+ unit is a 32-bit word and it is determined to work on words in
+ little endian byte order we perhaps have to change the byte order
+ before the computation. To reduce the work for the next steps
+ we store the swapped words in the array CORRECT_WORDS. */
+
+#define OP(a, b, c, d, s, T) \
+ do \
+ { \
+ a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
+ ++words; \
+ CYCLIC (a, s); \
+ a += b; \
+ } \
+ while (0)
+
+ /* It is unfortunate that C does not provide an operator for
+ cyclic rotation. Hope the C compiler is smart enough. */
+#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
+
+ /* Before we start, one word to the strange constants.
+ They are defined in RFC 1321 as
+
+ T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+ */
+
+ /* Round 1. */
+ OP(A, B, C, D, 7, 0xd76aa478);
+ OP(D, A, B, C, 12, 0xe8c7b756);
+ OP(C, D, A, B, 17, 0x242070db);
+ OP(B, C, D, A, 22, 0xc1bdceee);
+ OP(A, B, C, D, 7, 0xf57c0faf);
+ OP(D, A, B, C, 12, 0x4787c62a);
+ OP(C, D, A, B, 17, 0xa8304613);
+ OP(B, C, D, A, 22, 0xfd469501);
+ OP(A, B, C, D, 7, 0x698098d8);
+ OP(D, A, B, C, 12, 0x8b44f7af);
+ OP(C, D, A, B, 17, 0xffff5bb1);
+ OP(B, C, D, A, 22, 0x895cd7be);
+ OP(A, B, C, D, 7, 0x6b901122);
+ OP(D, A, B, C, 12, 0xfd987193);
+ OP(C, D, A, B, 17, 0xa679438e);
+ OP(B, C, D, A, 22, 0x49b40821);
+
+ /* For the second to fourth round we have the possibly swapped words
+ in CORRECT_WORDS. Redefine the macro to take an additional first
+ argument specifying the function to use. */
+#undef OP
+#define OP(f, a, b, c, d, k, s, T) \
+ do \
+ { \
+ a += f (b, c, d) + correct_words[k] + T; \
+ CYCLIC (a, s); \
+ a += b; \
+ } \
+ while (0)
+
+ /* Round 2. */
+ OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
+ OP(FG, D, A, B, C, 6, 9, 0xc040b340);
+ OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
+ OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
+ OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
+ OP(FG, D, A, B, C, 10, 9, 0x02441453);
+ OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
+ OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
+ OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
+ OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
+ OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
+ OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
+ OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
+ OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
+ OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
+ OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+
+ /* Round 3. */
+ OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
+ OP(FH, D, A, B, C, 8, 11, 0x8771f681);
+ OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
+ OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
+ OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
+ OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
+ OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
+ OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
+ OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
+ OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
+ OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
+ OP(FH, B, C, D, A, 6, 23, 0x04881d05);
+ OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
+ OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
+ OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+ OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
+
+ /* Round 4. */
+ OP(FI, A, B, C, D, 0, 6, 0xf4292244);
+ OP(FI, D, A, B, C, 7, 10, 0x432aff97);
+ OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
+ OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
+ OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
+ OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
+ OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
+ OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
+ OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
+ OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+ OP(FI, C, D, A, B, 6, 15, 0xa3014314);
+ OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
+ OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
+ OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
+ OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
+ OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
+
+ /* Add the starting values of the context. */
+ A += A_save;
+ B += B_save;
+ C += C_save;
+ D += D_save;
+ }
+
+ /* Put checksum in context given as argument. */
+ ctx->A = A;
+ ctx->B = B;
+ ctx->C = C;
+ ctx->D = D;
+}
+
+//----------------------------------------------------------------------------
+//--------end of md5.c
+//----------------------------------------------------------------------------
+
+#define ISWHITE(c) ((c) == ' ' || (c) == '\t')
+#define IN_CTYPE_DOMAIN(c) 1
+#define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c))
+#define STREQ(a, b) (strcmp ((a), (b)) == 0)
+#define TOLOWER(Ch) tolower (Ch)
+#define OPENOPTS(BINARY) "r"
+
+/* The minimum length of a valid digest line in a file produced
+ by `md5sum FILE' and read by `md5sum -c'. This length does
+ not include any newline character at the end of a line. */
+#define MIN_DIGEST_LINE_LENGTH 35 /* 32 - message digest length
+ 2 - blank and binary indicator
+ 1 - minimum filename length */
+
+static int have_read_stdin; /* Nonzero if any of the files read were
+ the standard input. */
+
+static int status_only = 0; /* With -c, don't generate any output.
+ The exit code indicates success or failure */
+static int warn = 0; /* With -w, print a message to standard error warning
+ about each improperly formatted MD5 checksum line */
+
+static const char md5sum_usage[] =
+ "md5sum [OPTION] [FILE]...\n"
+ "or: md5sum [OPTION] -c [FILE]\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nPrint or check MD5 checksums.\n\n"
+ "Options:\n"
+ "With no FILE, or when FILE is -, read standard input.\n\n"
+ "\t-b\tread files in binary mode\n"
+ "\t-c\tcheck MD5 sums against given list\n"
+ "\t-t\tread files in text mode (default)\n"
+ "\t-g\tread a string\n"
+ "\nThe following two options are useful only when verifying checksums:\n"
+ "\t-s,\tdon't output anything, status code shows success\n"
+ "\t-w,\twarn about improperly formated MD5 checksum lines\n"
+#endif
+;
+
+static int split_3(char *s,
+ size_t s_len,
+ unsigned char **u,
+ int *binary,
+ char **w)
+{
+ size_t i = 0;
+ int escaped_filename = 0;
+
+ while (ISWHITE(s[i]))
+ ++i;
+
+ /* The line must have at least 35 (36 if the first is a backslash)
+ more characters to contain correct message digest information.
+ Ignore this line if it is too short. */
+ if (!(s_len - i >= MIN_DIGEST_LINE_LENGTH
+ || (s[i] == '\\' && s_len - i >= 1 + MIN_DIGEST_LINE_LENGTH)))
+ return FALSE;
+
+ if (s[i] == '\\') {
+ ++i;
+ escaped_filename = 1;
+ }
+ *u = (unsigned char *) &s[i];
+
+ /* The first field has to be the 32-character hexadecimal
+ representation of the message digest. If it is not followed
+ immediately by a white space it's an error. */
+ i += 32;
+ if (!ISWHITE(s[i]))
+ return FALSE;
+
+ s[i++] = '\0';
+
+ if (s[i] != ' ' && s[i] != '*')
+ return FALSE;
+ *binary = (s[i++] == '*');
+
+ /* All characters between the type indicator and end of line are
+ significant -- that includes leading and trailing white space. */
+ *w = &s[i];
+
+ if (escaped_filename) {
+ /* Translate each `\n' string in the file name to a NEWLINE,
+ and each `\\' string to a backslash. */
+
+ char *dst = &s[i];
+
+ while (i < s_len) {
+ switch (s[i]) {
+ case '\\':
+ if (i == s_len - 1) {
+ /* A valid line does not end with a backslash. */
+ return FALSE;
+ }
+ ++i;
+ switch (s[i++]) {
+ case 'n':
+ *dst++ = '\n';
+ break;
+ case '\\':
+ *dst++ = '\\';
+ break;
+ default:
+ /* Only `\' or `n' may follow a backslash. */
+ return FALSE;
+ }
+ break;
+
+ case '\0':
+ /* The file name may not contain a NUL. */
+ return FALSE;
+ break;
+
+ default:
+ *dst++ = s[i++];
+ break;
+ }
+ }
+ *dst = '\0';
+ }
+ return TRUE;
+}
+
+static int hex_digits(unsigned char const *s)
+{
+ while (*s) {
+ if (!ISXDIGIT(*s))
+ return TRUE;
+ ++s;
+ }
+ return FALSE;
+}
+
+/* An interface to md5_stream. Operate on FILENAME (it may be "-") and
+ put the result in *MD5_RESULT. Return non-zero upon failure, zero
+ to indicate success. */
+static int md5_file(const char *filename,
+ int binary,
+ unsigned char *md5_result)
+{
+ FILE *fp;
+
+ if (STREQ(filename, "-")) {
+ have_read_stdin = 1;
+ fp = stdin;
+ } else {
+ fp = fopen(filename, OPENOPTS(binary));
+ if (fp == NULL) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+ return FALSE;
+ }
+ }
+
+ if (md5_stream(fp, md5_result)) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+
+ if (fp != stdin)
+ fclose(fp);
+ return FALSE;
+ }
+
+ if (fp != stdin && fclose(fp) == EOF) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static int md5_check(const char *checkfile_name)
+{
+ FILE *checkfile_stream;
+ int n_properly_formated_lines = 0;
+ int n_mismatched_checksums = 0;
+ int n_open_or_read_failures = 0;
+ unsigned char md5buffer[16];
+ size_t line_number;
+ char *line;
+ size_t line_chars_allocated;
+
+ if (STREQ(checkfile_name, "-")) {
+ have_read_stdin = 1;
+ checkfile_stream = stdin;
+ } else {
+ checkfile_stream = fopen(checkfile_name, "r");
+ if (checkfile_stream == NULL) {
+ errorMsg("md5sum: %s: %s\n", checkfile_name, strerror(errno));
+ return FALSE;
+ }
+ }
+
+ line_number = 0;
+ line = 0;
+ line_chars_allocated = 0;
+
+ do {
+ char *filename;
+ int binary;
+ unsigned char *md5num;
+ int line_length;
+
+ ++line_number;
+
+ line_length = getline(&line, &line_chars_allocated, checkfile_stream);
+
+ if (line_length <= 0)
+ break;
+
+ /* Ignore comment lines, which begin with a '#' character. */
+ if (line[0] == '#')
+ continue;
+
+ /* Remove any trailing newline. */
+ if (line[line_length - 1] == '\n')
+ line[--line_length] = '\0';
+
+ if (split_3(line, line_length, &md5num, &binary, &filename)
+ || !hex_digits(md5num)) {
+ if (warn) {
+ errorMsg("%s: %lu: improperly formatted MD5 checksum line\n",
+ checkfile_name, (unsigned long) line_number);
+ }
+ } else {
+ static const char bin2hex[] = {
+ '0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 'c', 'd', 'e', 'f'
+ };
+
+ ++n_properly_formated_lines;
+
+ if (md5_file(filename, binary, md5buffer)) {
+ ++n_open_or_read_failures;
+ if (!status_only) {
+ printf("%s: FAILED open or read\n", filename);
+ fflush(stdout);
+ }
+ } else {
+ size_t cnt;
+ /* Compare generated binary number with text representation
+ in check file. Ignore case of hex digits. */
+ for (cnt = 0; cnt < 16; ++cnt) {
+ if (TOLOWER(md5num[2 * cnt])
+ != bin2hex[md5buffer[cnt] >> 4]
+ || (TOLOWER(md5num[2 * cnt + 1])
+ != (bin2hex[md5buffer[cnt] & 0xf])))
+ break;
+ }
+ if (cnt != 16)
+ ++n_mismatched_checksums;
+
+ if (!status_only) {
+ printf("%s: %s\n", filename,
+ (cnt != 16 ? "FAILED" : "OK"));
+ fflush(stdout);
+ }
+ }
+ }
+ }
+
+ while (!feof(checkfile_stream) && !ferror(checkfile_stream));
+
+ if (line)
+ free(line);
+
+ if (ferror(checkfile_stream)) {
+ errorMsg("%s: read error", checkfile_name); /* */
+ return FALSE;
+ }
+
+ if (checkfile_stream != stdin && fclose(checkfile_stream) == EOF) {
+ errorMsg("md5sum: %s: %s\n", checkfile_name, strerror(errno));
+ return FALSE;
+ }
+
+ if (n_properly_formated_lines == 0) {
+ /* Warn if no tests are found. */
+ errorMsg("%s: no properly formatted MD5 checksum lines found\n",
+ checkfile_name);
+ return FALSE;
+ } else {
+ if (!status_only) {
+ int n_computed_checkums = (n_properly_formated_lines
+ - n_open_or_read_failures);
+
+ if (n_open_or_read_failures > 0) {
+ errorMsg("WARNING: %d of %d listed files could not be read\n",
+ n_open_or_read_failures, n_properly_formated_lines);
+ return FALSE;
+ }
+
+ if (n_mismatched_checksums > 0) {
+ errorMsg("WARNING: %d of %d computed checksums did NOT match\n",
+ n_mismatched_checksums, n_computed_checkums);
+ return FALSE;
+ }
+ }
+ }
+
+ return ((n_properly_formated_lines > 0 && n_mismatched_checksums == 0
+ && n_open_or_read_failures == 0) ? 0 : 1);
+}
+
+int md5sum_main(int argc,
+ char **argv)
+{
+ unsigned char md5buffer[16];
+ int do_check = 0;
+ int opt;
+ char **string = NULL;
+ size_t n_strings = 0;
+ size_t err = 0;
+ int file_type_specified = 0;
+ int binary = 0;
+
+ while ((opt = getopt(argc, argv, "g:bcstw")) != -1) {
+ switch (opt) {
+ case 'g': { /* read a string */
+ if (string == NULL)
+ string = (char **) xmalloc ((argc - 1) * sizeof (char *));
+
+ if (optarg == NULL)
+ optarg = "";
+ string[n_strings++] = optarg;
+ break;
+ }
+
+ case 'b': /* read files in binary mode */
+ file_type_specified = 1;
+ binary = 1;
+ break;
+
+ case 'c': /* check MD5 sums against given list */
+ do_check = 1;
+ break;
+
+ case 's': /* don't output anything, status code shows success */
+ status_only = 1;
+ warn = 0;
+ break;
+
+ case 't': /* read files in text mode (default) */
+ file_type_specified = 1;
+ binary = 0;
+ break;
+
+ case 'w': /* warn about improperly formated MD5 checksum lines */
+ status_only = 0;
+ warn = 1;
+ break;
+
+ default:
+ usage(md5sum_usage);
+ }
+ }
+
+ if (file_type_specified && do_check) {
+ errorMsg("the -b and -t options are meaningless when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (n_strings > 0 && do_check) {
+ errorMsg("the -g and -c options are mutually exclusive\n");
+ exit FALSE;
+ }
+
+ if (status_only && !do_check) {
+ errorMsg("the -s option is meaningful only when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (warn && !do_check) {
+ errorMsg("the -w option is meaningful only when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (n_strings > 0) {
+ size_t i;
+
+ if (optind < argc) {
+ errorMsg("no files may be specified when using -g\n");
+ exit FALSE;
+ }
+ for (i = 0; i < n_strings; ++i) {
+ size_t cnt;
+ md5_buffer (string[i], strlen (string[i]), md5buffer);
+
+ for (cnt = 0; cnt < 16; ++cnt)
+ printf ("%02x", md5buffer[cnt]);
+
+ printf (" \"%s\"\n", string[i]);
+ }
+ } else if (do_check) {
+ if (optind + 1 < argc) {
+ errorMsg("only one argument may be specified when using -c\n");
+ }
+
+ err = md5_check ((optind == argc) ? "-" : argv[optind]);
+ } else {
+ if (optind == argc)
+ argv[argc++] = "-";
+
+ for (; optind < argc; ++optind) {
+ int fail;
+ char *file = argv[optind];
+
+ fail = md5_file (file, binary, md5buffer);
+ err |= fail;
+ if (!fail) {
+ size_t i;
+ /* Output a leading backslash if the file name contains
+ a newline or backslash. */
+ if (strchr (file, '\n') || strchr (file, '\\'))
+ putchar ('\\');
+
+ for (i = 0; i < 16; ++i)
+ printf ("%02x", md5buffer[i]);
+
+ putchar (' ');
+ if (binary)
+ putchar ('*');
+ else
+ putchar (' ');
+
+ /* Translate each NEWLINE byte to the string, "\\n",
+ and each backslash to "\\\\". */
+ for (i = 0; i < strlen (file); ++i) {
+ switch (file[i]) {
+ case '\n':
+ fputs ("\\n", stdout);
+ break;
+
+ case '\\':
+ fputs ("\\\\", stdout);
+ break;
+
+ default:
+ putchar (file[i]);
+ break;
+ }
+ }
+ putchar ('\n');
+ }
+ }
+ }
+
+ if (fclose (stdout) == EOF) {
+ errorMsg("write error");
+ exit FALSE;
+ }
+
+ if (have_read_stdin && fclose (stdin) == EOF) {
+ errorMsg("standard input");
+ exit FALSE;
+ }
+
+ exit (err == 0 ? TRUE : FALSE);
+}
--- /dev/null
+/* uudecode.c -- uudecode utility.
+ * Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+ *
+ * This product is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This product is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this product; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* Reworked to GNU style by Ian Lance Taylor, ian@airs.com, August 93. */
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <pwd.h>
+
+/*struct passwd *getpwnam();*/
+
+/* Single character decode. */
+#define DEC(Char) (((Char) - ' ') & 077)
+
+static int read_stduu (const char *inname)
+{
+ char buf[2 * BUFSIZ];
+
+ while (1) {
+ int n;
+ char *p;
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL) {
+ errorMsg("%s: Short file\n", inname);
+ return FALSE;
+ }
+ p = buf;
+
+ /* N is used to avoid writing out all the characters at the end of
+ the file. */
+ n = DEC (*p);
+ if (n <= 0)
+ break;
+ for (++p; n > 0; p += 4, n -= 3) {
+ char ch;
+
+ if (n >= 3) {
+ ch = DEC (p[0]) << 2 | DEC (p[1]) >> 4;
+ putchar (ch);
+ ch = DEC (p[1]) << 4 | DEC (p[2]) >> 2;
+ putchar (ch);
+ ch = DEC (p[2]) << 6 | DEC (p[3]);
+ putchar (ch);
+ } else {
+ if (n >= 1) {
+ ch = DEC (p[0]) << 2 | DEC (p[1]) >> 4;
+ putchar (ch);
+ }
+ if (n >= 2) {
+ ch = DEC (p[1]) << 4 | DEC (p[2]) >> 2;
+ putchar (ch);
+ }
+ }
+ }
+ }
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL
+ || strcmp (buf, "end\n")) {
+ errorMsg("%s: No `end' line\n", inname);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static int read_base64 (const char *inname)
+{
+ static const char b64_tab[256] = {
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*000-007*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*010-017*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*020-027*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*030-037*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*040-047*/
+ '\177', '\177', '\177', '\76', '\177', '\177', '\177', '\77', /*050-057*/
+ '\64', '\65', '\66', '\67', '\70', '\71', '\72', '\73', /*060-067*/
+ '\74', '\75', '\177', '\177', '\177', '\100', '\177', '\177', /*070-077*/
+ '\177', '\0', '\1', '\2', '\3', '\4', '\5', '\6', /*100-107*/
+ '\7', '\10', '\11', '\12', '\13', '\14', '\15', '\16', /*110-117*/
+ '\17', '\20', '\21', '\22', '\23', '\24', '\25', '\26', /*120-127*/
+ '\27', '\30', '\31', '\177', '\177', '\177', '\177', '\177', /*130-137*/
+ '\177', '\32', '\33', '\34', '\35', '\36', '\37', '\40', /*140-147*/
+ '\41', '\42', '\43', '\44', '\45', '\46', '\47', '\50', /*150-157*/
+ '\51', '\52', '\53', '\54', '\55', '\56', '\57', '\60', /*160-167*/
+ '\61', '\62', '\63', '\177', '\177', '\177', '\177', '\177', /*170-177*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*200-207*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*210-217*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*220-227*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*230-237*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*240-247*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*250-257*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*260-267*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*270-277*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*300-307*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*310-317*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*320-327*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*330-337*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*340-347*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*350-357*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*360-367*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*370-377*/
+ };
+ unsigned char buf[2 * BUFSIZ];
+
+ while (1) {
+ int last_data = 0;
+ unsigned char *p;
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL) {
+ errorMsg("%s: Short file\n", inname);
+ return FALSE;
+ }
+ p = buf;
+
+ if (memcmp (buf, "====", 4) == 0)
+ break;
+ if (last_data != 0) {
+ errorMsg("%s: data following `=' padding character\n", inname);
+ return FALSE;
+ }
+
+ /* The following implementation of the base64 decoding might look
+ a bit clumsy but I only try to follow the POSIX standard:
+ ``All line breaks or other characters not found in the table
+ [with base64 characters] shall be ignored by decoding
+ software.'' */
+ while (*p != '\n') {
+ char c1, c2, c3;
+
+ while ((b64_tab[*p] & '\100') != 0)
+ if (*p == '\n' || *p++ == '=')
+ break;
+ if (*p == '\n')
+ /* This leaves the loop. */
+ continue;
+ c1 = b64_tab[*p++];
+
+ while ((b64_tab[*p] & '\100') != 0)
+ if (*p == '\n' || *p++ == '=') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ c2 = b64_tab[*p++];
+
+ while (b64_tab[*p] == '\177')
+ if (*p++ == '\n') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ if (*p == '=') {
+ putchar (c1 << 2 | c2 >> 4);
+ last_data = 1;
+ break;
+ }
+ c3 = b64_tab[*p++];
+
+ while (b64_tab[*p] == '\177')
+ if (*p++ == '\n') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ putchar (c1 << 2 | c2 >> 4);
+ putchar (c2 << 4 | c3 >> 2);
+ if (*p == '=') {
+ last_data = 1;
+ break;
+ }
+ else
+ putchar (c3 << 6 | b64_tab[*p++]);
+ }
+ }
+
+ return TRUE;
+}
+
+static int decode (const char *inname,
+ const char *forced_outname)
+{
+ struct passwd *pw;
+ register int n;
+ register char *p;
+ int mode, n1;
+ char buf[2 * BUFSIZ];
+ char *outname;
+ int do_base64 = 0;
+
+ /* Search for header line. */
+
+ while (1) {
+ if (fgets (buf, sizeof (buf), stdin) == NULL) {
+ errorMsg("%s: No `begin' line\n", inname);
+ return FALSE;
+ }
+
+ if (strncmp (buf, "begin", 5) == 0) {
+ if (sscanf (buf, "begin-base64 %o %s", &mode, buf) == 2) {
+ do_base64 = 1;
+ break;
+ } else if (sscanf (buf, "begin %o %s", &mode, buf) == 2)
+ break;
+ }
+ }
+
+ /* If the output file name is given on the command line this rules. */
+ if (forced_outname != NULL)
+ outname = (char *) forced_outname;
+ else {
+ /* Handle ~user/file format. */
+ if (buf[0] != '~')
+ outname = buf;
+ else {
+ p = buf + 1;
+ while (*p != '/')
+ ++p;
+ if (*p == '\0') {
+ errorMsg("%s: Illegal ~user\n", inname);
+ return FALSE;
+ }
+ *p++ = '\0';
+ pw = getpwnam (buf + 1);
+ if (pw == NULL) {
+ errorMsg("%s: No user `%s'\n", inname, buf + 1);
+ return FALSE;
+ }
+ n = strlen (pw->pw_dir);
+ n1 = strlen (p);
+ outname = (char *) alloca ((size_t) (n + n1 + 2));
+ memcpy (outname + n + 1, p, (size_t) (n1 + 1));
+ memcpy (outname, pw->pw_dir, (size_t) n);
+ outname[n] = '/';
+ }
+ }
+
+ /* Create output file and set mode. */
+ if (strcmp (outname, "/dev/stdout") != 0 && strcmp (outname, "-") != 0
+ && (freopen (outname, "w", stdout) == NULL
+ || chmod (outname, mode & (S_IRWXU | S_IRWXG | S_IRWXO))
+ )) {
+ errorMsg("uudeoce %s: %s %s\n", outname, inname, strerror(errno)); /* */
+ return FALSE;
+ }
+
+ /* We differenciate decoding standard UU encoding and base64. A
+ common function would only slow down the program. */
+
+ /* For each input line: */
+ if (do_base64)
+ return read_base64 (inname);
+ else
+ return read_stduu (inname);
+}
+
+static const char uudecode_usage[] =
+ "uudecode [FILE]...\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nUudecode a file that is uuencoded.\n\n"
+ "Options:\n"
+ "\t-o FILE\tdirect output to FILE\n"
+#endif
+;
+
+int uudecode_main (int argc,
+ char **argv)
+{
+ int opt;
+ int exit_status;
+ const char *outname;
+ outname = NULL;
+
+ while ((opt = getopt(argc, argv, "o:")) != EOF) {
+ switch (opt) {
+ case 0:
+ break;
+
+ case 'o':
+ outname = optarg;
+ break;
+
+ default:
+ usage(uudecode_usage);
+ }
+ }
+
+ if (optind == argc)
+ exit_status = decode ("stdin", outname) == 0 ? TRUE : FALSE;
+ else {
+ exit_status = TRUE;
+ do {
+ if (freopen (argv[optind], "r", stdin) != NULL) {
+ if (decode (argv[optind], outname) != 0)
+ exit_status = FALSE;
+ } else {
+ errorMsg("uudecode: %s: %s\n", argv[optind], strerror(errno));
+ exit_status = FALSE;
+ }
+ optind++;
+ }
+ while (optind < argc);
+ }
+ exit(exit_status);
+}
--- /dev/null
+/* uuencode.c -- uuencode utility.
+ * Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+ *
+ * This product is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This product is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this product; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* Reworked to GNU style by Ian Lance Taylor, ian@airs.com, August 93. */
+/* Hacked to work with BusyBox by Alfred M. Szmidt */
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <pwd.h>
+
+#define RW (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
+
+static void encode __P ((void));
+
+/* Pointer to the translation table we currently use. */
+const char *trans_ptr;
+
+/* The two currently defined translation tables. The first is the
+ standard uuencoding, the second is base64 encoding. */
+const char uu_std[64] = {
+ '`', '!', '"', '#', '$', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', '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', '[', '\\', ']', '^', '_'
+};
+
+const char uu_base64[64] = {
+ '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', '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', '0', '1', '2', '3',
+ '4', '5', '6', '7', '8', '9', '+', '/'
+};
+
+/* ENC is the basic 1 character encoding function to make a char printing. */
+#define ENC(Char) (trans_ptr[(Char) & 077])
+
+/* Copy from IN to OUT, encoding as you go along. */
+static void encode()
+{
+ register int ch, n;
+ char *p = NULL;
+ char buf[80];
+
+ while (1) {
+ n = 0;
+ do {
+ register int m = fread (buf, 1, 45 - n, stdin);
+ if (m == 0)
+ break;
+ n += m;
+ }
+ while (n < 45);
+
+ if (n == 0)
+ break;
+
+ if (trans_ptr == uu_std)
+ if (putchar (ENC (n)) == EOF)
+ break;
+ for (p = buf; n > 2; n -= 3, p += 3) {
+ ch = *p >> 2;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = ((*p << 4) & 060) | ((p[1] >> 4) & 017);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = ((p[1] << 2) & 074) | ((p[2] >> 6) & 03);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = p[2] & 077;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ }
+
+ if (n != 0)
+ break;
+
+ if (putchar ('\n') == EOF)
+ break;
+ }
+
+ while (n != 0) {
+ char c1 = *p;
+ char c2 = n == 1 ? 0 : p[1];
+
+ ch = c1 >> 2;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+
+ ch = ((c1 << 4) & 060) | ((c2 >> 4) & 017);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+
+ if (n == 1)
+ ch = trans_ptr == uu_std ? ENC ('\0') : '=';
+ else {
+ ch = (c2 << 2) & 074;
+ ch = ENC (ch);
+ }
+ if (putchar (ch) == EOF)
+ break;
+ ch = trans_ptr == uu_std ? ENC ('\0') : '=';
+ if (putchar (ch) == EOF)
+ break;
+ putchar ('\n');
+ break;
+ }
+
+ if (ferror (stdin))
+ errorMsg("Read error\n");
+
+ if (trans_ptr == uu_std) {
+ putchar (ENC ('\0'));
+ putchar ('\n');
+ }
+}
+
+static const char uuencode_usage[] =
+ "uuencode [OPTION] [INFILE] REMOTEFILE\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nUuencode a file.\n\n"
+ "Options:\n"
+ "\t-m\tuse base64 encoding as of RFC1521\n"
+#endif
+;
+
+int uuencode_main (int argc,
+ char **argv)
+{
+ int opt;
+ struct stat sb;
+ int mode;
+
+ trans_ptr = uu_std; /* Standard encoding is old uu format */
+
+ /* Parse any options */
+ while ((opt = getopt (argc, argv, "m")) != EOF) {
+ switch (opt) {
+ case 'm':
+ trans_ptr = uu_base64;
+ break;
+
+ case 0:
+ break;
+
+ default:
+ usage(uuencode_usage);
+ }
+ }
+
+ switch (argc - optind) {
+ case 2:
+ /* Optional first argument is input file. */
+ if (!freopen (argv[optind], "r", stdin) || fstat (fileno (stdin), &sb)) {
+ errorMsg("uuencode: %s: %s\n", argv[optind], strerror(errno));
+ exit FALSE;
+ }
+ mode = sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
+ optind++;
+ break;
+
+ case 1:
+ mode = RW & ~umask (RW);
+ break;
+
+ case 0:
+ default:
+ usage(uuencode_usage);
+ }
+
+ printf("begin%s %o %s\n", trans_ptr == uu_std ? "" : "-base64",
+ mode, argv[optind]);
+ encode();
+ printf(trans_ptr == uu_std ? "end\n" : "====\n");
+ if (ferror (stdout)) {
+ errorMsg("Write error\n");
+ exit FALSE;
+ }
+ exit TRUE;
+}
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = (long)
(blocks_used * 100.0 / (blocks_used + s.f_bavail) + 0.5);
- /* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */
if (strcmp(device, "/dev/root") == 0) {
/* Adjusts device to be the real root device,
* or leaves device alone if it can't find it */
df, dirname, dmesg, du, dutmp, echo, false, fbset, fdflush, find, free,
freeramdisk, deallocvt, fsck.minix, grep, gunzip, gzip, halt, head, hostid,
hostname, id, init, kill, killall, length, ln, loadacm, loadfont, loadkmap,
-logger, logname, ls, lsmod, makedevs, math, mkdir, mkfifo, mkfs.minix, mknod,
-mkswap, mktemp, nc, more, mount, mt, mv, nslookup, ping, poweroff, printf, ps,
-pwd, reboot, rm, rmdir, rmmod, sed, setkeycodes, sh, sfdisk, sleep, sort, sync,
-syslogd, swapon, swapoff, tail, tar, test, tee, touch, tr, true, tty, umount,
-uname, uniq, update, uptime, usleep, wc, whoami, yes, zcat, [
+logger, logname, ls, lsmod, makedevs, math, md5sum, mkdir, mkfifo, mkfs.minix,
+mknod, mkswap, mktemp, nc, more, mount, mt, mv, nslookup, ping, poweroff,
+printf, ps, pwd, reboot, rm, rmdir, rmmod, sed, setkeycodes, sh, sfdisk, sleep,
+sort, sync, syslogd, swapon, swapoff, tail, tar, test, tee, touch, tr, true,
+tty, umount, uname, uniq, update, uptime, usleep, uudecode, uuencode, wc,
+whoami, yes, zcat, [
-------------------------------
-------------------------------
+=item md5sum
+
+Usage: md5sum [OPTION] [file ...]
+
+Print or check MD5 checksums.
+
+Options:
+
+ -b read files in binary mode
+ -c check MD5 sums against given list
+ -t read files in text mode (default)
+ -g read a string
+
+The following two options are useful only when verifying checksums:
+
+ -s don't output anything, status code shows success
+ -w warn about improperly formated MD5 checksum lines
+
+Example:
+
+ $ md5sum busybox
+ 6fd11e98b98a58f64ff3398d7b324003 busybox
+ $ md5sum -c -
+ 6fd11e98b98a58f64ff3398d7b324003 busybox
+ busybox: OK
+ ^D
+
+-------------------------------
+
=item mkdir
Usage: mkdir [OPTION] DIRECTORY...
-------------------------------
+=item uuencode
+
+Usage: uuencode [OPTION] [INFILE] REMOTEFILE
+
+Uuencode a file.
+
+Options:
+
+ -m use base64 encoding as of RFC1521
+
+Example:
+
+ $ uuencode busybox busybox
+ begin 755 busybox
+ M?T5,1@$!`0````````````(``P`!````L+@$"#0```!0N@,``````#0`(``&
+ .....
+ $ uudecode busybox busybox > busybox.uu
+ $
+
+-------------------------------
+
+=item uudecode
+
+Usage: uudecode [OPTION] [FILE]
+
+Uudecode a uuencoded file
+
+Options:
+
+ -o FILE direct output to FILE
+
+Example:
+
+ $ uudecode -o busybox busybox.uu
+ $ ls -l busybox
+ -rwxr-xr-x 1 ams ams 245264 Jun 7 21:35 busybox
+
+-------------------------------
+
=item umount
Usage: umount [flags] filesystem|directory
=cut
-# $Id: busybox.pod,v 1.40 2000/06/12 23:04:55 beppu Exp $
+# $Id: busybox.pod,v 1.41 2000/06/13 06:54:53 andersen Exp $
extern int lsmod_main(int argc, char** argv);
extern int makedevs_main(int argc, char** argv);
extern int math_main(int argc, char** argv);
+extern int md5sum_main(int argc, char** argv);
extern int mkdir_main(int argc, char** argv);
extern int mkfifo_main(int argc, char **argv);
extern int mkfs_minix_main(int argc, char **argv);
extern int tput_main(int argc, char** argv);
extern int tryopen_main(int argc, char** argv);
extern int tty_main(int argc, char** argv);
+extern int uuencode_main(int argc, char** argv);
+extern int uudecode_main(int argc, char** argv);
extern int umount_main(int argc, char** argv);
extern int uname_main(int argc, char** argv);
extern int uptime_main(int argc, char** argv);
--- /dev/null
+/* md5sum.c - Compute MD5 checksum of files or strings according to the
+ * definition of MD5 in RFC 1321 from April 1992.
+ * Copyright (C) 1995-1999 Free Software Foundation, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu> */
+/* Hacked to work with BusyBox by Alfred M. Szmidt <ams@trillian.itslinux.org> */
+
+#include "internal.h"
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.h>
+
+//----------------------------------------------------------------------------
+//--------md5.c
+//----------------------------------------------------------------------------
+
+/* md5.c - Functions to compute MD5 message digest of files or memory blocks
+ * according to the definition of MD5 in RFC 1321 from April 1992.
+ * Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ *
+ * NOTE: The canonical source of this file is maintained with the GNU C
+ * Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995. */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
+#include <endian.h>
+
+#include "internal.h"
+//----------------------------------------------------------------------------
+//--------md5.h
+//----------------------------------------------------------------------------
+
+/* md5.h - Declaration of functions and data types used for MD5 sum
+ computing library functions.
+ Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ NOTE: The canonical source of this file is maintained with the GNU C
+ Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+ This program is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2, or (at your option) any
+ later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+#ifndef _MD5_H
+#define _MD5_H 1
+
+#include <stdio.h>
+
+#if defined HAVE_LIMITS_H || _LIBC
+# include <limits.h>
+#endif
+
+/* The following contortions are an attempt to use the C preprocessor
+ to determine an unsigned integral type that is 32 bits wide. An
+ alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
+ doing that would require that the configure script compile and *run*
+ the resulting executable. Locally running cross-compiled executables
+ is usually not possible. */
+
+#ifdef _LIBC
+# include <sys/types.h>
+typedef u_int32_t md5_uint32;
+#else
+# if defined __STDC__ && __STDC__
+# define UINT_MAX_32_BITS 4294967295U
+# else
+# define UINT_MAX_32_BITS 0xFFFFFFFF
+# endif
+
+/* If UINT_MAX isn't defined, assume it's a 32-bit type.
+ This should be valid for all systems GNU cares about because
+ that doesn't include 16-bit systems, and only modern systems
+ (that certainly have <limits.h>) have 64+-bit integral types. */
+
+# ifndef UINT_MAX
+# define UINT_MAX UINT_MAX_32_BITS
+# endif
+
+# if UINT_MAX == UINT_MAX_32_BITS
+ typedef unsigned int md5_uint32;
+# else
+# if USHRT_MAX == UINT_MAX_32_BITS
+ typedef unsigned short md5_uint32;
+# else
+# if ULONG_MAX == UINT_MAX_32_BITS
+ typedef unsigned long md5_uint32;
+# else
+ /* The following line is intended to evoke an error.
+ Using #error is not portable enough. */
+ "Cannot determine unsigned 32-bit data type."
+# endif
+# endif
+# endif
+#endif
+
+#undef __P
+#if defined (__STDC__) && __STDC__
+#define __P(x) x
+#else
+#define __P(x) ()
+#endif
+
+/* Structure to save state of computation between the single steps. */
+struct md5_ctx
+{
+ md5_uint32 A;
+ md5_uint32 B;
+ md5_uint32 C;
+ md5_uint32 D;
+
+ md5_uint32 total[2];
+ md5_uint32 buflen;
+ char buffer[128];
+};
+
+/*
+ * The following three functions are build up the low level used in
+ * the functions `md5_stream' and `md5_buffer'.
+ */
+
+/* Initialize structure containing state of computation.
+ (RFC 1321, 3.3: Step 3) */
+extern void md5_init_ctx __P ((struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+ initialization function update the context for the next LEN bytes
+ starting at BUFFER.
+ It is necessary that LEN is a multiple of 64!!! */
+extern void md5_process_block __P ((const void *buffer, size_t len,
+ struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+ initialization function update the context for the next LEN bytes
+ starting at BUFFER.
+ It is NOT required that LEN is a multiple of 64. */
+extern void md5_process_bytes __P ((const void *buffer, size_t len,
+ struct md5_ctx *ctx));
+
+/* Process the remaining bytes in the buffer and put result from CTX
+ in first 16 bytes following RESBUF. The result is always in little
+ endian byte order, so that a byte-wise output yields to the wanted
+ ASCII representation of the message digest.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
+
+
+/* Put result from CTX in first 16 bytes following RESBUF. The result is
+ always in little endian byte order, so that a byte-wise output yields
+ to the wanted ASCII representation of the message digest.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
+
+
+/* Compute MD5 message digest for bytes read from STREAM. The
+ resulting message digest number will be written into the 16 bytes
+ beginning at RESBLOCK. */
+extern int md5_stream __P ((FILE *stream, void *resblock));
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
+ result is always in little endian byte order, so that a byte-wise
+ output yields to the wanted ASCII representation of the message
+ digest. */
+extern void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
+
+#endif
+
+//----------------------------------------------------------------------------
+//--------end of md5.h
+//----------------------------------------------------------------------------
+
+#define SWAP(n) (n)
+
+/* This array contains the bytes used to pad the buffer to the next
+ 64-byte boundary. (RFC 1321, 3.1: Step 1) */
+static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
+
+/* Initialize structure containing state of computation.
+ (RFC 1321, 3.3: Step 3) */
+void md5_init_ctx(struct md5_ctx *ctx)
+{
+ ctx->A = 0x67452301;
+ ctx->B = 0xefcdab89;
+ ctx->C = 0x98badcfe;
+ ctx->D = 0x10325476;
+
+ ctx->total[0] = ctx->total[1] = 0;
+ ctx->buflen = 0;
+}
+
+/* Put result from CTX in first 16 bytes following RESBUF. The result
+ must be in little endian byte order.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
+{
+ ((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
+ ((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
+ ((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
+ ((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
+
+ return resbuf;
+}
+
+/* Process the remaining bytes in the internal buffer and the usual
+ prolog according to the standard and write the result to RESBUF.
+
+ IMPORTANT: On some systems it is required that RESBUF is correctly
+ aligned for a 32 bits value. */
+void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
+{
+ /* Take yet unprocessed bytes into account. */
+ md5_uint32 bytes = ctx->buflen;
+ size_t pad;
+
+ /* Now count remaining bytes. */
+ ctx->total[0] += bytes;
+ if (ctx->total[0] < bytes)
+ ++ctx->total[1];
+
+ pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
+ memcpy(&ctx->buffer[bytes], fillbuf, pad);
+
+ /* Put the 64-bit file length in *bits* at the end of the buffer. */
+ *(md5_uint32 *) & ctx->buffer[bytes + pad] = SWAP(ctx->total[0] << 3);
+ *(md5_uint32 *) & ctx->buffer[bytes + pad + 4] =
+ SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
+
+ /* Process last bytes. */
+ md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
+
+ return md5_read_ctx(ctx, resbuf);
+}
+
+/* Compute MD5 message digest for bytes read from STREAM. The
+ resulting message digest number will be written into the 16 bytes
+ beginning at RESBLOCK. */
+int md5_stream(FILE *stream, void *resblock)
+{
+ /* Important: BLOCKSIZE must be a multiple of 64. */
+#define BLOCKSIZE 4096
+ struct md5_ctx ctx;
+ char buffer[BLOCKSIZE + 72];
+ size_t sum;
+
+ /* Initialize the computation context. */
+ md5_init_ctx(&ctx);
+
+ /* Iterate over full file contents. */
+ while (1) {
+ /* We read the file in blocks of BLOCKSIZE bytes. One call of the
+ computation function processes the whole buffer so that with the
+ next round of the loop another block can be read. */
+ size_t n;
+ sum = 0;
+
+ /* Read block. Take care for partial reads. */
+ do {
+ n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+ sum += n;
+ }
+ while (sum < BLOCKSIZE && n != 0);
+ if (n == 0 && ferror(stream))
+ return 1;
+
+ /* If end of file is reached, end the loop. */
+ if (n == 0)
+ break;
+
+ /* Process buffer with BLOCKSIZE bytes. Note that
+ BLOCKSIZE % 64 == 0
+ */
+ md5_process_block(buffer, BLOCKSIZE, &ctx);
+ }
+
+ /* Add the last bytes if necessary. */
+ if (sum > 0)
+ md5_process_bytes(buffer, sum, &ctx);
+
+ /* Construct result in desired memory. */
+ md5_finish_ctx(&ctx, resblock);
+ return 0;
+}
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
+ result is always in little endian byte order, so that a byte-wise
+ output yields to the wanted ASCII representation of the message
+ digest. */
+void *md5_buffer(const char *buffer, size_t len, void *resblock)
+{
+ struct md5_ctx ctx;
+
+ /* Initialize the computation context. */
+ md5_init_ctx(&ctx);
+
+ /* Process whole buffer but last len % 64 bytes. */
+ md5_process_bytes(buffer, len, &ctx);
+
+ /* Put result in desired memory area. */
+ return md5_finish_ctx(&ctx, resblock);
+}
+
+void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
+{
+ /* When we already have some bits in our internal buffer concatenate
+ both inputs first. */
+ if (ctx->buflen != 0) {
+ size_t left_over = ctx->buflen;
+ size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+ memcpy(&ctx->buffer[left_over], buffer, add);
+ ctx->buflen += add;
+
+ if (left_over + add > 64) {
+ md5_process_block(ctx->buffer, (left_over + add) & ~63, ctx);
+ /* The regions in the following copy operation cannot overlap. */
+ memcpy(ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
+ (left_over + add) & 63);
+ ctx->buflen = (left_over + add) & 63;
+ }
+
+ buffer = (const char *) buffer + add;
+ len -= add;
+ }
+
+ /* Process available complete blocks. */
+ if (len > 64) {
+ md5_process_block(buffer, len & ~63, ctx);
+ buffer = (const char *) buffer + (len & ~63);
+ len &= 63;
+ }
+
+ /* Move remaining bytes in internal buffer. */
+ if (len > 0) {
+ memcpy(ctx->buffer, buffer, len);
+ ctx->buflen = len;
+ }
+}
+
+/* These are the four functions used in the four steps of the MD5 algorithm
+ and defined in the RFC 1321. The first function is a little bit optimized
+ (as found in Colin Plumbs public domain implementation). */
+/* #define FF(b, c, d) ((b & c) | (~b & d)) */
+#define FF(b, c, d) (d ^ (b & (c ^ d)))
+#define FG(b, c, d) FF (d, b, c)
+#define FH(b, c, d) (b ^ c ^ d)
+#define FI(b, c, d) (c ^ (b | ~d))
+
+/* Process LEN bytes of BUFFER, accumulating context into CTX.
+ It is assumed that LEN % 64 == 0. */
+void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
+{
+ md5_uint32 correct_words[16];
+ const md5_uint32 *words = buffer;
+ size_t nwords = len / sizeof(md5_uint32);
+ const md5_uint32 *endp = words + nwords;
+ md5_uint32 A = ctx->A;
+ md5_uint32 B = ctx->B;
+ md5_uint32 C = ctx->C;
+ md5_uint32 D = ctx->D;
+
+ /* First increment the byte count. RFC 1321 specifies the possible
+ length of the file up to 2^64 bits. Here we only compute the
+ number of bytes. Do a double word increment. */
+ ctx->total[0] += len;
+ if (ctx->total[0] < len)
+ ++ctx->total[1];
+
+ /* Process all bytes in the buffer with 64 bytes in each round of
+ the loop. */
+ while (words < endp) {
+ md5_uint32 *cwp = correct_words;
+ md5_uint32 A_save = A;
+ md5_uint32 B_save = B;
+ md5_uint32 C_save = C;
+ md5_uint32 D_save = D;
+
+ /* First round: using the given function, the context and a constant
+ the next context is computed. Because the algorithms processing
+ unit is a 32-bit word and it is determined to work on words in
+ little endian byte order we perhaps have to change the byte order
+ before the computation. To reduce the work for the next steps
+ we store the swapped words in the array CORRECT_WORDS. */
+
+#define OP(a, b, c, d, s, T) \
+ do \
+ { \
+ a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \
+ ++words; \
+ CYCLIC (a, s); \
+ a += b; \
+ } \
+ while (0)
+
+ /* It is unfortunate that C does not provide an operator for
+ cyclic rotation. Hope the C compiler is smart enough. */
+#define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
+
+ /* Before we start, one word to the strange constants.
+ They are defined in RFC 1321 as
+
+ T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+ */
+
+ /* Round 1. */
+ OP(A, B, C, D, 7, 0xd76aa478);
+ OP(D, A, B, C, 12, 0xe8c7b756);
+ OP(C, D, A, B, 17, 0x242070db);
+ OP(B, C, D, A, 22, 0xc1bdceee);
+ OP(A, B, C, D, 7, 0xf57c0faf);
+ OP(D, A, B, C, 12, 0x4787c62a);
+ OP(C, D, A, B, 17, 0xa8304613);
+ OP(B, C, D, A, 22, 0xfd469501);
+ OP(A, B, C, D, 7, 0x698098d8);
+ OP(D, A, B, C, 12, 0x8b44f7af);
+ OP(C, D, A, B, 17, 0xffff5bb1);
+ OP(B, C, D, A, 22, 0x895cd7be);
+ OP(A, B, C, D, 7, 0x6b901122);
+ OP(D, A, B, C, 12, 0xfd987193);
+ OP(C, D, A, B, 17, 0xa679438e);
+ OP(B, C, D, A, 22, 0x49b40821);
+
+ /* For the second to fourth round we have the possibly swapped words
+ in CORRECT_WORDS. Redefine the macro to take an additional first
+ argument specifying the function to use. */
+#undef OP
+#define OP(f, a, b, c, d, k, s, T) \
+ do \
+ { \
+ a += f (b, c, d) + correct_words[k] + T; \
+ CYCLIC (a, s); \
+ a += b; \
+ } \
+ while (0)
+
+ /* Round 2. */
+ OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
+ OP(FG, D, A, B, C, 6, 9, 0xc040b340);
+ OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
+ OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
+ OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
+ OP(FG, D, A, B, C, 10, 9, 0x02441453);
+ OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
+ OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
+ OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
+ OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
+ OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
+ OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
+ OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
+ OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
+ OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
+ OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+
+ /* Round 3. */
+ OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
+ OP(FH, D, A, B, C, 8, 11, 0x8771f681);
+ OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
+ OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
+ OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
+ OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
+ OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
+ OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
+ OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
+ OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
+ OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
+ OP(FH, B, C, D, A, 6, 23, 0x04881d05);
+ OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
+ OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
+ OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+ OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
+
+ /* Round 4. */
+ OP(FI, A, B, C, D, 0, 6, 0xf4292244);
+ OP(FI, D, A, B, C, 7, 10, 0x432aff97);
+ OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
+ OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
+ OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
+ OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
+ OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
+ OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
+ OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
+ OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+ OP(FI, C, D, A, B, 6, 15, 0xa3014314);
+ OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
+ OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
+ OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
+ OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
+ OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
+
+ /* Add the starting values of the context. */
+ A += A_save;
+ B += B_save;
+ C += C_save;
+ D += D_save;
+ }
+
+ /* Put checksum in context given as argument. */
+ ctx->A = A;
+ ctx->B = B;
+ ctx->C = C;
+ ctx->D = D;
+}
+
+//----------------------------------------------------------------------------
+//--------end of md5.c
+//----------------------------------------------------------------------------
+
+#define ISWHITE(c) ((c) == ' ' || (c) == '\t')
+#define IN_CTYPE_DOMAIN(c) 1
+#define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c))
+#define STREQ(a, b) (strcmp ((a), (b)) == 0)
+#define TOLOWER(Ch) tolower (Ch)
+#define OPENOPTS(BINARY) "r"
+
+/* The minimum length of a valid digest line in a file produced
+ by `md5sum FILE' and read by `md5sum -c'. This length does
+ not include any newline character at the end of a line. */
+#define MIN_DIGEST_LINE_LENGTH 35 /* 32 - message digest length
+ 2 - blank and binary indicator
+ 1 - minimum filename length */
+
+static int have_read_stdin; /* Nonzero if any of the files read were
+ the standard input. */
+
+static int status_only = 0; /* With -c, don't generate any output.
+ The exit code indicates success or failure */
+static int warn = 0; /* With -w, print a message to standard error warning
+ about each improperly formatted MD5 checksum line */
+
+static const char md5sum_usage[] =
+ "md5sum [OPTION] [FILE]...\n"
+ "or: md5sum [OPTION] -c [FILE]\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nPrint or check MD5 checksums.\n\n"
+ "Options:\n"
+ "With no FILE, or when FILE is -, read standard input.\n\n"
+ "\t-b\tread files in binary mode\n"
+ "\t-c\tcheck MD5 sums against given list\n"
+ "\t-t\tread files in text mode (default)\n"
+ "\t-g\tread a string\n"
+ "\nThe following two options are useful only when verifying checksums:\n"
+ "\t-s,\tdon't output anything, status code shows success\n"
+ "\t-w,\twarn about improperly formated MD5 checksum lines\n"
+#endif
+;
+
+static int split_3(char *s,
+ size_t s_len,
+ unsigned char **u,
+ int *binary,
+ char **w)
+{
+ size_t i = 0;
+ int escaped_filename = 0;
+
+ while (ISWHITE(s[i]))
+ ++i;
+
+ /* The line must have at least 35 (36 if the first is a backslash)
+ more characters to contain correct message digest information.
+ Ignore this line if it is too short. */
+ if (!(s_len - i >= MIN_DIGEST_LINE_LENGTH
+ || (s[i] == '\\' && s_len - i >= 1 + MIN_DIGEST_LINE_LENGTH)))
+ return FALSE;
+
+ if (s[i] == '\\') {
+ ++i;
+ escaped_filename = 1;
+ }
+ *u = (unsigned char *) &s[i];
+
+ /* The first field has to be the 32-character hexadecimal
+ representation of the message digest. If it is not followed
+ immediately by a white space it's an error. */
+ i += 32;
+ if (!ISWHITE(s[i]))
+ return FALSE;
+
+ s[i++] = '\0';
+
+ if (s[i] != ' ' && s[i] != '*')
+ return FALSE;
+ *binary = (s[i++] == '*');
+
+ /* All characters between the type indicator and end of line are
+ significant -- that includes leading and trailing white space. */
+ *w = &s[i];
+
+ if (escaped_filename) {
+ /* Translate each `\n' string in the file name to a NEWLINE,
+ and each `\\' string to a backslash. */
+
+ char *dst = &s[i];
+
+ while (i < s_len) {
+ switch (s[i]) {
+ case '\\':
+ if (i == s_len - 1) {
+ /* A valid line does not end with a backslash. */
+ return FALSE;
+ }
+ ++i;
+ switch (s[i++]) {
+ case 'n':
+ *dst++ = '\n';
+ break;
+ case '\\':
+ *dst++ = '\\';
+ break;
+ default:
+ /* Only `\' or `n' may follow a backslash. */
+ return FALSE;
+ }
+ break;
+
+ case '\0':
+ /* The file name may not contain a NUL. */
+ return FALSE;
+ break;
+
+ default:
+ *dst++ = s[i++];
+ break;
+ }
+ }
+ *dst = '\0';
+ }
+ return TRUE;
+}
+
+static int hex_digits(unsigned char const *s)
+{
+ while (*s) {
+ if (!ISXDIGIT(*s))
+ return TRUE;
+ ++s;
+ }
+ return FALSE;
+}
+
+/* An interface to md5_stream. Operate on FILENAME (it may be "-") and
+ put the result in *MD5_RESULT. Return non-zero upon failure, zero
+ to indicate success. */
+static int md5_file(const char *filename,
+ int binary,
+ unsigned char *md5_result)
+{
+ FILE *fp;
+
+ if (STREQ(filename, "-")) {
+ have_read_stdin = 1;
+ fp = stdin;
+ } else {
+ fp = fopen(filename, OPENOPTS(binary));
+ if (fp == NULL) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+ return FALSE;
+ }
+ }
+
+ if (md5_stream(fp, md5_result)) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+
+ if (fp != stdin)
+ fclose(fp);
+ return FALSE;
+ }
+
+ if (fp != stdin && fclose(fp) == EOF) {
+ errorMsg("md5sum: %s: %s\n", filename, strerror(errno));
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static int md5_check(const char *checkfile_name)
+{
+ FILE *checkfile_stream;
+ int n_properly_formated_lines = 0;
+ int n_mismatched_checksums = 0;
+ int n_open_or_read_failures = 0;
+ unsigned char md5buffer[16];
+ size_t line_number;
+ char *line;
+ size_t line_chars_allocated;
+
+ if (STREQ(checkfile_name, "-")) {
+ have_read_stdin = 1;
+ checkfile_stream = stdin;
+ } else {
+ checkfile_stream = fopen(checkfile_name, "r");
+ if (checkfile_stream == NULL) {
+ errorMsg("md5sum: %s: %s\n", checkfile_name, strerror(errno));
+ return FALSE;
+ }
+ }
+
+ line_number = 0;
+ line = 0;
+ line_chars_allocated = 0;
+
+ do {
+ char *filename;
+ int binary;
+ unsigned char *md5num;
+ int line_length;
+
+ ++line_number;
+
+ line_length = getline(&line, &line_chars_allocated, checkfile_stream);
+
+ if (line_length <= 0)
+ break;
+
+ /* Ignore comment lines, which begin with a '#' character. */
+ if (line[0] == '#')
+ continue;
+
+ /* Remove any trailing newline. */
+ if (line[line_length - 1] == '\n')
+ line[--line_length] = '\0';
+
+ if (split_3(line, line_length, &md5num, &binary, &filename)
+ || !hex_digits(md5num)) {
+ if (warn) {
+ errorMsg("%s: %lu: improperly formatted MD5 checksum line\n",
+ checkfile_name, (unsigned long) line_number);
+ }
+ } else {
+ static const char bin2hex[] = {
+ '0', '1', '2', '3',
+ '4', '5', '6', '7',
+ '8', '9', 'a', 'b',
+ 'c', 'd', 'e', 'f'
+ };
+
+ ++n_properly_formated_lines;
+
+ if (md5_file(filename, binary, md5buffer)) {
+ ++n_open_or_read_failures;
+ if (!status_only) {
+ printf("%s: FAILED open or read\n", filename);
+ fflush(stdout);
+ }
+ } else {
+ size_t cnt;
+ /* Compare generated binary number with text representation
+ in check file. Ignore case of hex digits. */
+ for (cnt = 0; cnt < 16; ++cnt) {
+ if (TOLOWER(md5num[2 * cnt])
+ != bin2hex[md5buffer[cnt] >> 4]
+ || (TOLOWER(md5num[2 * cnt + 1])
+ != (bin2hex[md5buffer[cnt] & 0xf])))
+ break;
+ }
+ if (cnt != 16)
+ ++n_mismatched_checksums;
+
+ if (!status_only) {
+ printf("%s: %s\n", filename,
+ (cnt != 16 ? "FAILED" : "OK"));
+ fflush(stdout);
+ }
+ }
+ }
+ }
+
+ while (!feof(checkfile_stream) && !ferror(checkfile_stream));
+
+ if (line)
+ free(line);
+
+ if (ferror(checkfile_stream)) {
+ errorMsg("%s: read error", checkfile_name); /* */
+ return FALSE;
+ }
+
+ if (checkfile_stream != stdin && fclose(checkfile_stream) == EOF) {
+ errorMsg("md5sum: %s: %s\n", checkfile_name, strerror(errno));
+ return FALSE;
+ }
+
+ if (n_properly_formated_lines == 0) {
+ /* Warn if no tests are found. */
+ errorMsg("%s: no properly formatted MD5 checksum lines found\n",
+ checkfile_name);
+ return FALSE;
+ } else {
+ if (!status_only) {
+ int n_computed_checkums = (n_properly_formated_lines
+ - n_open_or_read_failures);
+
+ if (n_open_or_read_failures > 0) {
+ errorMsg("WARNING: %d of %d listed files could not be read\n",
+ n_open_or_read_failures, n_properly_formated_lines);
+ return FALSE;
+ }
+
+ if (n_mismatched_checksums > 0) {
+ errorMsg("WARNING: %d of %d computed checksums did NOT match\n",
+ n_mismatched_checksums, n_computed_checkums);
+ return FALSE;
+ }
+ }
+ }
+
+ return ((n_properly_formated_lines > 0 && n_mismatched_checksums == 0
+ && n_open_or_read_failures == 0) ? 0 : 1);
+}
+
+int md5sum_main(int argc,
+ char **argv)
+{
+ unsigned char md5buffer[16];
+ int do_check = 0;
+ int opt;
+ char **string = NULL;
+ size_t n_strings = 0;
+ size_t err = 0;
+ int file_type_specified = 0;
+ int binary = 0;
+
+ while ((opt = getopt(argc, argv, "g:bcstw")) != -1) {
+ switch (opt) {
+ case 'g': { /* read a string */
+ if (string == NULL)
+ string = (char **) xmalloc ((argc - 1) * sizeof (char *));
+
+ if (optarg == NULL)
+ optarg = "";
+ string[n_strings++] = optarg;
+ break;
+ }
+
+ case 'b': /* read files in binary mode */
+ file_type_specified = 1;
+ binary = 1;
+ break;
+
+ case 'c': /* check MD5 sums against given list */
+ do_check = 1;
+ break;
+
+ case 's': /* don't output anything, status code shows success */
+ status_only = 1;
+ warn = 0;
+ break;
+
+ case 't': /* read files in text mode (default) */
+ file_type_specified = 1;
+ binary = 0;
+ break;
+
+ case 'w': /* warn about improperly formated MD5 checksum lines */
+ status_only = 0;
+ warn = 1;
+ break;
+
+ default:
+ usage(md5sum_usage);
+ }
+ }
+
+ if (file_type_specified && do_check) {
+ errorMsg("the -b and -t options are meaningless when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (n_strings > 0 && do_check) {
+ errorMsg("the -g and -c options are mutually exclusive\n");
+ exit FALSE;
+ }
+
+ if (status_only && !do_check) {
+ errorMsg("the -s option is meaningful only when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (warn && !do_check) {
+ errorMsg("the -w option is meaningful only when verifying checksums\n");
+ exit FALSE;
+ }
+
+ if (n_strings > 0) {
+ size_t i;
+
+ if (optind < argc) {
+ errorMsg("no files may be specified when using -g\n");
+ exit FALSE;
+ }
+ for (i = 0; i < n_strings; ++i) {
+ size_t cnt;
+ md5_buffer (string[i], strlen (string[i]), md5buffer);
+
+ for (cnt = 0; cnt < 16; ++cnt)
+ printf ("%02x", md5buffer[cnt]);
+
+ printf (" \"%s\"\n", string[i]);
+ }
+ } else if (do_check) {
+ if (optind + 1 < argc) {
+ errorMsg("only one argument may be specified when using -c\n");
+ }
+
+ err = md5_check ((optind == argc) ? "-" : argv[optind]);
+ } else {
+ if (optind == argc)
+ argv[argc++] = "-";
+
+ for (; optind < argc; ++optind) {
+ int fail;
+ char *file = argv[optind];
+
+ fail = md5_file (file, binary, md5buffer);
+ err |= fail;
+ if (!fail) {
+ size_t i;
+ /* Output a leading backslash if the file name contains
+ a newline or backslash. */
+ if (strchr (file, '\n') || strchr (file, '\\'))
+ putchar ('\\');
+
+ for (i = 0; i < 16; ++i)
+ printf ("%02x", md5buffer[i]);
+
+ putchar (' ');
+ if (binary)
+ putchar ('*');
+ else
+ putchar (' ');
+
+ /* Translate each NEWLINE byte to the string, "\\n",
+ and each backslash to "\\\\". */
+ for (i = 0; i < strlen (file); ++i) {
+ switch (file[i]) {
+ case '\n':
+ fputs ("\\n", stdout);
+ break;
+
+ case '\\':
+ fputs ("\\\\", stdout);
+ break;
+
+ default:
+ putchar (file[i]);
+ break;
+ }
+ }
+ putchar ('\n');
+ }
+ }
+ }
+
+ if (fclose (stdout) == EOF) {
+ errorMsg("write error");
+ exit FALSE;
+ }
+
+ if (have_read_stdin && fclose (stdin) == EOF) {
+ errorMsg("standard input");
+ exit FALSE;
+ }
+
+ exit (err == 0 ? TRUE : FALSE);
+}
--- /dev/null
+/* uudecode.c -- uudecode utility.
+ * Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+ *
+ * This product is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This product is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this product; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* Reworked to GNU style by Ian Lance Taylor, ian@airs.com, August 93. */
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <pwd.h>
+
+/*struct passwd *getpwnam();*/
+
+/* Single character decode. */
+#define DEC(Char) (((Char) - ' ') & 077)
+
+static int read_stduu (const char *inname)
+{
+ char buf[2 * BUFSIZ];
+
+ while (1) {
+ int n;
+ char *p;
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL) {
+ errorMsg("%s: Short file\n", inname);
+ return FALSE;
+ }
+ p = buf;
+
+ /* N is used to avoid writing out all the characters at the end of
+ the file. */
+ n = DEC (*p);
+ if (n <= 0)
+ break;
+ for (++p; n > 0; p += 4, n -= 3) {
+ char ch;
+
+ if (n >= 3) {
+ ch = DEC (p[0]) << 2 | DEC (p[1]) >> 4;
+ putchar (ch);
+ ch = DEC (p[1]) << 4 | DEC (p[2]) >> 2;
+ putchar (ch);
+ ch = DEC (p[2]) << 6 | DEC (p[3]);
+ putchar (ch);
+ } else {
+ if (n >= 1) {
+ ch = DEC (p[0]) << 2 | DEC (p[1]) >> 4;
+ putchar (ch);
+ }
+ if (n >= 2) {
+ ch = DEC (p[1]) << 4 | DEC (p[2]) >> 2;
+ putchar (ch);
+ }
+ }
+ }
+ }
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL
+ || strcmp (buf, "end\n")) {
+ errorMsg("%s: No `end' line\n", inname);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static int read_base64 (const char *inname)
+{
+ static const char b64_tab[256] = {
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*000-007*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*010-017*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*020-027*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*030-037*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*040-047*/
+ '\177', '\177', '\177', '\76', '\177', '\177', '\177', '\77', /*050-057*/
+ '\64', '\65', '\66', '\67', '\70', '\71', '\72', '\73', /*060-067*/
+ '\74', '\75', '\177', '\177', '\177', '\100', '\177', '\177', /*070-077*/
+ '\177', '\0', '\1', '\2', '\3', '\4', '\5', '\6', /*100-107*/
+ '\7', '\10', '\11', '\12', '\13', '\14', '\15', '\16', /*110-117*/
+ '\17', '\20', '\21', '\22', '\23', '\24', '\25', '\26', /*120-127*/
+ '\27', '\30', '\31', '\177', '\177', '\177', '\177', '\177', /*130-137*/
+ '\177', '\32', '\33', '\34', '\35', '\36', '\37', '\40', /*140-147*/
+ '\41', '\42', '\43', '\44', '\45', '\46', '\47', '\50', /*150-157*/
+ '\51', '\52', '\53', '\54', '\55', '\56', '\57', '\60', /*160-167*/
+ '\61', '\62', '\63', '\177', '\177', '\177', '\177', '\177', /*170-177*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*200-207*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*210-217*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*220-227*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*230-237*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*240-247*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*250-257*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*260-267*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*270-277*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*300-307*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*310-317*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*320-327*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*330-337*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*340-347*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*350-357*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*360-367*/
+ '\177', '\177', '\177', '\177', '\177', '\177', '\177', '\177', /*370-377*/
+ };
+ unsigned char buf[2 * BUFSIZ];
+
+ while (1) {
+ int last_data = 0;
+ unsigned char *p;
+
+ if (fgets (buf, sizeof(buf), stdin) == NULL) {
+ errorMsg("%s: Short file\n", inname);
+ return FALSE;
+ }
+ p = buf;
+
+ if (memcmp (buf, "====", 4) == 0)
+ break;
+ if (last_data != 0) {
+ errorMsg("%s: data following `=' padding character\n", inname);
+ return FALSE;
+ }
+
+ /* The following implementation of the base64 decoding might look
+ a bit clumsy but I only try to follow the POSIX standard:
+ ``All line breaks or other characters not found in the table
+ [with base64 characters] shall be ignored by decoding
+ software.'' */
+ while (*p != '\n') {
+ char c1, c2, c3;
+
+ while ((b64_tab[*p] & '\100') != 0)
+ if (*p == '\n' || *p++ == '=')
+ break;
+ if (*p == '\n')
+ /* This leaves the loop. */
+ continue;
+ c1 = b64_tab[*p++];
+
+ while ((b64_tab[*p] & '\100') != 0)
+ if (*p == '\n' || *p++ == '=') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ c2 = b64_tab[*p++];
+
+ while (b64_tab[*p] == '\177')
+ if (*p++ == '\n') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ if (*p == '=') {
+ putchar (c1 << 2 | c2 >> 4);
+ last_data = 1;
+ break;
+ }
+ c3 = b64_tab[*p++];
+
+ while (b64_tab[*p] == '\177')
+ if (*p++ == '\n') {
+ errorMsg("%s: illegal line\n", inname);
+ return FALSE;
+ }
+ putchar (c1 << 2 | c2 >> 4);
+ putchar (c2 << 4 | c3 >> 2);
+ if (*p == '=') {
+ last_data = 1;
+ break;
+ }
+ else
+ putchar (c3 << 6 | b64_tab[*p++]);
+ }
+ }
+
+ return TRUE;
+}
+
+static int decode (const char *inname,
+ const char *forced_outname)
+{
+ struct passwd *pw;
+ register int n;
+ register char *p;
+ int mode, n1;
+ char buf[2 * BUFSIZ];
+ char *outname;
+ int do_base64 = 0;
+
+ /* Search for header line. */
+
+ while (1) {
+ if (fgets (buf, sizeof (buf), stdin) == NULL) {
+ errorMsg("%s: No `begin' line\n", inname);
+ return FALSE;
+ }
+
+ if (strncmp (buf, "begin", 5) == 0) {
+ if (sscanf (buf, "begin-base64 %o %s", &mode, buf) == 2) {
+ do_base64 = 1;
+ break;
+ } else if (sscanf (buf, "begin %o %s", &mode, buf) == 2)
+ break;
+ }
+ }
+
+ /* If the output file name is given on the command line this rules. */
+ if (forced_outname != NULL)
+ outname = (char *) forced_outname;
+ else {
+ /* Handle ~user/file format. */
+ if (buf[0] != '~')
+ outname = buf;
+ else {
+ p = buf + 1;
+ while (*p != '/')
+ ++p;
+ if (*p == '\0') {
+ errorMsg("%s: Illegal ~user\n", inname);
+ return FALSE;
+ }
+ *p++ = '\0';
+ pw = getpwnam (buf + 1);
+ if (pw == NULL) {
+ errorMsg("%s: No user `%s'\n", inname, buf + 1);
+ return FALSE;
+ }
+ n = strlen (pw->pw_dir);
+ n1 = strlen (p);
+ outname = (char *) alloca ((size_t) (n + n1 + 2));
+ memcpy (outname + n + 1, p, (size_t) (n1 + 1));
+ memcpy (outname, pw->pw_dir, (size_t) n);
+ outname[n] = '/';
+ }
+ }
+
+ /* Create output file and set mode. */
+ if (strcmp (outname, "/dev/stdout") != 0 && strcmp (outname, "-") != 0
+ && (freopen (outname, "w", stdout) == NULL
+ || chmod (outname, mode & (S_IRWXU | S_IRWXG | S_IRWXO))
+ )) {
+ errorMsg("uudeoce %s: %s %s\n", outname, inname, strerror(errno)); /* */
+ return FALSE;
+ }
+
+ /* We differenciate decoding standard UU encoding and base64. A
+ common function would only slow down the program. */
+
+ /* For each input line: */
+ if (do_base64)
+ return read_base64 (inname);
+ else
+ return read_stduu (inname);
+}
+
+static const char uudecode_usage[] =
+ "uudecode [FILE]...\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nUudecode a file that is uuencoded.\n\n"
+ "Options:\n"
+ "\t-o FILE\tdirect output to FILE\n"
+#endif
+;
+
+int uudecode_main (int argc,
+ char **argv)
+{
+ int opt;
+ int exit_status;
+ const char *outname;
+ outname = NULL;
+
+ while ((opt = getopt(argc, argv, "o:")) != EOF) {
+ switch (opt) {
+ case 0:
+ break;
+
+ case 'o':
+ outname = optarg;
+ break;
+
+ default:
+ usage(uudecode_usage);
+ }
+ }
+
+ if (optind == argc)
+ exit_status = decode ("stdin", outname) == 0 ? TRUE : FALSE;
+ else {
+ exit_status = TRUE;
+ do {
+ if (freopen (argv[optind], "r", stdin) != NULL) {
+ if (decode (argv[optind], outname) != 0)
+ exit_status = FALSE;
+ } else {
+ errorMsg("uudecode: %s: %s\n", argv[optind], strerror(errno));
+ exit_status = FALSE;
+ }
+ optind++;
+ }
+ while (optind < argc);
+ }
+ exit(exit_status);
+}
--- /dev/null
+/* uuencode.c -- uuencode utility.
+ * Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+ *
+ * This product is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This product is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this product; see the file COPYING. If not, write to
+ * the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* Reworked to GNU style by Ian Lance Taylor, ian@airs.com, August 93. */
+/* Hacked to work with BusyBox by Alfred M. Szmidt */
+
+#include "internal.h"
+
+#include <stdio.h>
+#include <errno.h>
+#include <pwd.h>
+
+#define RW (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
+
+static void encode __P ((void));
+
+/* Pointer to the translation table we currently use. */
+const char *trans_ptr;
+
+/* The two currently defined translation tables. The first is the
+ standard uuencoding, the second is base64 encoding. */
+const char uu_std[64] = {
+ '`', '!', '"', '#', '$', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', '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', '[', '\\', ']', '^', '_'
+};
+
+const char uu_base64[64] = {
+ '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', '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', '0', '1', '2', '3',
+ '4', '5', '6', '7', '8', '9', '+', '/'
+};
+
+/* ENC is the basic 1 character encoding function to make a char printing. */
+#define ENC(Char) (trans_ptr[(Char) & 077])
+
+/* Copy from IN to OUT, encoding as you go along. */
+static void encode()
+{
+ register int ch, n;
+ char *p = NULL;
+ char buf[80];
+
+ while (1) {
+ n = 0;
+ do {
+ register int m = fread (buf, 1, 45 - n, stdin);
+ if (m == 0)
+ break;
+ n += m;
+ }
+ while (n < 45);
+
+ if (n == 0)
+ break;
+
+ if (trans_ptr == uu_std)
+ if (putchar (ENC (n)) == EOF)
+ break;
+ for (p = buf; n > 2; n -= 3, p += 3) {
+ ch = *p >> 2;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = ((*p << 4) & 060) | ((p[1] >> 4) & 017);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = ((p[1] << 2) & 074) | ((p[2] >> 6) & 03);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ ch = p[2] & 077;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+ }
+
+ if (n != 0)
+ break;
+
+ if (putchar ('\n') == EOF)
+ break;
+ }
+
+ while (n != 0) {
+ char c1 = *p;
+ char c2 = n == 1 ? 0 : p[1];
+
+ ch = c1 >> 2;
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+
+ ch = ((c1 << 4) & 060) | ((c2 >> 4) & 017);
+ ch = ENC (ch);
+ if (putchar (ch) == EOF)
+ break;
+
+ if (n == 1)
+ ch = trans_ptr == uu_std ? ENC ('\0') : '=';
+ else {
+ ch = (c2 << 2) & 074;
+ ch = ENC (ch);
+ }
+ if (putchar (ch) == EOF)
+ break;
+ ch = trans_ptr == uu_std ? ENC ('\0') : '=';
+ if (putchar (ch) == EOF)
+ break;
+ putchar ('\n');
+ break;
+ }
+
+ if (ferror (stdin))
+ errorMsg("Read error\n");
+
+ if (trans_ptr == uu_std) {
+ putchar (ENC ('\0'));
+ putchar ('\n');
+ }
+}
+
+static const char uuencode_usage[] =
+ "uuencode [OPTION] [INFILE] REMOTEFILE\n"
+#ifndef BB_FEATURE_TRIVIAL_HELP
+ "\nUuencode a file.\n\n"
+ "Options:\n"
+ "\t-m\tuse base64 encoding as of RFC1521\n"
+#endif
+;
+
+int uuencode_main (int argc,
+ char **argv)
+{
+ int opt;
+ struct stat sb;
+ int mode;
+
+ trans_ptr = uu_std; /* Standard encoding is old uu format */
+
+ /* Parse any options */
+ while ((opt = getopt (argc, argv, "m")) != EOF) {
+ switch (opt) {
+ case 'm':
+ trans_ptr = uu_base64;
+ break;
+
+ case 0:
+ break;
+
+ default:
+ usage(uuencode_usage);
+ }
+ }
+
+ switch (argc - optind) {
+ case 2:
+ /* Optional first argument is input file. */
+ if (!freopen (argv[optind], "r", stdin) || fstat (fileno (stdin), &sb)) {
+ errorMsg("uuencode: %s: %s\n", argv[optind], strerror(errno));
+ exit FALSE;
+ }
+ mode = sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
+ optind++;
+ break;
+
+ case 1:
+ mode = RW & ~umask (RW);
+ break;
+
+ case 0:
+ default:
+ usage(uuencode_usage);
+ }
+
+ printf("begin%s %o %s\n", trans_ptr == uu_std ? "" : "-base64",
+ mode, argv[optind]);
+ encode();
+ printf(trans_ptr == uu_std ? "end\n" : "====\n");
+ if (ferror (stdout)) {
+ errorMsg("Write error\n");
+ exit FALSE;
+ }
+ exit TRUE;
+}
OSDN Git Service
