findutils/grep.c

   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.  */
  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 /*
  19  * (C) 2006 Jac Goudsmit added -o option
  20  */
  21
  22 #include "busybox.h"
  23 #include "xregex.h"
  24
  25
  26 /* options */
  27 #define GREP_OPTS "lnqvscFiHhe:f:Lor"
  28 #define GREP_OPT_l (1<<0)
  29 #define PRINT_FILES_WITH_MATCHES (option_mask32 & GREP_OPT_l)
  30 #define GREP_OPT_n (1<<1)
  31 #define PRINT_LINE_NUM (option_mask32 & GREP_OPT_n)
  32 #define GREP_OPT_q (1<<2)
  33 #define BE_QUIET (option_mask32 & GREP_OPT_q)
  34 #define GREP_OPT_v (1<<3)
  35 #define GREP_OPT_s (1<<4)
  36 #define SUPPRESS_ERR_MSGS (option_mask32 & GREP_OPT_s)
  37 #define GREP_OPT_c (1<<5)
  38 #define PRINT_MATCH_COUNTS (option_mask32 & GREP_OPT_c)
  39 #define GREP_OPT_F (1<<6)
  40 #define FGREP_FLAG (option_mask32 & GREP_OPT_F)
  41 #define GREP_OPT_i (1<<7)
  42 #define GREP_OPT_H (1<<8)
  43 #define GREP_OPT_h (1<<9)
  44 #define GREP_OPT_e (1<<10)
  45 #define GREP_OPT_f (1<<11)
  46 #define GREP_OPT_L (1<<12)
  47 #define PRINT_FILES_WITHOUT_MATCHES (option_mask32 & GREP_OPT_L)
  48 #define GREP_OPT_o (1<<13)
  49 #define GREP_OPT_r (1<<14)
  50 #if ENABLE_FEATURE_GREP_CONTEXT
  51 # define GREP_OPT_CONTEXT "A:B:C:"
  52 # define GREP_OPT_A (1<<15)
  53 # define GREP_OPT_B (1<<16)
  54 # define GREP_OPT_C (1<<17)
  55 # define GREP_OPT_E (1<<18)
  56 #else
  57 # define GREP_OPT_CONTEXT ""
  58 # define GREP_OPT_A 0
  59 # define GREP_OPT_B 0
  60 # define GREP_OPT_C 0
  61 # define GREP_OPT_E (1<<15)
  62 #endif
  63 #if ENABLE_FEATURE_GREP_EGREP_ALIAS
  64 # define OPT_EGREP "E"
  65 #else
  66 # define OPT_EGREP ""
  67 #endif
  68
  69 typedef unsigned char byte_t;
  70
  71 static int reflags;
  72 static byte_t invert_search;
  73 static byte_t print_filename;
  74 static byte_t open_errors;
  75
  76 #if ENABLE_FEATURE_GREP_CONTEXT
  77 static int lines_before;
  78 static int lines_after;
  79 static char **before_buf;
  80 static int last_line_printed;
  81 #endif /* ENABLE_FEATURE_GREP_CONTEXT */
  82
  83 /* globals used internally */
  84 static llist_t *pattern_head;   /* growable list of patterns to match */
  85 static const char *cur_file;    /* the current file we are reading */
  86
  87 typedef struct GREP_LIST_DATA {
  88         char *pattern;
  89         regex_t preg;
  90 #define PATTERN_MEM_A 1
  91 #define COMPILED 2
  92         int flg_mem_alocated_compiled;
  93 } grep_list_data_t;
  94
  95 static void print_line(const char *line, int linenum, char decoration)
  96 {
  97 #if ENABLE_FEATURE_GREP_CONTEXT
  98         /* possibly print the little '--' separator */
  99         if ((lines_before || lines_after) && last_line_printed &&
 100                         last_line_printed < linenum - 1) {
 101                 puts("--");
 102         }
 103         last_line_printed = linenum;
 104 #endif
 105         if (print_filename)
 106                 printf("%s%c", cur_file, decoration);
 107         if (PRINT_LINE_NUM)
 108                 printf("%i%c", linenum, decoration);
 109         /* Emulate weird GNU grep behavior with -ov */
 110         if ((option_mask32 & (GREP_OPT_v+GREP_OPT_o)) != (GREP_OPT_v+GREP_OPT_o))
 111                 puts(line);
 112 }
 113
 114
 115 static int grep_file(FILE *file)
 116 {
 117         char *line;
 118         byte_t ret;
 119         int linenum = 0;
 120         int nmatches = 0;
 121         regmatch_t regmatch;
 122 #if ENABLE_FEATURE_GREP_CONTEXT
 123         int print_n_lines_after = 0;
 124         int curpos = 0; /* track where we are in the circular 'before' buffer */
 125         int idx = 0; /* used for iteration through the circular buffer */
 126 #endif /* ENABLE_FEATURE_GREP_CONTEXT */
 127
 128         while ((line = xmalloc_getline(file)) != NULL) {
 129                 llist_t *pattern_ptr = pattern_head;
 130                 grep_list_data_t * gl;
 131
 132                 linenum++;
 133                 ret = 0;
 134                 while (pattern_ptr) {
 135                         gl = (grep_list_data_t *)pattern_ptr->data;
 136                         if (FGREP_FLAG) {
 137                                 ret = strstr(line, gl->pattern) != NULL;
 138                         } else {
 139                                 /*
 140                                  * test for a postitive-assertion match (regexec returns success (0)
 141                                  * and the user did not specify invert search), or a negative-assertion
 142                                  * match (regexec returns failure (REG_NOMATCH) and the user specified
 143                                  * invert search)
 144                                  */
 145                                 if (!(gl->flg_mem_alocated_compiled & COMPILED)) {
 146                                         gl->flg_mem_alocated_compiled |= COMPILED;
 147                                         xregcomp(&(gl->preg), gl->pattern, reflags);
 148                                 }
 149                                 regmatch.rm_so = 0;
 150                                 regmatch.rm_eo = 0;
 151                                 ret |= regexec(&(gl->preg), line, 1, &regmatch, 0) == 0;
 152                         }
 153                         pattern_ptr = pattern_ptr->link;
 154                 } /* while (pattern_ptr) */
 155
 156                 if (ret ^ invert_search) {
 157
 158                         if (PRINT_FILES_WITH_MATCHES || BE_QUIET)
 159                                 free(line);
 160
 161                         /* if we found a match but were told to be quiet, stop here */
 162                         if (BE_QUIET || PRINT_FILES_WITHOUT_MATCHES)
 163                                 return -1;
 164
 165                                 /* keep track of matches */
 166                                 nmatches++;
 167
 168                                 /* if we're just printing filenames, we stop after the first match */
 169                                 if (PRINT_FILES_WITH_MATCHES)
 170                                         break;
 171
 172                                 /* print the matched line */
 173                                 if (PRINT_MATCH_COUNTS == 0) {
 174 #if ENABLE_FEATURE_GREP_CONTEXT
 175                                         int prevpos = (curpos == 0) ? lines_before - 1 : curpos - 1;
 176
 177                                         /* if we were told to print 'before' lines and there is at least
 178                                          * one line in the circular buffer, print them */
 179                                         if (lines_before && before_buf[prevpos] != NULL) {
 180                                                 int first_buf_entry_line_num = linenum - lines_before;
 181
 182                                                 /* advance to the first entry in the circular buffer, and
 183                                                  * figure out the line number is of the first line in the
 184                                                  * buffer */
 185                                                 idx = curpos;
 186                                                 while (before_buf[idx] == NULL) {
 187                                                         idx = (idx + 1) % lines_before;
 188                                                         first_buf_entry_line_num++;
 189                                                 }
 190
 191                                                 /* now print each line in the buffer, clearing them as we go */
 192                                                 while (before_buf[idx] != NULL) {
 193                                                         print_line(before_buf[idx], first_buf_entry_line_num, '-');
 194                                                         free(before_buf[idx]);
 195                                                         before_buf[idx] = NULL;
 196                                                         idx = (idx + 1) % lines_before;
 197                                                         first_buf_entry_line_num++;
 198                                                 }
 199                                         }
 200
 201                                         /* make a note that we need to print 'after' lines */
 202                                         print_n_lines_after = lines_after;
 203 #endif
 204                                         if (option_mask32 & GREP_OPT_o) {
 205                                                 line[regmatch.rm_eo] = '\0';
 206                                                 print_line(line + regmatch.rm_so, linenum, ':');
 207                                         } else {
 208                                                 print_line(line, linenum, ':');
 209                                         }
 210                                 }
 211                         }
 212 #if ENABLE_FEATURE_GREP_CONTEXT
 213                         else { /* no match */
 214                                 /* Add the line to the circular 'before' buffer */
 215                                 if (lines_before) {
 216                                         free(before_buf[curpos]);
 217                                         before_buf[curpos] = xstrdup(line);
 218                                         curpos = (curpos + 1) % lines_before;
 219                                 }
 220                         }
 221
 222                         /* if we need to print some context lines after the last match, do so */
 223                         if (print_n_lines_after && (last_line_printed != linenum)) {
 224                                 print_line(line, linenum, '-');
 225                                 print_n_lines_after--;
 226                         }
 227 #endif /* ENABLE_FEATURE_GREP_CONTEXT */
 228                 free(line);
 229         }
 230
 231         /* special-case file post-processing for options where we don't print line
 232          * matches, just filenames and possibly match counts */
 233
 234         /* grep -c: print [filename:]count, even if count is zero */
 235         if (PRINT_MATCH_COUNTS) {
 236                 if (print_filename)
 237                         printf("%s:", cur_file);
 238                 printf("%d\n", nmatches);
 239         }
 240
 241         /* grep -l: print just the filename, but only if we grepped the line in the file  */
 242         if (PRINT_FILES_WITH_MATCHES && nmatches > 0) {
 243                 puts(cur_file);
 244         }
 245
 246         /* grep -L: print just the filename, but only if we didn't grep the line in the file  */
 247         if (PRINT_FILES_WITHOUT_MATCHES && nmatches == 0) {
 248                 puts(cur_file);
 249         }
 250
 251         return nmatches;
 252 }
 253
 254 #if ENABLE_FEATURE_CLEAN_UP
 255 #define new_grep_list_data(p, m) add_grep_list_data(p, m)
 256 static char * add_grep_list_data(char *pattern, int flg_used_mem)
 257 #else
 258 #define new_grep_list_data(p, m) add_grep_list_data(p)
 259 static char * add_grep_list_data(char *pattern)
 260 #endif
 261 {
 262         grep_list_data_t *gl = xmalloc(sizeof(grep_list_data_t));
 263         gl->pattern = pattern;
 264 #if ENABLE_FEATURE_CLEAN_UP
 265         gl->flg_mem_alocated_compiled = flg_used_mem;
 266 #else
 267         gl->flg_mem_alocated_compiled = 0;
 268 #endif
 269         return (char *)gl;
 270 }
 271
 272
 273 static void load_regexes_from_file(llist_t *fopt)
 274 {
 275         char *line;
 276         FILE *f;
 277
 278         while (fopt) {
 279                 llist_t *cur = fopt;
 280                 char *ffile = cur->data;
 281
 282                 fopt = cur->link;
 283                 free(cur);
 284                 f = xfopen(ffile, "r");
 285                 while ((line = xmalloc_getline(f)) != NULL) {
 286                         llist_add_to(&pattern_head,
 287                                 new_grep_list_data(line, PATTERN_MEM_A));
 288                 }
 289         }
 290 }
 291
 292
 293 static int file_action_grep(const char *filename, struct stat *statbuf, void* matched)
 294 {
 295         FILE *file = fopen(filename, "r");
 296         if (file == NULL) {
 297                 if (!SUPPRESS_ERR_MSGS)
 298                         bb_perror_msg("%s", cur_file);
 299                 open_errors = 1;
 300                 return 0;
 301         }
 302         cur_file = filename;
 303         *(int*)matched += grep_file(file);
 304         return 1;
 305 }
 306
 307
 308 static int grep_dir(const char *dir)
 309 {
 310         int matched = 0;
 311         recursive_action(dir,
 312                 /* recurse= */ 1,
 313                 /* followLinks= */ 0,
 314                 /* depthFirst= */ 1,
 315                 /* fileAction= */ file_action_grep,
 316                 /* dirAction= */ NULL,
 317                 /* userData= */ &matched);
 318         return matched;
 319 }
 320
 321
 322 int grep_main(int argc, char **argv)
 323 {
 324         FILE *file;
 325         int matched;
 326         llist_t *fopt = NULL;
 327
 328         /* do normal option parsing */
 329 #if ENABLE_FEATURE_GREP_CONTEXT
 330         char *slines_after;
 331         char *slines_before;
 332         char *Copt;
 333
 334         opt_complementary = "H-h:e::f::C-AB";
 335         getopt32(argc, argv,
 336                 GREP_OPTS GREP_OPT_CONTEXT OPT_EGREP,
 337                 &pattern_head, &fopt,
 338                 &slines_after, &slines_before, &Copt);
 339
 340         if (option_mask32 & GREP_OPT_C) {
 341                 /* C option unseted A and B options, but next -A or -B
 342                    may be ovewrite own option */
 343                 if (!(option_mask32 & GREP_OPT_A))         /* not overwtited */
 344                         slines_after = Copt;
 345                 if (!(option_mask32 & GREP_OPT_B))         /* not overwtited */
 346                         slines_before = Copt;
 347                 option_mask32 |= GREP_OPT_A|GREP_OPT_B;   /* set for parse now */
 348         }
 349         if (option_mask32 & GREP_OPT_A) {
 350                 lines_after = xatoi_u(slines_after);
 351         }
 352         if (option_mask32 & GREP_OPT_B) {
 353                 lines_before = xatoi_u(slines_before);
 354         }
 355         /* sanity checks after parse may be invalid numbers ;-) */
 356         if (option_mask32 & (GREP_OPT_c|GREP_OPT_q|GREP_OPT_l|GREP_OPT_L)) {
 357                 option_mask32 &= ~GREP_OPT_n;
 358                 lines_before = 0;
 359                 lines_after = 0;
 360         } else if (lines_before > 0)
 361                 before_buf = (char **)xzalloc(lines_before * sizeof(char *));
 362 #else
 363         /* with auto sanity checks */
 364         opt_complementary = "H-h:e::f::c-n:q-n:l-n";
 365         getopt32(argc, argv, GREP_OPTS OPT_EGREP,
 366                 &pattern_head, &fopt);
 367 #endif
 368         invert_search = (option_mask32 & GREP_OPT_v) != 0;        /* 0 | 1 */
 369
 370         if (option_mask32 & GREP_OPT_H)
 371                 print_filename = 1;
 372         if (option_mask32 & GREP_OPT_h)
 373                 print_filename = 0;
 374         if (pattern_head != NULL) {
 375                 /* convert char *argv[] to grep_list_data_t */
 376                 llist_t *cur;
 377
 378                 for (cur = pattern_head; cur; cur = cur->link)
 379                         cur->data = new_grep_list_data(cur->data, 0);
 380         }
 381         if (option_mask32 & GREP_OPT_f)
 382                 load_regexes_from_file(fopt);
 383
 384         if (ENABLE_FEATURE_GREP_FGREP_ALIAS && applet_name[0] == 'f')
 385                 option_mask32 |= GREP_OPT_F;
 386
 387         if (!(option_mask32 & GREP_OPT_o))
 388                 reflags = REG_NOSUB;
 389
 390         if (ENABLE_FEATURE_GREP_EGREP_ALIAS &&
 391                         (applet_name[0] == 'e' || (option_mask32 & GREP_OPT_E)))
 392                 reflags |= REG_EXTENDED;
 393
 394         if (option_mask32 & GREP_OPT_i)
 395                 reflags |= REG_ICASE;
 396
 397         argv += optind;
 398         argc -= optind;
 399
 400         /* if we didn't get a pattern from a -e and no command file was specified,
 401          * argv[optind] should be the pattern. no pattern, no worky */
 402         if (pattern_head == NULL) {
 403                 if (*argv == NULL)
 404                         bb_show_usage();
 405                 else {
 406                         char *pattern = new_grep_list_data(*argv++, 0);
 407
 408                         llist_add_to(&pattern_head, pattern);
 409                         argc--;
 410                 }
 411         }
 412
 413         /* argv[(optind)..(argc-1)] should be names of file to grep through. If
 414          * there is more than one file to grep, we will print the filenames. */
 415         if (argc > 1) {
 416                 print_filename = 1;
 417
 418         /* If no files were specified, or '-' was specified, take input from
 419          * stdin. Otherwise, we grep through all the files specified. */
 420         } else if (argc == 0) {
 421                 argc++;
 422         }
 423         matched = 0;
 424         while (argc--) {
 425                 cur_file = *argv++;
 426                 file = stdin;
 427                 if (!cur_file || (*cur_file == '-' && !cur_file[1])) {
 428                         cur_file = "(standard input)";
 429                 } else {
 430                         if (option_mask32 & GREP_OPT_r) {
 431                                 struct stat st;
 432                                 if (stat(cur_file, &st) == 0 && S_ISDIR(st.st_mode)) {
 433                                         print_filename = 1;
 434                                         matched += grep_dir(cur_file);
 435                                         goto grep_done;
 436                                 }
 437                         }
 438                         /* else: fopen(dir) will succeed, but reading won't */
 439                         file = fopen(cur_file, "r");
 440                         if (file == NULL) {
 441                                 if (!SUPPRESS_ERR_MSGS)
 442                                         bb_perror_msg("%s", cur_file);
 443                                 open_errors = 1;
 444                                 continue;
 445                         }
 446                 }
 447                 matched += grep_file(file);
 448  grep_done:
 449                 if (matched < 0) {
 450                         /* we found a match but were told to be quiet, stop here and
 451                         * return success */
 452                         break;
 453                 }
 454                 bb_fclose_nonstdin(file);
 455         }
 456
 457         /* destroy all the elments in the pattern list */
 458         if (ENABLE_FEATURE_CLEAN_UP) {
 459                 while (pattern_head) {
 460                         llist_t *pattern_head_ptr = pattern_head;
 461                         grep_list_data_t *gl =
 462                                 (grep_list_data_t *)pattern_head_ptr->data;
 463
 464                         pattern_head = pattern_head->link;
 465                         if ((gl->flg_mem_alocated_compiled & PATTERN_MEM_A))
 466                                 free(gl->pattern);
 467                         if ((gl->flg_mem_alocated_compiled & COMPILED))
 468                                 regfree(&(gl->preg));
 469                         free(pattern_head_ptr);
 470                 }
 471         }
 472         /* 0 = success, 1 = failed, 2 = error */
 473         /* If the -q option is specified, the exit status shall be zero
 474          * if an input line is selected, even if an error was detected.  */
 475         if (BE_QUIET && matched)
 476                 return 0;
 477         if (open_errors)
 478                 return 2;
 479         return !matched; /* invert return value 0 = success, 1 = failed */
 480 }