X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=findutils%2Fgrep.c;h=b072cd44126f7f4abb16dcc0fa3edde752d47226;hb=47cfbf32fd66563f8c4e09ad6cced6abfbe2fad5;hp=030e62461d2fc14768857ad055d87c4cd06299d1;hpb=5415c856eaccd1bc5d064022770a288f43b2e94f;p=oweals%2Fbusybox.git diff --git a/findutils/grep.c b/findutils/grep.c index 030e62461..b072cd441 100644 --- a/findutils/grep.c +++ b/findutils/grep.c @@ -5,7 +5,7 @@ * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley * Copyright (C) 1999,2000,2001 by Mark Whitley * - * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ /* BB_AUDIT SUSv3 defects - unsupported option -x "match whole line only". */ /* BB_AUDIT GNU defects - always acts as -a. */ @@ -14,24 +14,114 @@ * 2004,2006 (C) Vladimir Oleynik - * correction "-e pattern1 -e pattern2" logic and more optimizations. * precompiled regex - */ -/* + * * (C) 2006 Jac Goudsmit added -o option */ +//applet:IF_GREP(APPLET(grep, BB_DIR_BIN, BB_SUID_DROP)) +//applet:IF_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, BB_DIR_BIN, BB_SUID_DROP, egrep)) +//applet:IF_FEATURE_GREP_FGREP_ALIAS(APPLET_ODDNAME(fgrep, grep, BB_DIR_BIN, BB_SUID_DROP, fgrep)) + +//kbuild:lib-$(CONFIG_GREP) += grep.o + +//config:config GREP +//config: bool "grep" +//config: default y +//config: help +//config: grep is used to search files for a specified pattern. +//config: +//config:config FEATURE_GREP_EGREP_ALIAS +//config: bool "Enable extended regular expressions (egrep & grep -E)" +//config: default y +//config: depends on GREP +//config: help +//config: Enabled support for extended regular expressions. Extended +//config: regular expressions allow for alternation (foo|bar), grouping, +//config: and various repetition operators. +//config: +//config:config FEATURE_GREP_FGREP_ALIAS +//config: bool "Alias fgrep to grep -F" +//config: default y +//config: depends on GREP +//config: help +//config: fgrep sees the search pattern as a normal string rather than +//config: regular expressions. +//config: grep -F always works, this just creates the fgrep alias. +//config: +//config:config FEATURE_GREP_CONTEXT +//config: bool "Enable before and after context flags (-A, -B and -C)" +//config: default y +//config: depends on GREP +//config: help +//config: Print the specified number of leading (-B) and/or trailing (-A) +//config: context surrounding our matching lines. +//config: Print the specified number of context lines (-C). + #include "libbb.h" +#include "common_bufsiz.h" #include "xregex.h" + /* options */ +//usage:#define grep_trivial_usage +//usage: "[-HhnlLoqvsriw" +//usage: "F" +//usage: IF_FEATURE_GREP_EGREP_ALIAS("E") +//usage: IF_EXTRA_COMPAT("z") +//usage: "] [-m N] " +//usage: IF_FEATURE_GREP_CONTEXT("[-A/B/C N] ") +//usage: "PATTERN/-e PATTERN.../-f FILE [FILE]..." +//usage:#define grep_full_usage "\n\n" +//usage: "Search for PATTERN in FILEs (or stdin)\n" +//usage: "\n -H Add 'filename:' prefix" +//usage: "\n -h Do not add 'filename:' prefix" +//usage: "\n -n Add 'line_no:' prefix" +//usage: "\n -l Show only names of files that match" +//usage: "\n -L Show only names of files that don't match" +//usage: "\n -c Show only count of matching lines" +//usage: "\n -o Show only the matching part of line" +//usage: "\n -q Quiet. Return 0 if PATTERN is found, 1 otherwise" +//usage: "\n -v Select non-matching lines" +//usage: "\n -s Suppress open and read errors" +//usage: "\n -r Recurse" +//usage: "\n -i Ignore case" +//usage: "\n -w Match whole words only" +//usage: "\n -x Match whole lines only" +//usage: "\n -F PATTERN is a literal (not regexp)" +//usage: IF_FEATURE_GREP_EGREP_ALIAS( +//usage: "\n -E PATTERN is an extended regexp" +//usage: ) +//usage: IF_EXTRA_COMPAT( +//usage: "\n -z Input is NUL terminated" +//usage: ) +//usage: "\n -m N Match up to N times per file" +//usage: IF_FEATURE_GREP_CONTEXT( +//usage: "\n -A N Print N lines of trailing context" +//usage: "\n -B N Print N lines of leading context" +//usage: "\n -C N Same as '-A N -B N'" +//usage: ) +//usage: "\n -e PTRN Pattern to match" +//usage: "\n -f FILE Read pattern from file" +//usage: +//usage:#define grep_example_usage +//usage: "$ grep root /etc/passwd\n" +//usage: "root:x:0:0:root:/root:/bin/bash\n" +//usage: "$ grep ^[rR]oo. /etc/passwd\n" +//usage: "root:x:0:0:root:/root:/bin/bash\n" +//usage: +//usage:#define egrep_trivial_usage NOUSAGE_STR +//usage:#define egrep_full_usage "" +//usage:#define fgrep_trivial_usage NOUSAGE_STR +//usage:#define fgrep_full_usage "" + #define OPTSTR_GREP \ - "lnqvscFiHhe:f:Lorm:" \ - USE_FEATURE_GREP_CONTEXT("A:B:C:") \ - USE_FEATURE_GREP_EGREP_ALIAS("E") \ - USE_DESKTOP("w") \ + "lnqvscFiHhe:f:Lorm:wx" \ + IF_FEATURE_GREP_CONTEXT("A:B:C:") \ + IF_FEATURE_GREP_EGREP_ALIAS("E") \ + IF_EXTRA_COMPAT("z") \ "aI" /* ignored: -a "assume all files to be text" */ /* ignored: -I "assume binary files have no matches" */ - enum { OPTBIT_l, /* list matched file names only */ OPTBIT_n, /* print line# */ @@ -49,11 +139,13 @@ enum { OPTBIT_o, /* show only matching parts of lines */ OPTBIT_r, /* recurse dirs */ OPTBIT_m, /* -m MAX_MATCHES */ - USE_FEATURE_GREP_CONTEXT( OPTBIT_A ,) /* -A NUM: after-match context */ - USE_FEATURE_GREP_CONTEXT( OPTBIT_B ,) /* -B NUM: before-match context */ - USE_FEATURE_GREP_CONTEXT( OPTBIT_C ,) /* -C NUM: -A and -B combined */ - USE_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */ - USE_DESKTOP( OPTBIT_w ,) /* whole word match */ + OPTBIT_w, /* -w whole word match */ + OPTBIT_x, /* -x whole line match */ + IF_FEATURE_GREP_CONTEXT( OPTBIT_A ,) /* -A NUM: after-match context */ + IF_FEATURE_GREP_CONTEXT( OPTBIT_B ,) /* -B NUM: before-match context */ + IF_FEATURE_GREP_CONTEXT( OPTBIT_C ,) /* -C NUM: -A and -B combined */ + IF_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */ + IF_EXTRA_COMPAT( OPTBIT_z ,) /* input is NUL terminated */ OPT_l = 1 << OPTBIT_l, OPT_n = 1 << OPTBIT_n, OPT_q = 1 << OPTBIT_q, @@ -70,11 +162,13 @@ enum { OPT_o = 1 << OPTBIT_o, OPT_r = 1 << OPTBIT_r, OPT_m = 1 << OPTBIT_m, - OPT_A = USE_FEATURE_GREP_CONTEXT( (1 << OPTBIT_A)) + 0, - OPT_B = USE_FEATURE_GREP_CONTEXT( (1 << OPTBIT_B)) + 0, - OPT_C = USE_FEATURE_GREP_CONTEXT( (1 << OPTBIT_C)) + 0, - OPT_E = USE_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0, - OPT_w = USE_DESKTOP( (1 << OPTBIT_w)) + 0, + OPT_w = 1 << OPTBIT_w, + OPT_x = 1 << OPTBIT_x, + OPT_A = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_A)) + 0, + OPT_B = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_B)) + 0, + OPT_C = IF_FEATURE_GREP_CONTEXT( (1 << OPTBIT_C)) + 0, + OPT_E = IF_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0, + OPT_z = IF_EXTRA_COMPAT( (1 << OPTBIT_z)) + 0, }; #define PRINT_FILES_WITH_MATCHES (option_mask32 & OPT_l) @@ -84,10 +178,15 @@ enum { #define PRINT_MATCH_COUNTS (option_mask32 & OPT_c) #define FGREP_FLAG (option_mask32 & OPT_F) #define PRINT_FILES_WITHOUT_MATCHES (option_mask32 & OPT_L) +#define NUL_DELIMITED (option_mask32 & OPT_z) struct globals { int max_matches; +#if !ENABLE_EXTRA_COMPAT int reflags; +#else + RE_TRANSLATE_TYPE case_fold; /* RE_TRANSLATE_TYPE is [[un]signed] char* */ +#endif smalluint invert_search; smalluint print_filename; smalluint open_errors; @@ -96,20 +195,33 @@ struct globals { int lines_before; int lines_after; char **before_buf; + IF_EXTRA_COMPAT(size_t *before_buf_size;) int last_line_printed; #endif /* globals used internally */ llist_t *pattern_head; /* growable list of patterns to match */ const char *cur_file; /* the current file we are reading */ -}; -#define G (*(struct globals*)&bb_common_bufsiz1) +} FIX_ALIASING; +#define G (*(struct globals*)bb_common_bufsiz1) #define INIT_G() do { \ - struct G_sizecheck { \ - char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \ - }; \ + setup_common_bufsiz(); \ + BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \ } while (0) #define max_matches (G.max_matches ) -#define reflags (G.reflags ) +#if !ENABLE_EXTRA_COMPAT +# define reflags (G.reflags ) +#else +# define case_fold (G.case_fold ) +/* http://www.delorie.com/gnu/docs/regex/regex_46.html */ +# define reflags re_syntax_options +# undef REG_NOSUB +# undef REG_EXTENDED +# undef REG_ICASE +# define REG_NOSUB bug:is:here /* should not be used */ +/* Just RE_SYNTAX_EGREP is not enough, need to enable {n[,[m]]} too */ +# define REG_EXTENDED (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES) +# define REG_ICASE bug:is:here /* should not be used */ +#endif #define invert_search (G.invert_search ) #define print_filename (G.print_filename ) #define open_errors (G.open_errors ) @@ -117,6 +229,7 @@ struct globals { #define lines_before (G.lines_before ) #define lines_after (G.lines_after ) #define before_buf (G.before_buf ) +#define before_buf_size (G.before_buf_size ) #define last_line_printed (G.last_line_printed ) #define pattern_head (G.pattern_head ) #define cur_file (G.cur_file ) @@ -124,14 +237,24 @@ struct globals { typedef struct grep_list_data_t { char *pattern; - regex_t preg; +/* for GNU regex, matched_range must be persistent across grep_file() calls */ +#if !ENABLE_EXTRA_COMPAT + regex_t compiled_regex; + regmatch_t matched_range; +#else + struct re_pattern_buffer compiled_regex; + struct re_registers matched_range; +#endif #define ALLOCATED 1 #define COMPILED 2 int flg_mem_alocated_compiled; } grep_list_data_t; - -static void print_line(const char *line, int linenum, char decoration) +#if !ENABLE_EXTRA_COMPAT +#define print_line(line, line_len, linenum, decoration) \ + print_line(line, linenum, decoration) +#endif +static void print_line(const char *line, size_t line_len, int linenum, char decoration) { #if ENABLE_FEATURE_GREP_CONTEXT /* Happens when we go to next file, immediately hit match @@ -139,8 +262,9 @@ static void print_line(const char *line, int linenum, char decoration) if (linenum < 1) return; /* possibly print the little '--' separator */ - if ((lines_before || lines_after) && did_print_line && - last_line_printed != linenum - 1) { + if ((lines_before || lines_after) && did_print_line + && last_line_printed != linenum - 1 + ) { puts("--"); } /* guard against printing "--" before first line of first file */ @@ -152,26 +276,66 @@ static void print_line(const char *line, int linenum, char decoration) if (PRINT_LINE_NUM) printf("%i%c", linenum, decoration); /* Emulate weird GNU grep behavior with -ov */ - if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) + if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) { +#if !ENABLE_EXTRA_COMPAT puts(line); +#else + fwrite(line, 1, line_len, stdout); + putchar(NUL_DELIMITED ? '\0' : '\n'); +#endif + } } -static int grep_file(FILE *file) +#if ENABLE_EXTRA_COMPAT +/* Unlike getline, this one removes trailing '\n' */ +static ssize_t FAST_FUNC bb_getline(char **line_ptr, size_t *line_alloc_len, FILE *file) { + ssize_t res_sz; char *line; + int delim = (NUL_DELIMITED ? '\0' : '\n'); + + res_sz = getdelim(line_ptr, line_alloc_len, delim, file); + line = *line_ptr; + + if (res_sz > 0) { + if (line[res_sz - 1] == delim) + line[--res_sz] = '\0'; + } else { + free(line); /* uclibc allocates a buffer even on EOF. WTF? */ + } + return res_sz; +} +#endif + +static int grep_file(FILE *file) +{ smalluint found; int linenum = 0; int nmatches = 0; - regmatch_t regmatch; +#if !ENABLE_EXTRA_COMPAT + char *line; +#else + char *line = NULL; + ssize_t line_len; + size_t line_alloc_len; +# define rm_so start[0] +# define rm_eo end[0] +#endif #if ENABLE_FEATURE_GREP_CONTEXT int print_n_lines_after = 0; int curpos = 0; /* track where we are in the circular 'before' buffer */ int idx = 0; /* used for iteration through the circular buffer */ #else enum { print_n_lines_after = 0 }; -#endif /* ENABLE_FEATURE_GREP_CONTEXT */ +#endif - while ((line = xmalloc_fgetline(file)) != NULL) { + while ( +#if !ENABLE_EXTRA_COMPAT + (line = xmalloc_fgetline(file)) != NULL +#else + (line_len = bb_getline(&line, &line_alloc_len, file)) >= 0 +#endif + ) { llist_t *pattern_ptr = pattern_head; grep_list_data_t *gl = gl; /* for gcc */ @@ -180,25 +344,108 @@ static int grep_file(FILE *file) while (pattern_ptr) { gl = (grep_list_data_t *)pattern_ptr->data; if (FGREP_FLAG) { - found |= (strstr(line, gl->pattern) != NULL); + char *match; + char *str = line; + opt_f_again: + match = ((option_mask32 & OPT_i) + ? strcasestr(str, gl->pattern) + : strstr(str, gl->pattern) + ); + if (match) { + if (option_mask32 & OPT_x) { + if (match != str) + goto opt_f_not_found; + if (str[strlen(gl->pattern)] != '\0') + goto opt_f_not_found; + } else + if (option_mask32 & OPT_w) { + char c = (match != str) ? match[-1] : ' '; + if (!isalnum(c) && c != '_') { + c = match[strlen(gl->pattern)]; + if (!c || (!isalnum(c) && c != '_')) + goto opt_f_found; + } + str = match + 1; + goto opt_f_again; + } + opt_f_found: + found = 1; + opt_f_not_found: ; + } } else { +#if ENABLE_EXTRA_COMPAT + unsigned start_pos; +#else + int match_flg; +#endif + char *match_at; + if (!(gl->flg_mem_alocated_compiled & COMPILED)) { gl->flg_mem_alocated_compiled |= COMPILED; - xregcomp(&(gl->preg), gl->pattern, reflags); +#if !ENABLE_EXTRA_COMPAT + xregcomp(&gl->compiled_regex, gl->pattern, reflags); +#else + memset(&gl->compiled_regex, 0, sizeof(gl->compiled_regex)); + gl->compiled_regex.translate = case_fold; /* for -i */ + if (re_compile_pattern(gl->pattern, strlen(gl->pattern), &gl->compiled_regex)) + bb_error_msg_and_die("bad regex '%s'", gl->pattern); +#endif } - regmatch.rm_so = 0; - regmatch.rm_eo = 0; - if (regexec(&(gl->preg), line, 1, ®match, 0) == 0) { - if (!(option_mask32 & OPT_w)) +#if !ENABLE_EXTRA_COMPAT + gl->matched_range.rm_so = 0; + gl->matched_range.rm_eo = 0; + match_flg = 0; +#else + start_pos = 0; +#endif + match_at = line; + opt_w_again: +//bb_error_msg("'%s' start_pos:%d line_len:%d", match_at, start_pos, line_len); + if ( +#if !ENABLE_EXTRA_COMPAT + regexec(&gl->compiled_regex, match_at, 1, &gl->matched_range, match_flg) == 0 +#else + re_search(&gl->compiled_regex, match_at, line_len, + start_pos, /*range:*/ line_len, + &gl->matched_range) >= 0 +#endif + ) { + if (option_mask32 & OPT_x) { + found = (gl->matched_range.rm_so == 0 + && match_at[gl->matched_range.rm_eo] == '\0'); + } else + if (!(option_mask32 & OPT_w)) { found = 1; - else { + } else { char c = ' '; - if (regmatch.rm_so) - c = line[regmatch.rm_so - 1]; + if (match_at > line || gl->matched_range.rm_so != 0) { + c = match_at[gl->matched_range.rm_so - 1]; + } if (!isalnum(c) && c != '_') { - c = line[regmatch.rm_eo]; - if (!c || (!isalnum(c) && c != '_')) - found = 1; + c = match_at[gl->matched_range.rm_eo]; + } + if (!isalnum(c) && c != '_') { + found = 1; + } else { + /* + * Why check gl->matched_range.rm_eo? + * Zero-length match makes -w skip the line: + * "echo foo | grep ^" prints "foo", + * "echo foo | grep -w ^" prints nothing. + * Without such check, we can loop forever. + */ +#if !ENABLE_EXTRA_COMPAT + if (gl->matched_range.rm_eo != 0) { + match_at += gl->matched_range.rm_eo; + match_flg |= REG_NOTBOL; + goto opt_w_again; + } +#else + if (gl->matched_range.rm_eo > start_pos) { + start_pos = gl->matched_range.rm_eo; + goto opt_w_again; + } +#endif } } } @@ -261,7 +508,7 @@ static int grep_file(FILE *file) /* now print each line in the buffer, clearing them as we go */ while (before_buf[idx] != NULL) { - print_line(before_buf[idx], first_buf_entry_line_num, '-'); + print_line(before_buf[idx], before_buf_size[idx], first_buf_entry_line_num, '-'); free(before_buf[idx]); before_buf[idx] = NULL; idx = (idx + 1) % lines_before; @@ -277,13 +524,36 @@ static int grep_file(FILE *file) /* -Fo just prints the pattern * (unless -v: -Fov doesnt print anything at all) */ if (found) - print_line(gl->pattern, linenum, ':'); - } else { - line[regmatch.rm_eo] = '\0'; - print_line(line + regmatch.rm_so, linenum, ':'); + print_line(gl->pattern, strlen(gl->pattern), linenum, ':'); + } else while (1) { + unsigned start = gl->matched_range.rm_so; + unsigned end = gl->matched_range.rm_eo; + unsigned len = end - start; + char old = line[end]; + line[end] = '\0'; + /* Empty match is not printed: try "echo test | grep -o ''" */ + if (len != 0) + print_line(line + start, len, linenum, ':'); + if (old == '\0') + break; + line[end] = old; + if (len == 0) + end++; +#if !ENABLE_EXTRA_COMPAT + if (regexec(&gl->compiled_regex, line + end, + 1, &gl->matched_range, REG_NOTBOL) != 0) + break; + gl->matched_range.rm_so += end; + gl->matched_range.rm_eo += end; +#else + if (re_search(&gl->compiled_regex, line, line_len, + end, line_len - end, + &gl->matched_range) < 0) + break; +#endif } } else { - print_line(line, linenum, ':'); + print_line(line, line_len, linenum, ':'); } } } @@ -291,12 +561,13 @@ static int grep_file(FILE *file) else { /* no match */ /* if we need to print some context lines after the last match, do so */ if (print_n_lines_after) { - print_line(line, linenum, '-'); + print_line(line, strlen(line), linenum, '-'); print_n_lines_after--; } else if (lines_before) { /* Add the line to the circular 'before' buffer */ free(before_buf[curpos]); before_buf[curpos] = line; + IF_EXTRA_COMPAT(before_buf_size[curpos] = line_len;) curpos = (curpos + 1) % lines_before; /* avoid free(line) - we took the line */ line = NULL; @@ -304,13 +575,17 @@ static int grep_file(FILE *file) } #endif /* ENABLE_FEATURE_GREP_CONTEXT */ +#if !ENABLE_EXTRA_COMPAT free(line); - +#endif /* Did we print all context after last requested match? */ if ((option_mask32 & OPT_m) - && !print_n_lines_after && nmatches == max_matches) + && !print_n_lines_after + && nmatches == max_matches + ) { break; - } + } + } /* while (read line) */ /* special-case file post-processing for options where we don't print line * matches, just filenames and possibly match counts */ @@ -353,20 +628,20 @@ static char *add_grep_list_data(char *pattern) static void load_regexes_from_file(llist_t *fopt) { - char *line; - FILE *f; - while (fopt) { + char *line; + FILE *fp; llist_t *cur = fopt; char *ffile = cur->data; fopt = cur->link; free(cur); - f = xfopen_stdin(ffile); - while ((line = xmalloc_fgetline(f)) != NULL) { + fp = xfopen_stdin(ffile); + while ((line = xmalloc_fgetline(fp)) != NULL) { llist_add_to(&pattern_head, new_grep_list_data(line, ALLOCATED)); } + fclose_if_not_stdin(fp); } } @@ -393,7 +668,7 @@ static int grep_dir(const char *dir) int matched = 0; recursive_action(dir, /* recurse=yes */ ACTION_RECURSE | - /* followLinks=no */ + /* followLinks=command line only */ ACTION_FOLLOWLINKS_L0 | /* depthFirst=yes */ ACTION_DEPTHFIRST, /* fileAction= */ file_action_grep, /* dirAction= */ NULL, @@ -403,40 +678,48 @@ static int grep_dir(const char *dir) } int grep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; -int grep_main(int argc, char **argv) +int grep_main(int argc UNUSED_PARAM, char **argv) { FILE *file; int matched; llist_t *fopt = NULL; +#if ENABLE_FEATURE_GREP_CONTEXT + int Copt, opts; +#endif + + /* For grep, exitcode of 1 is "not found". Other errors are 2: */ + xfunc_error_retval = 2; /* do normal option parsing */ #if ENABLE_FEATURE_GREP_CONTEXT - int Copt; - /* -H unsets -h; -C unsets -A,-B; -e,-f are lists; * -m,-A,-B,-C have numeric param */ opt_complementary = "H-h:C-AB:e::f::m+:A+:B+:C+"; - getopt32(argv, + opts = getopt32(argv, OPTSTR_GREP, &pattern_head, &fopt, &max_matches, &lines_after, &lines_before, &Copt); - if (option_mask32 & OPT_C) { + if (opts & OPT_C) { /* -C unsets prev -A and -B, but following -A or -B - may override it */ - if (!(option_mask32 & OPT_A)) /* not overridden */ + * may override it */ + if (!(opts & OPT_A)) /* not overridden */ lines_after = Copt; - if (!(option_mask32 & OPT_B)) /* not overridden */ + if (!(opts & OPT_B)) /* not overridden */ lines_before = Copt; - //option_mask32 |= OPT_A|OPT_B; /* for parser */ } /* sanity checks */ - if (option_mask32 & (OPT_c|OPT_q|OPT_l|OPT_L)) { + if (opts & (OPT_c|OPT_q|OPT_l|OPT_L)) { option_mask32 &= ~OPT_n; lines_before = 0; lines_after = 0; - } else if (lines_before > 0) - before_buf = xzalloc(lines_before * sizeof(char *)); + } else if (lines_before > 0) { + if (lines_before > INT_MAX / sizeof(long long)) + lines_before = INT_MAX / sizeof(long long); + /* overflow in (lines_before * sizeof(x)) is prevented (above) */ + before_buf = xzalloc(lines_before * sizeof(before_buf[0])); + IF_EXTRA_COMPAT(before_buf_size = xzalloc(lines_before * sizeof(before_buf_size[0]));) + } #else /* with auto sanity checks */ /* -H unsets -h; -c,-q or -l unset -n; -e,-f are lists; -m N */ @@ -446,33 +729,53 @@ int grep_main(int argc, char **argv) #endif invert_search = ((option_mask32 & OPT_v) != 0); /* 0 | 1 */ - if (pattern_head != NULL) { - /* convert char **argv to grep_list_data_t */ + { /* convert char **argv to grep_list_data_t */ llist_t *cur; - for (cur = pattern_head; cur; cur = cur->link) cur->data = new_grep_list_data(cur->data, 0); } - if (option_mask32 & OPT_f) + if (option_mask32 & OPT_f) { load_regexes_from_file(fopt); + if (!pattern_head) { /* -f EMPTY_FILE? */ + /* GNU grep treats it as "nothing matches" */ + llist_add_to(&pattern_head, new_grep_list_data((char*) "", 0)); + invert_search ^= 1; + } + } if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f') option_mask32 |= OPT_F; - if (!(option_mask32 & (OPT_o | OPT_w))) +#if !ENABLE_EXTRA_COMPAT + if (!(option_mask32 & (OPT_o | OPT_w | OPT_x))) reflags = REG_NOSUB; +#endif if (ENABLE_FEATURE_GREP_EGREP_ALIAS && (applet_name[0] == 'e' || (option_mask32 & OPT_E)) ) { reflags |= REG_EXTENDED; } +#if ENABLE_EXTRA_COMPAT + else { + reflags = RE_SYNTAX_GREP; + } +#endif - if (option_mask32 & OPT_i) + if (option_mask32 & OPT_i) { +#if !ENABLE_EXTRA_COMPAT reflags |= REG_ICASE; +#else + int i; + case_fold = xmalloc(256); + for (i = 0; i < 256; i++) + case_fold[i] = (unsigned char)i; + for (i = 'a'; i <= 'z'; i++) + case_fold[i] = (unsigned char)(i - ('a' - 'A')); +#endif + } argv += optind; - argc -= optind; /* if we didn't get a pattern from -e and no command file was specified, * first parameter should be the pattern. no pattern, no worky */ @@ -482,12 +785,11 @@ int grep_main(int argc, char **argv) bb_show_usage(); pattern = new_grep_list_data(*argv++, 0); llist_add_to(&pattern_head, pattern); - argc--; } /* argv[0..(argc-1)] should be names of file to grep through. If * there is more than one file to grep, we will print the filenames. */ - if (argc > 1) + if (argv[0] && argv[1]) print_filename = 1; /* -H / -h of course override */ if (option_mask32 & OPT_H) @@ -499,7 +801,7 @@ int grep_main(int argc, char **argv) * stdin. Otherwise, we grep through all the files specified. */ matched = 0; do { - cur_file = *argv++; + cur_file = *argv; file = stdin; if (!cur_file || LONE_DASH(cur_file)) { cur_file = "(standard input)"; @@ -525,7 +827,7 @@ int grep_main(int argc, char **argv) matched += grep_file(file); fclose_if_not_stdin(file); grep_done: ; - } while (--argc > 0); + } while (*argv && *++argv); /* destroy all the elments in the pattern list */ if (ENABLE_FEATURE_CLEAN_UP) { @@ -537,7 +839,7 @@ int grep_main(int argc, char **argv) if (gl->flg_mem_alocated_compiled & ALLOCATED) free(gl->pattern); if (gl->flg_mem_alocated_compiled & COMPILED) - regfree(&(gl->preg)); + regfree(&gl->compiled_regex); free(gl); free(pattern_head_ptr); }