1 files changed, 115 insertions, 41 deletions
diff --git a/coreutils/cmp.c b/coreutils/cmp.c
index 07bf3be92..43dbc842f 100644
--- a/coreutils/cmp.c
+++ b/coreutils/cmp.c
@@ -20,59 +20,133 @@
 *
 */
+/* BB_AUDIT SUSv3 (virtually) compliant -- uses nicer GNU format for -l. */
+/* http://www.opengroup.org/onlinepubs/007904975/utilities/cmp.html */
+/* Mar 16, 2003      Manuel Novoa III   (mjn3@codepoet.org)
+ *
+ * Original version majorly reworked for SUSv3 compliance, bug fixes, and
+ * size optimizations.  Changes include:
+ * 1) Now correctly distingusishes between errors and actual file differences.
+ * 2) Proper handling of '-' args.
+ * 3) Actual error checking of i/o.
+ * 4) Accept SUSv3 -l option.  Note that we use the slightly nicer gnu format
+ *    in the '-l' case.
+ */
 #include <stdio.h>
-#include <string.h>
-#include <errno.h>
 #include <stdlib.h>
-#include <getopt.h>
+#include <unistd.h>
 #include "busybox.h"
+static FILE *cmp_xfopen_input(const char *filename)
+{
+        FILE *fp;
+        if ((fp = bb_wfopen_input(filename)) != NULL) {
+                return fp;
+        }
+        exit(bb_default_error_retval);  /* We already output an error message. */
+}
+static const char fmt_eof[] = "cmp: EOF on %s\n";
+static const char fmt_differ[] = "%s %s differ: char %d, line %d\n";
+#if 0
+static const char fmt_l_opt[] = "%.0s%.0s%d %o %o\n";   /* SUSv3 format */
+#else
+static const char fmt_l_opt[] = "%.0s%.0s%d %3o %3o\n"; /* nicer gnu format */
+#endif
+static const char opt_chars[] = "sl";
+enum {
+        OPT_s = 1,
+        OPT_l = 2
+};
 int cmp_main(int argc, char **argv)
 {
-        FILE *fp1 = NULL, *fp2 = stdin;
+        FILE *fp1, *fp2, *outfile = stdout;
-        char *filename1, *filename2 = "-";
+        const char *filename1, *filename2;
-        int c, c1, c2, char_pos = 1, line_pos = 1, silent = FALSE;
+        const char *fmt;
+        int c1, c2, char_pos, line_pos;
-        while ((c = getopt(argc, argv, "s")) != EOF) {
+        int opt_flags;
-                switch (c) {
+        int exit_val = 0;
-                        case 's':
-                                silent = TRUE;
+        bb_default_error_retval = 2;    /* 1 is returned if files are different. */
-                                break;
-                        default:
+        opt_flags = bb_getopt_ulflags(argc, argv, opt_chars);
-                                show_usage();
-                }
+        if ((opt_flags == 3) || (((unsigned int)(--argc - optind)) > 1)) {
+                bb_show_usage();
        }
-        filename1 = argv[optind];
+        fp1 = cmp_xfopen_input(filename1 = *(argv += optind));
-        switch (argc - optind) {
-                case 2:
+        filename2 = "-";
-                        fp2 = xfopen(filename2 = argv[optind + 1], "r");
+        if (*++argv) {
-                case 1:
+                filename2 = *argv;
-                        fp1 = xfopen(filename1, "r");
-                        break;
-                default:
-                        show_usage();
        }
+        fp2 = cmp_xfopen_input(filename2);
+        if (fp1 == fp2) {                       /* Paranioa check... stdin == stdin? */
+                /* Note that we don't bother reading stdin.  Neither does gnu wc.
+                 * But perhaps we should, so that other apps down the chain don't
+                 * get the input.  Consider 'echo hello | (cmp - - && cat -)'.
+                 */
+                return 0;
+        }
+        fmt = fmt_differ;
+        if (opt_flags == OPT_l) {
+                fmt = fmt_l_opt;
+        }
+        char_pos = 0;
+        line_pos = 1;
        do {
-                c1 = fgetc(fp1);
+                c1 = getc(fp1);
-                c2 = fgetc(fp2);
+                c2 = getc(fp2);
-                if (c1 != c2) {
+                ++char_pos;
-                        if (silent)
+                if (c1 != c2) {                 /* Remember -- a read error may have occurred. */
-                                return EXIT_FAILURE;
+                        exit_val = 1;           /* But assume the files are different for now. */
-                        if (c1 == EOF)
+                        if (c2 == EOF) {
-                                printf("EOF on %s\n", filename1);
+                                /* We know that fp1 isn't at EOF or in an error state.  But to
-                        else if (c2 == EOF)
+                                 * save space below, things are setup to expect an EOF in fp1
-                                printf("EOF on %s\n", filename2);
+                                 * if an EOF occurred.  So, swap things around.
-                        else
+                                 */
-                                printf("%s %s differ: char %d, line %d\n", filename1, filename2,
+                                fp1 = fp2;
-                                                char_pos, line_pos);
+                                filename1 = filename2;
-                        return EXIT_FAILURE;
+                                c1 = c2;
+                        }
+                        if (c1 == EOF) {
+                                bb_xferror(fp1, filename1);
+                                fmt = fmt_eof;  /* Well, no error, so it must really be EOF. */
+                                outfile = stderr;
+                                /* There may have been output to stdout (option -l), so
+                                 * make sure we fflush before writing to stderr. */
+                                bb_xfflush_stdout();
+                        }
+                        if (opt_flags != OPT_s) {
+                                if (opt_flags == OPT_l) {
+                                        line_pos = c1;  /* line_pos is unused in the -l case. */
+                                }
+                                bb_fprintf(outfile, fmt, filename1, filename2, char_pos, line_pos, c2);
+                                if (opt_flags) {        /* This must be -l since not -s. */
+                                        /* If we encountered and EOF, the while check will catch it. */
+                                        continue;
+                                }
+                        }
+                        break;
+                }
+                if (c1 == '\n') {
+                        ++line_pos;
                }
-                char_pos++;
-                if (c1 == '\n')
-                        line_pos++;
        } while (c1 != EOF);
-        return EXIT_SUCCESS;
+        bb_xferror(fp1, filename1);
+        bb_xferror(fp2, filename2);
+        bb_fflush_stdout_and_exit(exit_val);
 }

diff --git a/coreutils/cmp.c b/coreutils/cmp.c index 07bf3be92..43dbc842f 100644 --- a/coreutils/cmp.c +++ b/coreutils/cmp.c
@@ -20,59 +20,133 @@
20	*	20	*
21	*/	21	*/
22		22
		23	/* BB_AUDIT SUSv3 (virtually) compliant -- uses nicer GNU format for -l. */
		24	/* http://www.opengroup.org/onlinepubs/007904975/utilities/cmp.html */
		25
		26	/* Mar 16, 2003 Manuel Novoa III (mjn3@codepoet.org)
		27	*
		28	* Original version majorly reworked for SUSv3 compliance, bug fixes, and
		29	* size optimizations. Changes include:
		30	* 1) Now correctly distingusishes between errors and actual file differences.
		31	* 2) Proper handling of '-' args.
		32	* 3) Actual error checking of i/o.
		33	* 4) Accept SUSv3 -l option. Note that we use the slightly nicer gnu format
		34	* in the '-l' case.
		35	*/
		36
23	#include <stdio.h>	37	#include <stdio.h>
24	#include <string.h>
25	#include <errno.h>
26	#include <stdlib.h>	38	#include <stdlib.h>
27	#include <getopt.h>	39	#include <unistd.h>
28	#include "busybox.h"	40	#include "busybox.h"
29		41
		42	static FILE cmp_xfopen_input(const char filename)
		43	{
		44	FILE *fp;
		45
		46	if ((fp = bb_wfopen_input(filename)) != NULL) {
		47	return fp;
		48	}
		49
		50	exit(bb_default_error_retval); /* We already output an error message. */
		51	}
		52
		53	static const char fmt_eof[] = "cmp: EOF on %s\n";
		54	static const char fmt_differ[] = "%s %s differ: char %d, line %d\n";
		55	#if 0
		56	static const char fmt_l_opt[] = "%.0s%.0s%d %o %o\n"; /* SUSv3 format */
		57	#else
		58	static const char fmt_l_opt[] = "%.0s%.0s%d %3o %3o\n"; /* nicer gnu format */
		59	#endif
		60
		61	static const char opt_chars[] = "sl";
		62
		63	enum {
		64	OPT_s = 1,
		65	OPT_l = 2
		66	};
		67
30	int cmp_main(int argc, char **argv)	68	int cmp_main(int argc, char **argv)
31	{	69	{
32	FILE fp1 = NULL, fp2 = stdin;	70	FILE fp1, fp2, *outfile = stdout;
33	char filename1, filename2 = "-";	71	const char filename1, filename2;
34	int c, c1, c2, char_pos = 1, line_pos = 1, silent = FALSE;	72	const char *fmt;
35		73	int c1, c2, char_pos, line_pos;
36	while ((c = getopt(argc, argv, "s")) != EOF) {	74	int opt_flags;
37	switch (c) {	75	int exit_val = 0;
38	case 's':	76
39	silent = TRUE;	77	bb_default_error_retval = 2; /* 1 is returned if files are different. */
40	break;	78
41	default:	79	opt_flags = bb_getopt_ulflags(argc, argv, opt_chars);
42	show_usage();	80
43	}	81	if ((opt_flags == 3) \|\| (((unsigned int)(--argc - optind)) > 1)) {
		82	bb_show_usage();
44	}	83	}
45		84
46	filename1 = argv[optind];	85	fp1 = cmp_xfopen_input(filename1 = *(argv += optind));
47	switch (argc - optind) {	86
48	case 2:	87	filename2 = "-";
49	fp2 = xfopen(filename2 = argv[optind + 1], "r");	88	if (*++argv) {
50	case 1:	89	filename2 = *argv;
51	fp1 = xfopen(filename1, "r");
52	break;
53	default:
54	show_usage();
55	}	90	}
		91	fp2 = cmp_xfopen_input(filename2);
56		92
		93	if (fp1 == fp2) { /* Paranioa check... stdin == stdin? */
		94	/* Note that we don't bother reading stdin. Neither does gnu wc.
		95	* But perhaps we should, so that other apps down the chain don't
		96	* get the input. Consider 'echo hello \| (cmp - - && cat -)'.
		97	*/
		98	return 0;
		99	}
		100
		101	fmt = fmt_differ;
		102	if (opt_flags == OPT_l) {
		103	fmt = fmt_l_opt;
		104	}
		105
		106	char_pos = 0;
		107	line_pos = 1;
57	do {	108	do {
58	c1 = fgetc(fp1);	109	c1 = getc(fp1);
59	c2 = fgetc(fp2);	110	c2 = getc(fp2);
60	if (c1 != c2) {	111	++char_pos;
61	if (silent)	112	if (c1 != c2) { /* Remember -- a read error may have occurred. */
62	return EXIT_FAILURE;	113	exit_val = 1; /* But assume the files are different for now. */
63	if (c1 == EOF)	114	if (c2 == EOF) {
64	printf("EOF on %s\n", filename1);	115	/* We know that fp1 isn't at EOF or in an error state. But to
65	else if (c2 == EOF)	116	* save space below, things are setup to expect an EOF in fp1
66	printf("EOF on %s\n", filename2);	117	* if an EOF occurred. So, swap things around.
67	else	118	*/
68	printf("%s %s differ: char %d, line %d\n", filename1, filename2,	119	fp1 = fp2;
69	char_pos, line_pos);	120	filename1 = filename2;
70	return EXIT_FAILURE;	121	c1 = c2;
		122	}
		123	if (c1 == EOF) {
		124	bb_xferror(fp1, filename1);
		125	fmt = fmt_eof; /* Well, no error, so it must really be EOF. */
		126	outfile = stderr;
		127	/* There may have been output to stdout (option -l), so
		128	* make sure we fflush before writing to stderr. */
		129	bb_xfflush_stdout();
		130	}
		131	if (opt_flags != OPT_s) {
		132	if (opt_flags == OPT_l) {
		133	line_pos = c1; /* line_pos is unused in the -l case. */
		134	}
		135	bb_fprintf(outfile, fmt, filename1, filename2, char_pos, line_pos, c2);
		136	if (opt_flags) { /* This must be -l since not -s. */
		137	/* If we encountered and EOF, the while check will catch it. */
		138	continue;
		139	}
		140	}
		141	break;
		142	}
		143	if (c1 == '\n') {
		144	++line_pos;
71	}	145	}
72	char_pos++;
73	if (c1 == '\n')
74	line_pos++;
75	} while (c1 != EOF);	146	} while (c1 != EOF);
76		147
77	return EXIT_SUCCESS;	148	bb_xferror(fp1, filename1);
		149	bb_xferror(fp2, filename2);
		150
		151	bb_fflush_stdout_and_exit(exit_val);
78	}	152	}