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

Last change on this file since 3232 was 3232, checked in by bruno, 5 years ago
  • Update mindi-busybox to 1.21.1
File size: 24.2 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:     "\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"
88//usage:     "\n    -x  Match whole lines 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:wx" \
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    OPTBIT_x, /* -x whole line match */
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 */
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,
164    OPT_w = 1 << OPTBIT_w,
165    OPT_x = 1 << OPTBIT_x,
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,
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)
180#define NUL_DELIMITED               (option_mask32 & OPT_z)
181
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            )
236
237
238typedef struct grep_list_data_t {
239    char *pattern;
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
249#define COMPILED 2
250    int flg_mem_alocated_compiled;
251} grep_list_data_t;
252
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)
258{
259#if ENABLE_FEATURE_GREP_CONTEXT
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;
264    /* possibly print the little '--' separator */
265    if ((lines_before || lines_after) && did_print_line
266     && last_line_printed != linenum - 1
267    ) {
268        puts("--");
269    }
270    /* guard against printing "--" before first line of first file */
271    did_print_line = 1;
272    last_line_printed = linenum;
273#endif
274    if (print_filename)
275        printf("%s%c", cur_file, decoration);
276    if (PRINT_LINE_NUM)
277        printf("%i%c", linenum, decoration);
278    /* Emulate weird GNU grep behavior with -ov */
279    if ((option_mask32 & (OPT_v|OPT_o)) != (OPT_v|OPT_o)) {
280#if !ENABLE_EXTRA_COMPAT
281        puts(line);
282#else
283        fwrite(line, 1, line_len, stdout);
284        putchar(NUL_DELIMITED ? '\0' : '\n');
285#endif
286    }
287}
288
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
310static int grep_file(FILE *file)
311{
312    smalluint found;
313    int linenum = 0;
314    int nmatches = 0;
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
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 */
328#else
329    enum { print_n_lines_after = 0 };
330#endif
331
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    ) {
339        llist_t *pattern_ptr = pattern_head;
340        grep_list_data_t *gl = gl; /* for gcc */
341
342        linenum++;
343        found = 0;
344        while (pattern_ptr) {
345            gl = (grep_list_data_t *)pattern_ptr->data;
346            if (FGREP_FLAG) {
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                }
375            } else {
376                if (!(gl->flg_mem_alocated_compiled & COMPILED)) {
377                    gl->flg_mem_alocated_compiled |= COMPILED;
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
386                }
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                ) {
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)) {
405                        found = 1;
406                    } else {
407                        char c = ' ';
408                        if (gl->matched_range.rm_so)
409                            c = line[gl->matched_range.rm_so - 1];
410                        if (!isalnum(c) && c != '_') {
411                            c = line[gl->matched_range.rm_eo];
412                            if (!c || (!isalnum(c) && c != '_'))
413                                found = 1;
414                        }
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.
417                    }
418                }
419            }
420            /* If it's non-inverted search, we can stop
421             * at first match */
422            if (found && !invert_search)
423                goto do_found;
424            pattern_ptr = pattern_ptr->link;
425        } /* while (pattern_ptr) */
426
427        if (found ^ invert_search) {
428 do_found:
429            /* keep track of matches */
430            nmatches++;
431
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" */
440                    exit(EXIT_SUCCESS);
441                }
442                /* if we're just printing filenames, we stop after the first match */
443                if (PRINT_FILES_WITH_MATCHES) {
444                    puts(cur_file);
445                    /* fall through to "return 1" */
446                }
447                /* OPT_L aka PRINT_FILES_WITHOUT_MATCHES: return early */
448                return 1; /* one match */
449            }
450
451#if ENABLE_FEATURE_GREP_CONTEXT
452            /* Were we printing context and saw next (unwanted) match? */
453            if ((option_mask32 & OPT_m) && nmatches > max_matches)
454                break;
455#endif
456
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;
461
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;
466
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++;
474                    }
475
476                    /* now print each line in the buffer, clearing them as we go */
477                    while (before_buf[idx] != NULL) {
478                        print_line(before_buf[idx], before_buf_size[idx], first_buf_entry_line_num, '-');
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;
488#endif
489                if (option_mask32 & OPT_o) {
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                    }
522                } else {
523                    print_line(line, line_len, linenum, ':');
524                }
525            }
526        }
527#if ENABLE_FEATURE_GREP_CONTEXT
528        else { /* no match */
529            /* if we need to print some context lines after the last match, do so */
530            if (print_n_lines_after) {
531                print_line(line, strlen(line), linenum, '-');
532                print_n_lines_after--;
533            } else if (lines_before) {
534                /* Add the line to the circular 'before' buffer */
535                free(before_buf[curpos]);
536                before_buf[curpos] = line;
537                IF_EXTRA_COMPAT(before_buf_size[curpos] = line_len;)
538                curpos = (curpos + 1) % lines_before;
539                /* avoid free(line) - we took the line */
540                line = NULL;
541            }
542        }
543
544#endif /* ENABLE_FEATURE_GREP_CONTEXT */
545#if !ENABLE_EXTRA_COMPAT
546        free(line);
547#endif
548        /* Did we print all context after last requested match? */
549        if ((option_mask32 & OPT_m)
550         && !print_n_lines_after
551         && nmatches == max_matches
552        ) {
553            break;
554        }
555    } /* while (read line) */
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) {
562        if (print_filename)
563            printf("%s:", cur_file);
564        printf("%d\n", nmatches);
565    }
566
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 */
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)
580static char *add_grep_list_data(char *pattern, int flg_used_mem)
581#else
582#define new_grep_list_data(p, m) add_grep_list_data(p)
583static char *add_grep_list_data(char *pattern)
584#endif
585{
586    grep_list_data_t *gl = xzalloc(sizeof(*gl));
587    gl->pattern = pattern;
588#if ENABLE_FEATURE_CLEAN_UP
589    gl->flg_mem_alocated_compiled = flg_used_mem;
590#else
591    /*gl->flg_mem_alocated_compiled = 0;*/
592#endif
593    return (char *)gl;
594}
595
596static void load_regexes_from_file(llist_t *fopt)
597{
598    while (fopt) {
599        char *line;
600        FILE *fp;
601        llist_t *cur = fopt;
602        char *ffile = cur->data;
603
604        fopt = cur->link;
605        free(cur);
606        fp = xfopen_stdin(ffile);
607        while ((line = xmalloc_fgetline(fp)) != NULL) {
608            llist_add_to(&pattern_head,
609                new_grep_list_data(line, ALLOCATED));
610        }
611        fclose_if_not_stdin(fp);
612    }
613}
614
615static int FAST_FUNC file_action_grep(const char *filename,
616            struct stat *statbuf UNUSED_PARAM,
617            void* matched,
618            int depth UNUSED_PARAM)
619{
620    FILE *file = fopen_for_read(filename);
621    if (file == NULL) {
622        if (!SUPPRESS_ERR_MSGS)
623            bb_simple_perror_msg(filename);
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}
632
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
647int grep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
648int grep_main(int argc UNUSED_PARAM, char **argv)
649{
650    FILE *file;
651    int matched;
652    llist_t *fopt = NULL;
653
654    /* do normal option parsing */
655#if ENABLE_FEATURE_GREP_CONTEXT
656    int Copt, opts;
657
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,
662        OPTSTR_GREP,
663        &pattern_head, &fopt, &max_matches,
664        &lines_after, &lines_before, &Copt);
665
666    if (opts & OPT_C) {
667        /* -C unsets prev -A and -B, but following -A or -B
668         * may override it */
669        if (!(opts & OPT_A)) /* not overridden */
670            lines_after = Copt;
671        if (!(opts & OPT_B)) /* not overridden */
672            lines_before = Copt;
673    }
674    /* sanity checks */
675    if (opts & (OPT_c|OPT_q|OPT_l|OPT_L)) {
676        option_mask32 &= ~OPT_n;
677        lines_before = 0;
678        lines_after = 0;
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    }
686#else
687    /* with auto sanity checks */
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+";
690    getopt32(argv, OPTSTR_GREP,
691        &pattern_head, &fopt, &max_matches);
692#endif
693    invert_search = ((option_mask32 & OPT_v) != 0); /* 0 | 1 */
694
695    {   /* convert char **argv to grep_list_data_t */
696        llist_t *cur;
697        for (cur = pattern_head; cur; cur = cur->link)
698            cur->data = new_grep_list_data(cur->data, 0);
699    }
700    if (option_mask32 & OPT_f) {
701        load_regexes_from_file(fopt);
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    }
708
709    if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f')
710        option_mask32 |= OPT_F;
711
712#if !ENABLE_EXTRA_COMPAT
713    if (!(option_mask32 & (OPT_o | OPT_w)))
714        reflags = REG_NOSUB;
715#endif
716
717    if (ENABLE_FEATURE_GREP_EGREP_ALIAS
718     && (applet_name[0] == 'e' || (option_mask32 & OPT_E))
719    ) {
720        reflags |= REG_EXTENDED;
721    }
722#if ENABLE_EXTRA_COMPAT
723    else {
724        reflags = RE_SYNTAX_GREP;
725    }
726#endif
727
728    if (option_mask32 & OPT_i) {
729#if !ENABLE_EXTRA_COMPAT
730        reflags |= REG_ICASE;
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    }
740
741    argv += optind;
742
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 */
745    if (pattern_head == NULL) {
746        char *pattern;
747        if (*argv == NULL)
748            bb_show_usage();
749        pattern = new_grep_list_data(*argv++, 0);
750        llist_add_to(&pattern_head, pattern);
751    }
752
753    /* argv[0..(argc-1)] should be names of file to grep through. If
754     * there is more than one file to grep, we will print the filenames. */
755    if (argv[0] && argv[1])
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;
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;
766    do {
767        cur_file = *argv;
768        file = stdin;
769        if (!cur_file || LONE_DASH(cur_file)) {
770            cur_file = "(standard input)";
771        } else {
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 */
782            file = fopen_for_read(cur_file);
783            if (file == NULL) {
784                if (!SUPPRESS_ERR_MSGS)
785                    bb_simple_perror_msg(cur_file);
786                open_errors = 1;
787                continue;
788            }
789        }
790        matched += grep_file(file);
791        fclose_if_not_stdin(file);
792 grep_done: ;
793    } while (*argv && *++argv);
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;
799            grep_list_data_t *gl = (grep_list_data_t *)pattern_head_ptr->data;
800
801            pattern_head = pattern_head->link;
802            if (gl->flg_mem_alocated_compiled & ALLOCATED)
803                free(gl->pattern);
804            if (gl->flg_mem_alocated_compiled & COMPILED)
805                regfree(&gl->compiled_regex);
806            free(gl);
807            free(pattern_head_ptr);
808        }
809    }
810    /* 0 = success, 1 = failed, 2 = error */
811    if (open_errors)
812        return 2;
813    return !matched; /* invert return value: 0 = success, 1 = failed */
814}
Note: See TracBrowser for help on using the repository browser.