emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Run through indent

Browse Source
This commit is contained in:
Glenn L McGrath 2003-06-07 14:54:24 +00:00
parent 233b170a85
commit 7aa62cf173
1 changed files with 721 additions and 693 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

230
coreutils/md5sum.c
View File

@ -77,8 +77,7 @@
typedef u_int32_t md5_uint32; typedef u_int32_t md5_uint32;
/* Structure to save state of computation between the single steps. */ /* Structure to save state of computation between the single steps. */
struct md5_ctx struct md5_ctx {
{
md5_uint32 A; md5_uint32 A;
md5_uint32 B; md5_uint32 B;
md5_uint32 C; md5_uint32 C;
@ -96,21 +95,21 @@ struct md5_ctx
/* Initialize structure containing state of computation. /* Initialize structure containing state of computation.
(RFC 1321, 3.3: Step 3) */ (RFC 1321, 3.3: Step 3) */
static void md5_init_ctx __P ((struct md5_ctx *ctx)); static void md5_init_ctx __P((struct md5_ctx * ctx));
/* Starting with the result of former calls of this function (or the /* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes initialization function update the context for the next LEN bytes
starting at BUFFER. starting at BUFFER.
It is necessary that LEN is a multiple of 64!!! */ It is necessary that LEN is a multiple of 64!!! */
static void md5_process_block __P ((const void *buffer, size_t len, static void md5_process_block __P((const void *buffer, size_t len,
struct md5_ctx *ctx)); struct md5_ctx * ctx));
/* Starting with the result of former calls of this function (or the /* Starting with the result of former calls of this function (or the
initialization function update the context for the next LEN bytes initialization function update the context for the next LEN bytes
starting at BUFFER. starting at BUFFER.
It is NOT required that LEN is a multiple of 64. */ It is NOT required that LEN is a multiple of 64. */
static void md5_process_bytes __P ((const void *buffer, size_t len, static void md5_process_bytes __P((const void *buffer, size_t len,
struct md5_ctx *ctx)); struct md5_ctx * ctx));
/* Process the remaining bytes in the buffer and put result from 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 in first 16 bytes following RESBUF. The result is always in little
@ -119,7 +118,7 @@ static void md5_process_bytes __P ((const void *buffer, size_t len,
IMPORTANT: On some systems it is required that RESBUF is correctly IMPORTANT: On some systems it is required that RESBUF is correctly
aligned for a 32 bits value. */ aligned for a 32 bits value. */
static void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf)); static void *md5_finish_ctx __P((struct md5_ctx * ctx, void *resbuf));
@ -127,13 +126,13 @@ static void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
/* Compute MD5 message digest for bytes read from STREAM. The /* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */ beginning at RESBLOCK. */
static int md5_stream __P ((FILE *stream, void *resblock)); static int md5_stream __P((FILE * stream, void *resblock));
/* Compute MD5 message digest for LEN bytes beginning at BUFFER. The /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
result is always in little endian byte order, so that a byte-wise result is always in little endian byte order, so that a byte-wise
output yields to the wanted ASCII representation of the message output yields to the wanted ASCII representation of the message
digest. */ digest. */
static void *md5_buffer __P ((const char *buffer, size_t len, void *resblock)); static void *md5_buffer __P((const char *buffer, size_t len, void *resblock));
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
//--------end of md5.h //--------end of md5.h
@ -141,9 +140,9 @@ static void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
/* Handle endian-ness */ /* Handle endian-ness */
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
#define SWAP(n) (n) #define SWAP(n) (n)
#else #else
#define SWAP(n) ((n << 24) | ((n&65280)<<8) | ((n&16711680)>>8) | (n>>24)) #define SWAP(n) ((n << 24) | ((n&65280)<<8) | ((n&16711680)>>8) | (n>>24))
#endif #endif
@ -194,7 +193,7 @@ static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
/* Put the 64-bit file length in *bits* at the end of the buffer. */ /* 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] = SWAP(ctx->total[0] << 3);
*(md5_uint32 *) & ctx->buffer[bytes + pad + 4] = *(md5_uint32 *) & ctx->buffer[bytes + pad + 4] =
SWAP( ((ctx->total[1] << 3) | (ctx->total[0] >> 29)) ); SWAP(((ctx->total[1] << 3) | (ctx->total[0] >> 29)));
/* Process last bytes. */ /* Process last bytes. */
md5_process_block(ctx->buffer, bytes + pad + 8, ctx); md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
@ -216,10 +215,10 @@ static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
/* Compute MD5 message digest for bytes read from STREAM. The /* Compute MD5 message digest for bytes read from STREAM. The
resulting message digest number will be written into the 16 bytes resulting message digest number will be written into the 16 bytes
beginning at RESBLOCK. */ beginning at RESBLOCK. */
static int md5_stream(FILE *stream, void *resblock) static int md5_stream(FILE * stream, void *resblock)
{ {
/* Important: BLOCKSIZE must be a multiple of 64. */ /* Important: BLOCKSIZE must be a multiple of 64. */
static const int BLOCKSIZE = 4096; static const int BLOCKSIZE = 4096;
struct md5_ctx ctx; struct md5_ctx ctx;
char buffer[BLOCKSIZE + 72]; char buffer[BLOCKSIZE + 72];
size_t sum; size_t sum;
@ -233,6 +232,7 @@ static const int BLOCKSIZE = 4096;
computation function processes the whole buffer so that with the computation function processes the whole buffer so that with the
next round of the loop another block can be read. */ next round of the loop another block can be read. */
size_t n; size_t n;
sum = 0; sum = 0;
/* Read block. Take care for partial reads. */ /* Read block. Take care for partial reads. */
@ -282,7 +282,8 @@ static void *md5_buffer(const char *buffer, size_t len, void *resblock)
return md5_finish_ctx(&ctx, resblock); return md5_finish_ctx(&ctx, resblock);
} }
static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx) static 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 /* When we already have some bits in our internal buffer concatenate
both inputs first. */ both inputs first. */
@ -330,12 +331,14 @@ static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ct
/* Process LEN bytes of BUFFER, accumulating context into CTX. /* Process LEN bytes of BUFFER, accumulating context into CTX.
It is assumed that LEN % 64 == 0. */ It is assumed that LEN % 64 == 0. */
static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx) static void md5_process_block(const void *buffer, size_t len,
struct md5_ctx *ctx)
{ {
md5_uint32 correct_words[16]; md5_uint32 correct_words[16];
const md5_uint32 *words = buffer; const md5_uint32 *words = buffer;
size_t nwords = len / sizeof(md5_uint32); size_t nwords = len / sizeof(md5_uint32);
const md5_uint32 *endp = words + nwords; const md5_uint32 *endp = words + nwords;
#if MD5SUM_SIZE_VS_SPEED > 0 #if MD5SUM_SIZE_VS_SPEED > 0
static const md5_uint32 C_array[] = { static const md5_uint32 C_array[] = {
/* round 1 */ /* round 1 */
@ -409,65 +412,85 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
int i; int i;
md5_uint32 temp; md5_uint32 temp;
for ( i=0 ; i < 16 ; i++ ) { for (i = 0; i < 16; i++) {
cwp[i] = SWAP(words[i]); cwp[i] = SWAP(words[i]);
} }
words += 16; words += 16;
#if MD5SUM_SIZE_VS_SPEED > 2 #if MD5SUM_SIZE_VS_SPEED > 2
pc = C_array; pp = P_array; ps = S_array - 4; pc = C_array;
pp = P_array;
ps = S_array - 4;
for ( i = 0 ; i < 64 ; i++ ) { for (i = 0; i < 64; i++) {
if ((i&0x0f) == 0) ps += 4; if ((i & 0x0f) == 0)
ps += 4;
temp = A; temp = A;
switch (i>>4) { switch (i >> 4) {
case 0: case 0:
temp += FF(B,C,D); temp += FF(B, C, D);
break; break;
case 1: case 1:
temp += FG(B,C,D); temp += FG(B, C, D);
break; break;
case 2: case 2:
temp += FH(B,C,D); temp += FH(B, C, D);
break; break;
case 3: case 3:
temp += FI(B,C,D); temp += FI(B, C, D);
} }
temp += cwp[(int)(*pp++)] + *pc++; temp += cwp[(int) (*pp++)] + *pc++;
CYCLIC (temp, ps[i&3]); CYCLIC(temp, ps[i & 3]);
temp += B; temp += B;
A = D; D = C; C = B; B = temp; A = D;
D = C;
C = B;
B = temp;
} }
#else #else
pc = C_array; pp = P_array; ps = S_array; pc = C_array;
pp = P_array;
ps = S_array;
for ( i = 0 ; i < 16 ; i++ ) { for (i = 0; i < 16; i++) {
temp = A + FF(B,C,D) + cwp[(int)(*pp++)] + *pc++; temp = A + FF(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC (temp, ps[i&3]); CYCLIC(temp, ps[i & 3]);
temp += B; temp += B;
A = D; D = C; C = B; B = temp; A = D;
D = C;
C = B;
B = temp;
} }
ps += 4; ps += 4;
for ( i = 0 ; i < 16 ; i++ ) { for (i = 0; i < 16; i++) {
temp = A + FG(B,C,D) + cwp[(int)(*pp++)] + *pc++; temp = A + FG(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC (temp, ps[i&3]); CYCLIC(temp, ps[i & 3]);
temp += B; temp += B;
A = D; D = C; C = B; B = temp; A = D;
D = C;
C = B;
B = temp;
} }
ps += 4; ps += 4;
for ( i = 0 ; i < 16 ; i++ ) { for (i = 0; i < 16; i++) {
temp = A + FH(B,C,D) + cwp[(int)(*pp++)] + *pc++; temp = A + FH(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC (temp, ps[i&3]); CYCLIC(temp, ps[i & 3]);
temp += B; temp += B;
A = D; D = C; C = B; B = temp; A = D;
D = C;
C = B;
B = temp;
} }
ps += 4; ps += 4;
for ( i = 0 ; i < 16 ; i++ ) { for (i = 0; i < 16; i++) {
temp = A + FI(B,C,D) + cwp[(int)(*pp++)] + *pc++; temp = A + FI(B, C, D) + cwp[(int) (*pp++)] + *pc++;
CYCLIC (temp, ps[i&3]); CYCLIC(temp, ps[i & 3]);
temp += B; temp += B;
A = D; D = C; C = B; B = temp; A = D;
D = C;
C = B;
B = temp;
} }
#endif #endif
@ -509,7 +532,7 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
/* Round 1. */ /* Round 1. */
#if MD5SUM_SIZE_VS_SPEED == 1 #if MD5SUM_SIZE_VS_SPEED == 1
pc = C_array; pc = C_array;
for ( i=0 ; i < 4 ; i++ ) { for (i = 0; i < 4; i++) {
OP(A, B, C, D, 7, *pc++); OP(A, B, C, D, 7, *pc++);
OP(D, A, B, C, 12, *pc++); OP(D, A, B, C, 12, *pc++);
OP(C, D, A, B, 17, *pc++); OP(C, D, A, B, 17, *pc++);
@ -550,11 +573,11 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
/* Round 2. */ /* Round 2. */
#if MD5SUM_SIZE_VS_SPEED == 1 #if MD5SUM_SIZE_VS_SPEED == 1
pp = P_array; pp = P_array;
for ( i=0 ; i < 4 ; i++ ) { for (i = 0; i < 4; i++) {
OP(FG, A, B, C, D, (int)(*pp++), 5, *pc++); OP(FG, A, B, C, D, (int) (*pp++), 5, *pc++);
OP(FG, D, A, B, C, (int)(*pp++), 9, *pc++); OP(FG, D, A, B, C, (int) (*pp++), 9, *pc++);
OP(FG, C, D, A, B, (int)(*pp++), 14, *pc++); OP(FG, C, D, A, B, (int) (*pp++), 14, *pc++);
OP(FG, B, C, D, A, (int)(*pp++), 20, *pc++); OP(FG, B, C, D, A, (int) (*pp++), 20, *pc++);
} }
#else #else
OP(FG, A, B, C, D, 1, 5, 0xf61e2562); OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
@ -577,11 +600,11 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
/* Round 3. */ /* Round 3. */
#if MD5SUM_SIZE_VS_SPEED == 1 #if MD5SUM_SIZE_VS_SPEED == 1
for ( i=0 ; i < 4 ; i++ ) { for (i = 0; i < 4; i++) {
OP(FH, A, B, C, D, (int)(*pp++), 4, *pc++); OP(FH, A, B, C, D, (int) (*pp++), 4, *pc++);
OP(FH, D, A, B, C, (int)(*pp++), 11, *pc++); OP(FH, D, A, B, C, (int) (*pp++), 11, *pc++);
OP(FH, C, D, A, B, (int)(*pp++), 16, *pc++); OP(FH, C, D, A, B, (int) (*pp++), 16, *pc++);
OP(FH, B, C, D, A, (int)(*pp++), 23, *pc++); OP(FH, B, C, D, A, (int) (*pp++), 23, *pc++);
} }
#else #else
OP(FH, A, B, C, D, 5, 4, 0xfffa3942); OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
@ -604,11 +627,11 @@ static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ct
/* Round 4. */ /* Round 4. */
#if MD5SUM_SIZE_VS_SPEED == 1 #if MD5SUM_SIZE_VS_SPEED == 1
for ( i=0 ; i < 4 ; i++ ) { for (i = 0; i < 4; i++) {
OP(FI, A, B, C, D, (int)(*pp++), 6, *pc++); OP(FI, A, B, C, D, (int) (*pp++), 6, *pc++);
OP(FI, D, A, B, C, (int)(*pp++), 10, *pc++); OP(FI, D, A, B, C, (int) (*pp++), 10, *pc++);
OP(FI, C, D, A, B, (int)(*pp++), 15, *pc++); OP(FI, C, D, A, B, (int) (*pp++), 15, *pc++);
OP(FI, B, C, D, A, (int)(*pp++), 21, *pc++); OP(FI, B, C, D, A, (int) (*pp++), 21, *pc++);
} }
#else #else
OP(FI, A, B, C, D, 0, 6, 0xf4292244); OP(FI, A, B, C, D, 0, 6, 0xf4292244);
@ -666,10 +689,7 @@ static int status_only = 0; /* With -c, don't generate any output.
static int warn = 0; /* With -w, print a message to standard error warning static int warn = 0; /* With -w, print a message to standard error warning
about each improperly formatted MD5 checksum line */ about each improperly formatted MD5 checksum line */
static int split_3(char *s, static int split_3(char *s, size_t s_len, unsigned char **u, char **w)
size_t s_len,
unsigned char **u,
char **w)
{ {
size_t i = 0; size_t i = 0;
int escaped_filename = 0; int escaped_filename = 0;
@ -761,8 +781,7 @@ static inline int hex_digits(unsigned char const *s)
/* An interface to md5_stream. Operate on FILENAME (it may be "-") and /* An interface to md5_stream. Operate on FILENAME (it may be "-") and
put the result in *MD5_RESULT. Return non-zero upon failure, zero put the result in *MD5_RESULT. Return non-zero upon failure, zero
to indicate success. */ to indicate success. */
static int md5_file(const char *filename, static int md5_file(const char *filename, unsigned char *md5_result)
unsigned char *md5_result)
{ {
FILE *fp; FILE *fp;
@ -819,10 +838,10 @@ static int md5_check(const char *checkfile_name)
++line_number; ++line_number;
fgets(line, BUFSIZ-1, checkfile_stream); fgets(line, BUFSIZ - 1, checkfile_stream);
line_length = strlen(line); line_length = strlen(line);
if (line_length <= 0 || line==NULL) if (line_length <= 0 || line == NULL)
break; break;
/* Ignore comment lines, which begin with a '#' character. */ /* Ignore comment lines, which begin with a '#' character. */
@ -836,7 +855,8 @@ static int md5_check(const char *checkfile_name)
if (split_3(line, line_length, &md5num, &filename) if (split_3(line, line_length, &md5num, &filename)
|| !hex_digits(md5num)) { || !hex_digits(md5num)) {
if (warn) { if (warn) {
bb_error_msg("%s: %lu: improperly formatted MD5 checksum line", bb_error_msg
("%s: %lu: improperly formatted MD5 checksum line",
checkfile_name, (unsigned long) line_number); checkfile_name, (unsigned long) line_number);
} }
} else { } else {
@ -857,6 +877,7 @@ static int md5_check(const char *checkfile_name)
} }
} else { } else {
size_t cnt; size_t cnt;
/* Compare generated binary number with text representation /* Compare generated binary number with text representation
in check file. Ignore case of hex digits. */ in check file. Ignore case of hex digits. */
for (cnt = 0; cnt < 16; ++cnt) { for (cnt = 0; cnt < 16; ++cnt) {
@ -901,13 +922,15 @@ static int md5_check(const char *checkfile_name)
- n_open_or_read_failures); - n_open_or_read_failures);
if (n_open_or_read_failures > 0) { if (n_open_or_read_failures > 0) {
bb_error_msg("WARNING: %d of %d listed files could not be read", bb_error_msg
("WARNING: %d of %d listed files could not be read",
n_open_or_read_failures, n_properly_formated_lines); n_open_or_read_failures, n_properly_formated_lines);
return FALSE; return FALSE;
} }
if (n_mismatched_checksums > 0) { if (n_mismatched_checksums > 0) {
bb_error_msg("WARNING: %d of %d computed checksums did NOT match", bb_error_msg
("WARNING: %d of %d computed checksums did NOT match",
n_mismatched_checksums, n_computed_checkums); n_mismatched_checksums, n_computed_checkums);
return FALSE; return FALSE;
} }
@ -918,8 +941,7 @@ static int md5_check(const char *checkfile_name)
&& n_open_or_read_failures == 0) ? 0 : 1); && n_open_or_read_failures == 0) ? 0 : 1);
} }
int md5sum_main(int argc, int md5sum_main(int argc, char **argv)
char **argv)
{ {
unsigned char md5buffer[16]; unsigned char md5buffer[16];
int do_check = 0; int do_check = 0;
@ -932,9 +954,9 @@ int md5sum_main(int argc,
while ((opt = getopt(argc, argv, "g:bcstw")) != -1) { while ((opt = getopt(argc, argv, "g:bcstw")) != -1) {
switch (opt) { switch (opt) {
case 'g': { /* read a string */ case 'g':{ /* read a string */
if (string == NULL) if (string == NULL)
string = (char **) xmalloc ((argc - 1) * sizeof (char *)); string = (char **) xmalloc((argc - 1) * sizeof(char *));
string[n_strings++] = optarg; string[n_strings++] = optarg;
break; break;
@ -970,7 +992,8 @@ int md5sum_main(int argc,
} }
if (file_type_specified && do_check) { if (file_type_specified && do_check) {
bb_error_msg_and_die("the -b and -t options are meaningless when verifying checksums"); bb_error_msg_and_die
("the -b and -t options are meaningless when verifying checksums");
} }
if (n_strings > 0 && do_check) { if (n_strings > 0 && do_check) {
@ -978,11 +1001,13 @@ int md5sum_main(int argc,
} }
if (status_only && !do_check) { if (status_only && !do_check) {
bb_error_msg_and_die("the -s option is meaningful only when verifying checksums"); bb_error_msg_and_die
("the -s option is meaningful only when verifying checksums");
} }
if (warn && !do_check) { if (warn && !do_check) {
bb_error_msg_and_die("the -w option is meaningful only when verifying checksums"); bb_error_msg_and_die
("the -w option is meaningful only when verifying checksums");
} }
if (n_strings > 0) { if (n_strings > 0) {
@ -993,19 +1018,20 @@ int md5sum_main(int argc,
} }
for (i = 0; i < n_strings; ++i) { for (i = 0; i < n_strings; ++i) {
size_t cnt; size_t cnt;
md5_buffer (string[i], strlen (string[i]), md5buffer);
md5_buffer(string[i], strlen(string[i]), md5buffer);
for (cnt = 0; cnt < 16; ++cnt) for (cnt = 0; cnt < 16; ++cnt)
printf ("%02x", md5buffer[cnt]); printf("%02x", md5buffer[cnt]);
printf (" \"%s\"\n", string[i]); printf(" \"%s\"\n", string[i]);
} }
} else if (do_check) { } else if (do_check) {
if (optind + 1 < argc) { if (optind + 1 < argc) {
bb_error_msg("only one argument may be specified when using -c"); bb_error_msg("only one argument may be specified when using -c");
} }
err = md5_check ((optind == argc) ? "-" : argv[optind]); err = md5_check((optind == argc) ? "-" : argv[optind]);
} else { } else {
if (optind == argc) if (optind == argc)
argv[argc++] = "-"; argv[argc++] = "-";
@ -1014,56 +1040,58 @@ int md5sum_main(int argc,
int fail; int fail;
char *file = argv[optind]; char *file = argv[optind];
fail = md5_file (file, md5buffer); fail = md5_file(file, md5buffer);
err |= fail; err |= fail;
if (!fail && file[0]=='-' && file[1] == '\0') { if (!fail && file[0] == '-' && file[1] == '\0') {
size_t i; size_t i;
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)
printf ("%02x", md5buffer[i]); printf("%02x", md5buffer[i]);
putchar ('\n'); putchar('\n');
} else if (!fail) { } else if (!fail) {
size_t i; size_t i;
/* Output a leading backslash if the file name contains /* Output a leading backslash if the file name contains
a newline or backslash. */ a newline or backslash. */
if (strchr (file, '\n') || strchr (file, '\\')) if (strchr(file, '\n') || strchr(file, '\\'))
putchar ('\\'); putchar('\\');
for (i = 0; i < 16; ++i) for (i = 0; i < 16; ++i)
printf ("%02x", md5buffer[i]); printf("%02x", md5buffer[i]);
putchar (' '); putchar(' ');
if (binary) if (binary)
putchar ('*'); putchar('*');
else else
putchar (' '); putchar(' ');
/* Translate each NEWLINE byte to the string, "\\n", /* Translate each NEWLINE byte to the string, "\\n",
and each backslash to "\\\\". */ and each backslash to "\\\\". */
for (i = 0; i < strlen (file); ++i) { for (i = 0; i < strlen(file); ++i) {
switch (file[i]) { switch (file[i]) {
case '\n': case '\n':
fputs ("\\n", stdout); fputs("\\n", stdout);
break; break;
case '\\': case '\\':
fputs ("\\\\", stdout); fputs("\\\\", stdout);
break; break;
default: default:
putchar (file[i]); putchar(file[i]);
break; break;
} }
} }
putchar ('\n'); putchar('\n');
} }
} }
} }
if (fclose (stdout) == EOF) { if (fclose(stdout) == EOF) {
bb_error_msg_and_die("write error"); bb_error_msg_and_die("write error");
} }
if (have_read_stdin && fclose (stdin) == EOF) { if (have_read_stdin && fclose(stdin) == EOF) {
bb_error_msg_and_die(bb_msg_standard_input); bb_error_msg_and_die(bb_msg_standard_input);
} }