source: branches/3.2/mindi-busybox/findutils/grep.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 6 years ago
  • Update mindi-busybox to 1.21.1
File size: 24.2 KB
RevLine 
[821]1/* vi: set sw=4 ts=4: */
2/*
3 * Mini grep implementation for busybox using libc regex.
4 *
5 * Copyright (C) 1999,2000,2001 by Lineo, inc. and Mark Whitley
6 * Copyright (C) 1999,2000,2001 by Mark Whitley <markw@codepoet.org>
7 *
[2725]8 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
[821]9 */
[2725]10/* BB_AUDIT SUSv3 defects - unsupported option -x "match whole line only". */
[821]11/* BB_AUDIT GNU defects - always acts as -a.  */
12/* http://www.opengroup.org/onlinepubs/007904975/utilities/grep.html */
13/*
14 * 2004,2006 (C) Vladimir Oleynik <dzo@simtreas.ru> -
15 * correction "-e pattern1 -e pattern2" logic and more optimizations.
16 * precompiled regex
[2725]17 *
[1765]18 * (C) 2006 Jac Goudsmit added -o option
19 */
[821]20
[3232]21//applet:IF_GREP(APPLET(grep, BB_DIR_BIN, BB_SUID_DROP))
22//applet:IF_FEATURE_GREP_EGREP_ALIAS(APPLET_ODDNAME(egrep, grep, BB_DIR_BIN, BB_SUID_DROP, egrep))
23//applet:IF_FEATURE_GREP_FGREP_ALIAS(APPLET_ODDNAME(fgrep, grep, BB_DIR_BIN, BB_SUID_DROP, fgrep))
[2725]24
25//kbuild:lib-$(CONFIG_GREP) += grep.o
26
27//config:config GREP
28//config:   bool "grep"
29//config:   default y
30//config:   help
31//config:     grep is used to search files for a specified pattern.
32//config:
33//config:config FEATURE_GREP_EGREP_ALIAS
34//config:   bool "Enable extended regular expressions (egrep & grep -E)"
35//config:   default y
36//config:   depends on GREP
37//config:   help
38//config:     Enabled support for extended regular expressions. Extended
39//config:     regular expressions allow for alternation (foo|bar), grouping,
40//config:     and various repetition operators.
41//config:
42//config:config FEATURE_GREP_FGREP_ALIAS
43//config:   bool "Alias fgrep to grep -F"
44//config:   default y
45//config:   depends on GREP
46//config:   help
47//config:     fgrep sees the search pattern as a normal string rather than
48//config:     regular expressions.
49//config:     grep -F always works, this just creates the fgrep alias.
50//config:
51//config:config FEATURE_GREP_CONTEXT
52//config:   bool "Enable before and after context flags (-A, -B and -C)"
53//config:   default y
54//config:   depends on GREP
55//config:   help
56//config:     Print the specified number of leading (-B) and/or trailing (-A)
57//config:     context surrounding our matching lines.
58//config:     Print the specified number of context lines (-C).
59
[1765]60#include "libbb.h"
[821]61#include "xregex.h"
62
[2725]63
[821]64/* options */
[2725]65//usage:#define grep_trivial_usage
66//usage:       "[-HhnlLoqvsriw"
67//usage:       "F"
68//usage:    IF_FEATURE_GREP_EGREP_ALIAS("E")
69//usage:    IF_EXTRA_COMPAT("z")
70//usage:       "] [-m N] "
71//usage:    IF_FEATURE_GREP_CONTEXT("[-A/B/C N] ")
72//usage:       "PATTERN/-e PATTERN.../-f FILE [FILE]..."
73//usage:#define grep_full_usage "\n\n"
74//usage:       "Search for PATTERN in FILEs (or stdin)\n"
75//usage:     "\n    -H  Add 'filename:' prefix"
76//usage:     "\n    -h  Do not add 'filename:' prefix"
77//usage:     "\n    -n  Add 'line_no:' prefix"
78//usage:     "\n    -l  Show only names of files that match"
79//usage:     "\n    -L  Show only names of files that don't match"
80//usage:     "\n    -c  Show only count of matching lines"
81//usage:     "\n    -o  Show only the matching part of line"
82//usage:     "\n    -q  Quiet. Return 0 if PATTERN is found, 1 otherwise"
83//usage:     "\n    -v  Select non-matching lines"
84//usage:     "\n    -s  Suppress open and read errors"
85//usage:     "\n    -r  Recurse"
86//usage:     "\n    -i  Ignore case"
87//usage:     "\n    -w  Match whole words only"
[3232]88//usage:     "\n    -x  Match whole lines only"
[2725]89//usage:     "\n    -F  PATTERN is a literal (not regexp)"
90//usage:    IF_FEATURE_GREP_EGREP_ALIAS(
91//usage:     "\n    -E  PATTERN is an extended regexp"
92//usage:    )
93//usage:    IF_EXTRA_COMPAT(
94//usage:     "\n    -z  Input is NUL terminated"
95//usage:    )
96//usage:     "\n    -m N    Match up to N times per file"
97//usage:    IF_FEATURE_GREP_CONTEXT(
98//usage:     "\n    -A N    Print N lines of trailing context"
99//usage:     "\n    -B N    Print N lines of leading context"
100//usage:     "\n    -C N    Same as '-A N -B N'"
101//usage:    )
102//usage:     "\n    -e PTRN Pattern to match"
103//usage:     "\n    -f FILE Read pattern from file"
104//usage:
105//usage:#define grep_example_usage
106//usage:       "$ grep root /etc/passwd\n"
107//usage:       "root:x:0:0:root:/root:/bin/bash\n"
108//usage:       "$ grep ^[rR]oo. /etc/passwd\n"
109//usage:       "root:x:0:0:root:/root:/bin/bash\n"
110//usage:
111//usage:#define egrep_trivial_usage NOUSAGE_STR
112//usage:#define egrep_full_usage ""
113//usage:#define fgrep_trivial_usage NOUSAGE_STR
114//usage:#define fgrep_full_usage ""
115
[1765]116#define OPTSTR_GREP \
[3232]117    "lnqvscFiHhe:f:Lorm:wx" \
[2725]118    IF_FEATURE_GREP_CONTEXT("A:B:C:") \
119    IF_FEATURE_GREP_EGREP_ALIAS("E") \
120    IF_EXTRA_COMPAT("z") \
[1765]121    "aI"
122/* ignored: -a "assume all files to be text" */
123/* ignored: -I "assume binary files have no matches" */
124enum {
125    OPTBIT_l, /* list matched file names only */
126    OPTBIT_n, /* print line# */
[2725]127    OPTBIT_q, /* quiet - exit(EXIT_SUCCESS) of first match */
[1765]128    OPTBIT_v, /* invert the match, to select non-matching lines */
129    OPTBIT_s, /* suppress errors about file open errors */
130    OPTBIT_c, /* count matches per file (suppresses normal output) */
131    OPTBIT_F, /* literal match */
132    OPTBIT_i, /* case-insensitive */
133    OPTBIT_H, /* force filename display */
134    OPTBIT_h, /* inhibit filename display */
135    OPTBIT_e, /* -e PATTERN */
136    OPTBIT_f, /* -f FILE_WITH_PATTERNS */
137    OPTBIT_L, /* list unmatched file names only */
138    OPTBIT_o, /* show only matching parts of lines */
139    OPTBIT_r, /* recurse dirs */
140    OPTBIT_m, /* -m MAX_MATCHES */
[2725]141    OPTBIT_w, /* -w whole word match */
[3232]142    OPTBIT_x, /* -x whole line match */
[2725]143    IF_FEATURE_GREP_CONTEXT(    OPTBIT_A ,) /* -A NUM: after-match context */
144    IF_FEATURE_GREP_CONTEXT(    OPTBIT_B ,) /* -B NUM: before-match context */
145    IF_FEATURE_GREP_CONTEXT(    OPTBIT_C ,) /* -C NUM: -A and -B combined */
146    IF_FEATURE_GREP_EGREP_ALIAS(OPTBIT_E ,) /* extended regexp */
147    IF_EXTRA_COMPAT(            OPTBIT_z ,) /* input is NUL terminated */
[1765]148    OPT_l = 1 << OPTBIT_l,
149    OPT_n = 1 << OPTBIT_n,
150    OPT_q = 1 << OPTBIT_q,
151    OPT_v = 1 << OPTBIT_v,
152    OPT_s = 1 << OPTBIT_s,
153    OPT_c = 1 << OPTBIT_c,
154    OPT_F = 1 << OPTBIT_F,
155    OPT_i = 1 << OPTBIT_i,
156    OPT_H = 1 << OPTBIT_H,
157    OPT_h = 1 << OPTBIT_h,
158    OPT_e = 1 << OPTBIT_e,
159    OPT_f = 1 << OPTBIT_f,
160    OPT_L = 1 << OPTBIT_L,
161    OPT_o = 1 << OPTBIT_o,
162    OPT_r = 1 << OPTBIT_r,
163    OPT_m = 1 << OPTBIT_m,
[2725]164    OPT_w = 1 << OPTBIT_w,
[3232]165    OPT_x = 1 << OPTBIT_x,
[2725]166    OPT_A = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_A)) + 0,
167    OPT_B = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_B)) + 0,
168    OPT_C = IF_FEATURE_GREP_CONTEXT(    (1 << OPTBIT_C)) + 0,
169    OPT_E = IF_FEATURE_GREP_EGREP_ALIAS((1 << OPTBIT_E)) + 0,
170    OPT_z = IF_EXTRA_COMPAT(            (1 << OPTBIT_z)) + 0,
[1765]171};
172
173#define PRINT_FILES_WITH_MATCHES    (option_mask32 & OPT_l)
174#define PRINT_LINE_NUM              (option_mask32 & OPT_n)
175#define BE_QUIET                    (option_mask32 & OPT_q)
176#define SUPPRESS_ERR_MSGS           (option_mask32 & OPT_s)
177#define PRINT_MATCH_COUNTS          (option_mask32 & OPT_c)
178#define FGREP_FLAG                  (option_mask32 & OPT_F)
179#define PRINT_FILES_WITHOUT_MATCHES (option_mask32 & OPT_L)
[2725]180#define NUL_DELIMITED               (option_mask32 & OPT_z)
[1765]181
[2725]182struct globals {
183    int max_matches;
184#if !ENABLE_EXTRA_COMPAT
185    int reflags;
186#else
187    RE_TRANSLATE_TYPE case_fold; /* RE_TRANSLATE_TYPE is [[un]signed] char* */
188#endif
189    smalluint invert_search;
190    smalluint print_filename;
191    smalluint open_errors;
192#if ENABLE_FEATURE_GREP_CONTEXT
193    smalluint did_print_line;
194    int lines_before;
195    int lines_after;
196    char **before_buf;
197    IF_EXTRA_COMPAT(size_t *before_buf_size;)
198    int last_line_printed;
199#endif
200    /* globals used internally */
201    llist_t *pattern_head;   /* growable list of patterns to match */
202    const char *cur_file;    /* the current file we are reading */
203} FIX_ALIASING;
204#define G (*(struct globals*)&bb_common_bufsiz1)
205#define INIT_G() do { \
206    struct G_sizecheck { \
207        char G_sizecheck[sizeof(G) > COMMON_BUFSIZE ? -1 : 1]; \
208    }; \
209} while (0)
210#define max_matches       (G.max_matches         )
211#if !ENABLE_EXTRA_COMPAT
212# define reflags          (G.reflags             )
213#else
214# define case_fold        (G.case_fold           )
215/* http://www.delorie.com/gnu/docs/regex/regex_46.html */
216# define reflags           re_syntax_options
217# undef REG_NOSUB
218# undef REG_EXTENDED
219# undef REG_ICASE
220# define REG_NOSUB    bug:is:here /* should not be used */
221/* Just RE_SYNTAX_EGREP is not enough, need to enable {n[,[m]]} too */
222# define REG_EXTENDED (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)
223# define REG_ICASE    bug:is:here /* should not be used */
224#endif
225#define invert_search     (G.invert_search       )
226#define print_filename    (G.print_filename      )
227#define open_errors       (G.open_errors         )
228#define did_print_line    (G.did_print_line      )
229#define lines_before      (G.lines_before        )
230#define lines_after       (G.lines_after         )
231#define before_buf        (G.before_buf          )
232#define before_buf_size   (G.before_buf_size     )
233#define last_line_printed (G.last_line_printed   )
234#define pattern_head      (G.pattern_head        )
235#define cur_file          (G.cur_file            )
[1765]236
[821]237
[1765]238typedef struct grep_list_data_t {
[821]239    char *pattern;
[2725]240/* for GNU regex, matched_range must be persistent across grep_file() calls */
241#if !ENABLE_EXTRA_COMPAT
242    regex_t compiled_regex;
243    regmatch_t matched_range;
244#else
245    struct re_pattern_buffer compiled_regex;
246    struct re_registers matched_range;
247#endif
248#define ALLOCATED 1
[821]249#define COMPILED 2
250    int flg_mem_alocated_compiled;
251} grep_list_data_t;
252
[2725]253#if !ENABLE_EXTRA_COMPAT
254#define print_line(line, line_len, linenum, decoration) \
255    print_line(line, linenum, decoration)
256#endif
257static void print_line(const char *line, size_t line_len, int linenum, char decoration)
[821]258{
259#if ENABLE_FEATURE_GREP_CONTEXT
[1765]260    /* Happens when we go to next file, immediately hit match
261     * and try to print prev context... from prev file! Don't do it */
262    if (linenum < 1)
263        return;
[821]264    /* possibly print the little '--' separator */
[2725]265    if ((lines_before || lines_after) && did_print_line
266     && last_line_printed != linenum - 1
267    ) {
[821]268        puts("--");
269    }
[1765]270    /* guard against printing "--" before first line of first file */
271    did_print_line = 1;
[821]272    last_line_printed = linenum;
273#endif
[1765]274    if (print_filename)
[821]275        printf("%s%c", cur_file, decoration);
276    if (PRINT_LINE_NUM)
277        printf("%i%c", linenum, decoration);
[1765]278    /* Emulate weird GNU grep behavior with -ov */
[2725]279    if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) {
280#if !ENABLE_EXTRA_COMPAT
[1765]281        puts(line);
[2725]282#else
283        fwrite(line, 1, line_len, stdout);
284        putchar(NUL_DELIMITED ? '\0' : '\n');
285#endif
286    }
[821]287}
288
[2725]289#if ENABLE_EXTRA_COMPAT
290/* Unlike getline, this one removes trailing '\n' */
291static ssize_t FAST_FUNC bb_getline(char **line_ptr, size_t *line_alloc_len, FILE *file)
292{
293    ssize_t res_sz;
294    char *line;
295    int delim = (NUL_DELIMITED ? '\0' : '\n');
296
297    res_sz = getdelim(line_ptr, line_alloc_len, delim, file);
298    line = *line_ptr;
299
300    if (res_sz > 0) {
301        if (line[res_sz - 1] == delim)
302            line[--res_sz] = '\0';
303    } else {
304        free(line); /* uclibc allocates a buffer even on EOF. WTF? */
305    }
306    return res_sz;
307}
308#endif
309
[821]310static int grep_file(FILE *file)
311{
[2725]312    smalluint found;
[821]313    int linenum = 0;
314    int nmatches = 0;
[2725]315#if !ENABLE_EXTRA_COMPAT
316    char *line;
317#else
318    char *line = NULL;
319    ssize_t line_len;
320    size_t line_alloc_len;
321# define rm_so start[0]
322# define rm_eo end[0]
323#endif
[821]324#if ENABLE_FEATURE_GREP_CONTEXT
325    int print_n_lines_after = 0;
326    int curpos = 0; /* track where we are in the circular 'before' buffer */
327    int idx = 0; /* used for iteration through the circular buffer */
[1765]328#else
329    enum { print_n_lines_after = 0 };
[2725]330#endif
[821]331
[2725]332    while (
333#if !ENABLE_EXTRA_COMPAT
334        (line = xmalloc_fgetline(file)) != NULL
335#else
336        (line_len = bb_getline(&line, &line_alloc_len, file)) >= 0
337#endif
338    ) {
[821]339        llist_t *pattern_ptr = pattern_head;
[2725]340        grep_list_data_t *gl = gl; /* for gcc */
[821]341
342        linenum++;
[2725]343        found = 0;
[821]344        while (pattern_ptr) {
345            gl = (grep_list_data_t *)pattern_ptr->data;
346            if (FGREP_FLAG) {
[3232]347                char *match;
348                char *str = line;
349 opt_f_again:
350                match = ((option_mask32 & OPT_i)
351                    ? strcasestr(str, gl->pattern)
352                    : strstr(str, gl->pattern)
353                    );
354                if (match) {
355                    if (option_mask32 & OPT_x) {
356                        if (match != str)
357                            goto opt_f_not_found;
358                        if (str[strlen(gl->pattern)] != '\0')
359                            goto opt_f_not_found;
360                    } else
361                    if (option_mask32 & OPT_w) {
362                        char c = (match != str) ? match[-1] : ' ';
363                        if (!isalnum(c) && c != '_') {
364                            c = match[strlen(gl->pattern)];
365                            if (!c || (!isalnum(c) && c != '_'))
366                                goto opt_f_found;
367                        }
368                        str = match + 1;
369                        goto opt_f_again;
370                    }
371 opt_f_found:
372                    found = 1;
373 opt_f_not_found: ;
374                }
[821]375            } else {
[1765]376                if (!(gl->flg_mem_alocated_compiled & COMPILED)) {
[821]377                    gl->flg_mem_alocated_compiled |= COMPILED;
[2725]378#if !ENABLE_EXTRA_COMPAT
379                    xregcomp(&gl->compiled_regex, gl->pattern, reflags);
380#else
381                    memset(&gl->compiled_regex, 0, sizeof(gl->compiled_regex));
382                    gl->compiled_regex.translate = case_fold; /* for -i */
383                    if (re_compile_pattern(gl->pattern, strlen(gl->pattern), &gl->compiled_regex))
384                        bb_error_msg_and_die("bad regex '%s'", gl->pattern);
385#endif
[821]386                }
[2725]387#if !ENABLE_EXTRA_COMPAT
388                gl->matched_range.rm_so = 0;
389                gl->matched_range.rm_eo = 0;
390#endif
391                if (
392#if !ENABLE_EXTRA_COMPAT
393                    regexec(&gl->compiled_regex, line, 1, &gl->matched_range, 0) == 0
394#else
395                    re_search(&gl->compiled_regex, line, line_len,
396                            /*start:*/ 0, /*range:*/ line_len,
397                            &gl->matched_range) >= 0
398#endif
399                ) {
[3232]400                    if (option_mask32 & OPT_x) {
401                        found = (gl->matched_range.rm_so == 0
402                                 && line[gl->matched_range.rm_eo] == '\0');
403                    } else
404                    if (!(option_mask32 & OPT_w)) {
[2725]405                        found = 1;
[3232]406                    } else {
[1765]407                        char c = ' ';
[2725]408                        if (gl->matched_range.rm_so)
409                            c = line[gl->matched_range.rm_so - 1];
[1765]410                        if (!isalnum(c) && c != '_') {
[2725]411                            c = line[gl->matched_range.rm_eo];
[1765]412                            if (!c || (!isalnum(c) && c != '_'))
[2725]413                                found = 1;
[1765]414                        }
[3232]415//BUG: "echo foop foo | grep -w foo" should match, but doesn't:
416//we bail out on first "mismatch" because it's not a word.
[1765]417                    }
418                }
[821]419            }
[2725]420            /* If it's non-inverted search, we can stop
421             * at first match */
422            if (found && !invert_search)
423                goto do_found;
[821]424            pattern_ptr = pattern_ptr->link;
425        } /* while (pattern_ptr) */
426
[2725]427        if (found ^ invert_search) {
428 do_found:
[1765]429            /* keep track of matches */
430            nmatches++;
[821]431
[1765]432            /* quiet/print (non)matching file names only? */
433            if (option_mask32 & (OPT_q|OPT_l|OPT_L)) {
434                free(line); /* we don't need line anymore */
435                if (BE_QUIET) {
436                    /* manpage says about -q:
437                     * "exit immediately with zero status
438                     * if any match is found,
439                     * even if errors were detected" */
[2725]440                    exit(EXIT_SUCCESS);
[1765]441                }
[821]442                /* if we're just printing filenames, we stop after the first match */
[1765]443                if (PRINT_FILES_WITH_MATCHES) {
444                    puts(cur_file);
[2725]445                    /* fall through to "return 1" */
[1765]446                }
447                /* OPT_L aka PRINT_FILES_WITHOUT_MATCHES: return early */
448                return 1; /* one match */
449            }
[821]450
451#if ENABLE_FEATURE_GREP_CONTEXT
[1765]452            /* Were we printing context and saw next (unwanted) match? */
453            if ((option_mask32 & OPT_m) && nmatches > max_matches)
454                break;
455#endif
[821]456
[1765]457            /* print the matched line */
458            if (PRINT_MATCH_COUNTS == 0) {
459#if ENABLE_FEATURE_GREP_CONTEXT
460                int prevpos = (curpos == 0) ? lines_before - 1 : curpos - 1;
[821]461
[1765]462                /* if we were told to print 'before' lines and there is at least
463                 * one line in the circular buffer, print them */
464                if (lines_before && before_buf[prevpos] != NULL) {
465                    int first_buf_entry_line_num = linenum - lines_before;
[821]466
[1765]467                    /* advance to the first entry in the circular buffer, and
468                     * figure out the line number is of the first line in the
469                     * buffer */
470                    idx = curpos;
471                    while (before_buf[idx] == NULL) {
472                        idx = (idx + 1) % lines_before;
473                        first_buf_entry_line_num++;
[821]474                    }
475
[1765]476                    /* now print each line in the buffer, clearing them as we go */
477                    while (before_buf[idx] != NULL) {
[2725]478                        print_line(before_buf[idx], before_buf_size[idx], first_buf_entry_line_num, '-');
[1765]479                        free(before_buf[idx]);
480                        before_buf[idx] = NULL;
481                        idx = (idx + 1) % lines_before;
482                        first_buf_entry_line_num++;
483                    }
484                }
485
486                /* make a note that we need to print 'after' lines */
487                print_n_lines_after = lines_after;
[821]488#endif
[1765]489                if (option_mask32 & OPT_o) {
[2725]490                    if (FGREP_FLAG) {
491                        /* -Fo just prints the pattern
492                         * (unless -v: -Fov doesnt print anything at all) */
493                        if (found)
494                            print_line(gl->pattern, strlen(gl->pattern), linenum, ':');
495                    } else while (1) {
496                        unsigned start = gl->matched_range.rm_so;
497                        unsigned end = gl->matched_range.rm_eo;
498                        unsigned len = end - start;
499                        char old = line[end];
500                        line[end] = '\0';
501                        /* Empty match is not printed: try "echo test | grep -o ''" */
502                        if (len != 0)
503                            print_line(line + start, len, linenum, ':');
504                        if (old == '\0')
505                            break;
506                        line[end] = old;
507                        if (len == 0)
508                            end++;
509#if !ENABLE_EXTRA_COMPAT
510                        if (regexec(&gl->compiled_regex, line + end,
511                                1, &gl->matched_range, REG_NOTBOL) != 0)
512                            break;
513                        gl->matched_range.rm_so += end;
514                        gl->matched_range.rm_eo += end;
515#else
516                        if (re_search(&gl->compiled_regex, line, line_len,
517                                end, line_len - end,
518                                &gl->matched_range) < 0)
519                            break;
520#endif
521                    }
[1765]522                } else {
[2725]523                    print_line(line, line_len, linenum, ':');
[821]524                }
525            }
[1765]526        }
[821]527#if ENABLE_FEATURE_GREP_CONTEXT
[1765]528        else { /* no match */
[821]529            /* if we need to print some context lines after the last match, do so */
[1765]530            if (print_n_lines_after) {
[2725]531                print_line(line, strlen(line), linenum, '-');
[821]532                print_n_lines_after--;
[1765]533            } else if (lines_before) {
534                /* Add the line to the circular 'before' buffer */
535                free(before_buf[curpos]);
536                before_buf[curpos] = line;
[2725]537                IF_EXTRA_COMPAT(before_buf_size[curpos] = line_len;)
[1765]538                curpos = (curpos + 1) % lines_before;
[2725]539                /* avoid free(line) - we took the line */
[1765]540                line = NULL;
[821]541            }
[1765]542        }
543
[821]544#endif /* ENABLE_FEATURE_GREP_CONTEXT */
[2725]545#if !ENABLE_EXTRA_COMPAT
[821]546        free(line);
[2725]547#endif
[1765]548        /* Did we print all context after last requested match? */
549        if ((option_mask32 & OPT_m)
[2725]550         && !print_n_lines_after
551         && nmatches == max_matches
552        ) {
[1765]553            break;
[2725]554        }
555    } /* while (read line) */
[821]556
557    /* special-case file post-processing for options where we don't print line
558     * matches, just filenames and possibly match counts */
559
560    /* grep -c: print [filename:]count, even if count is zero */
561    if (PRINT_MATCH_COUNTS) {
[1765]562        if (print_filename)
[821]563            printf("%s:", cur_file);
[1765]564        printf("%d\n", nmatches);
[821]565    }
566
[1765]567    /* grep -L: print just the filename */
568    if (PRINT_FILES_WITHOUT_MATCHES) {
569        /* nmatches is zero, no need to check it:
570         * we return 1 early if we detected a match
571         * and PRINT_FILES_WITHOUT_MATCHES is set */
[821]572        puts(cur_file);
573    }
574
575    return nmatches;
576}
577
578#if ENABLE_FEATURE_CLEAN_UP
579#define new_grep_list_data(p, m) add_grep_list_data(p, m)
[2725]580static char *add_grep_list_data(char *pattern, int flg_used_mem)
[821]581#else
582#define new_grep_list_data(p, m) add_grep_list_data(p)
[2725]583static char *add_grep_list_data(char *pattern)
[821]584#endif
585{
[2725]586    grep_list_data_t *gl = xzalloc(sizeof(*gl));
[821]587    gl->pattern = pattern;
588#if ENABLE_FEATURE_CLEAN_UP
589    gl->flg_mem_alocated_compiled = flg_used_mem;
590#else
[2725]591    /*gl->flg_mem_alocated_compiled = 0;*/
[821]592#endif
593    return (char *)gl;
594}
595
596static void load_regexes_from_file(llist_t *fopt)
597{
[1765]598    while (fopt) {
[3232]599        char *line;
600        FILE *fp;
[821]601        llist_t *cur = fopt;
602        char *ffile = cur->data;
603
604        fopt = cur->link;
605        free(cur);
[3232]606        fp = xfopen_stdin(ffile);
607        while ((line = xmalloc_fgetline(fp)) != NULL) {
[821]608            llist_add_to(&pattern_head,
[2725]609                new_grep_list_data(line, ALLOCATED));
[821]610        }
[3232]611        fclose_if_not_stdin(fp);
[821]612    }
613}
614
[2725]615static int FAST_FUNC file_action_grep(const char *filename,
616            struct stat *statbuf UNUSED_PARAM,
617            void* matched,
618            int depth UNUSED_PARAM)
[1765]619{
[2725]620    FILE *file = fopen_for_read(filename);
[1765]621    if (file == NULL) {
622        if (!SUPPRESS_ERR_MSGS)
[2725]623            bb_simple_perror_msg(filename);
[1765]624        open_errors = 1;
625        return 0;
626    }
627    cur_file = filename;
628    *(int*)matched += grep_file(file);
629    fclose(file);
630    return 1;
631}
[821]632
[1765]633static int grep_dir(const char *dir)
634{
635    int matched = 0;
636    recursive_action(dir,
637        /* recurse=yes */ ACTION_RECURSE |
638        /* followLinks=no */
639        /* depthFirst=yes */ ACTION_DEPTHFIRST,
640        /* fileAction= */ file_action_grep,
641        /* dirAction= */ NULL,
642        /* userData= */ &matched,
643        /* depth= */ 0);
644    return matched;
645}
646
[2725]647int grep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
648int grep_main(int argc UNUSED_PARAM, char **argv)
[821]649{
650    FILE *file;
651    int matched;
652    llist_t *fopt = NULL;
653
654    /* do normal option parsing */
655#if ENABLE_FEATURE_GREP_CONTEXT
[2725]656    int Copt, opts;
[821]657
[2725]658    /* -H unsets -h; -C unsets -A,-B; -e,-f are lists;
659     * -m,-A,-B,-C have numeric param */
660    opt_complementary = "H-h:C-AB:e::f::m+:A+:B+:C+";
661    opts = getopt32(argv,
[1765]662        OPTSTR_GREP,
[2725]663        &pattern_head, &fopt, &max_matches,
664        &lines_after, &lines_before, &Copt);
[821]665
[2725]666    if (opts & OPT_C) {
[1765]667        /* -C unsets prev -A and -B, but following -A or -B
[3232]668         * may override it */
[2725]669        if (!(opts & OPT_A)) /* not overridden */
670            lines_after = Copt;
671        if (!(opts & OPT_B)) /* not overridden */
672            lines_before = Copt;
[821]673    }
[1765]674    /* sanity checks */
[2725]675    if (opts & (OPT_c|OPT_q|OPT_l|OPT_L)) {
[1765]676        option_mask32 &= ~OPT_n;
[821]677        lines_before = 0;
678        lines_after = 0;
[2725]679    } else if (lines_before > 0) {
680        if (lines_before > INT_MAX / sizeof(long long))
681            lines_before = INT_MAX / sizeof(long long);
682        /* overflow in (lines_before * sizeof(x)) is prevented (above) */
683        before_buf = xzalloc(lines_before * sizeof(before_buf[0]));
684        IF_EXTRA_COMPAT(before_buf_size = xzalloc(lines_before * sizeof(before_buf_size[0]));)
685    }
[821]686#else
687    /* with auto sanity checks */
[2725]688    /* -H unsets -h; -c,-q or -l unset -n; -e,-f are lists; -m N */
689    opt_complementary = "H-h:c-n:q-n:l-n:e::f::m+";
[1765]690    getopt32(argv, OPTSTR_GREP,
[2725]691        &pattern_head, &fopt, &max_matches);
[821]692#endif
[1765]693    invert_search = ((option_mask32 & OPT_v) != 0); /* 0 | 1 */
[821]694
[3232]695    {   /* convert char **argv to grep_list_data_t */
[821]696        llist_t *cur;
[1765]697        for (cur = pattern_head; cur; cur = cur->link)
[821]698            cur->data = new_grep_list_data(cur->data, 0);
699    }
[3232]700    if (option_mask32 & OPT_f) {
[821]701        load_regexes_from_file(fopt);
[3232]702        if (!pattern_head) { /* -f EMPTY_FILE? */
703            /* GNU grep treats it as "nothing matches" */
704            llist_add_to(&pattern_head, new_grep_list_data((char*) "", 0));
705            invert_search ^= 1;
706        }
707    }
[821]708
[1765]709    if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f')
710        option_mask32 |= OPT_F;
[821]711
[2725]712#if !ENABLE_EXTRA_COMPAT
[1765]713    if (!(option_mask32 & (OPT_o | OPT_w)))
[821]714        reflags = REG_NOSUB;
[2725]715#endif
[821]716
[2725]717    if (ENABLE_FEATURE_GREP_EGREP_ALIAS
718     && (applet_name[0] == 'e' || (option_mask32 & OPT_E))
719    ) {
[1765]720        reflags |= REG_EXTENDED;
[2725]721    }
722#if ENABLE_EXTRA_COMPAT
723    else {
724        reflags = RE_SYNTAX_GREP;
725    }
726#endif
[1765]727
[2725]728    if (option_mask32 & OPT_i) {
729#if !ENABLE_EXTRA_COMPAT
[821]730        reflags |= REG_ICASE;
[2725]731#else
732        int i;
733        case_fold = xmalloc(256);
734        for (i = 0; i < 256; i++)
735            case_fold[i] = (unsigned char)i;
736        for (i = 'a'; i <= 'z'; i++)
737            case_fold[i] = (unsigned char)(i - ('a' - 'A'));
738#endif
739    }
[821]740
741    argv += optind;
742
[2725]743    /* if we didn't get a pattern from -e and no command file was specified,
744     * first parameter should be the pattern. no pattern, no worky */
[821]745    if (pattern_head == NULL) {
[1765]746        char *pattern;
[821]747        if (*argv == NULL)
748            bb_show_usage();
[1765]749        pattern = new_grep_list_data(*argv++, 0);
750        llist_add_to(&pattern_head, pattern);
[821]751    }
752
[2725]753    /* argv[0..(argc-1)] should be names of file to grep through. If
[1765]754     * there is more than one file to grep, we will print the filenames. */
[2725]755    if (argv[0] && argv[1])
[1765]756        print_filename = 1;
757    /* -H / -h of course override */
758    if (option_mask32 & OPT_H)
759        print_filename = 1;
760    if (option_mask32 & OPT_h)
761        print_filename = 0;
[821]762
763    /* If no files were specified, or '-' was specified, take input from
764     * stdin. Otherwise, we grep through all the files specified. */
765    matched = 0;
[2725]766    do {
767        cur_file = *argv;
[1765]768        file = stdin;
[2725]769        if (!cur_file || LONE_DASH(cur_file)) {
[821]770            cur_file = "(standard input)";
771        } else {
[1765]772            if (option_mask32 & OPT_r) {
773                struct stat st;
774                if (stat(cur_file, &st) == 0 && S_ISDIR(st.st_mode)) {
775                    if (!(option_mask32 & OPT_h))
776                        print_filename = 1;
777                    matched += grep_dir(cur_file);
778                    goto grep_done;
779                }
780            }
781            /* else: fopen(dir) will succeed, but reading won't */
[2725]782            file = fopen_for_read(cur_file);
[1765]783            if (file == NULL) {
784                if (!SUPPRESS_ERR_MSGS)
[2725]785                    bb_simple_perror_msg(cur_file);
[1765]786                open_errors = 1;
787                continue;
[821]788            }
789        }
[1765]790        matched += grep_file(file);
791        fclose_if_not_stdin(file);
792 grep_done: ;
[2725]793    } while (*argv && *++argv);
[821]794
795    /* destroy all the elments in the pattern list */
796    if (ENABLE_FEATURE_CLEAN_UP) {
797        while (pattern_head) {
798            llist_t *pattern_head_ptr = pattern_head;
[2725]799            grep_list_data_t *gl = (grep_list_data_t *)pattern_head_ptr->data;
[821]800
801            pattern_head = pattern_head->link;
[2725]802            if (gl->flg_mem_alocated_compiled & ALLOCATED)
[821]803                free(gl->pattern);
[2725]804            if (gl->flg_mem_alocated_compiled & COMPILED)
805                regfree(&gl->compiled_regex);
[1765]806            free(gl);
[821]807            free(pattern_head_ptr);
808        }
809    }
810    /* 0 = success, 1 = failed, 2 = error */
[1765]811    if (open_errors)
[821]812        return 2;
[2725]813    return !matched; /* invert return value: 0 = success, 1 = failed */
[821]814}
Note: See TracBrowser for help on using the repository browser.