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

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