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 the GPL v2 or later, see the file LICENSE in this tarball. 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} 779