1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* Copyright (c) 1987, 1988 Microsoft Corporation */ 31 /* All Rights Reserved */ 32 33 /* Copyright 2012 Nexenta Systems, Inc. All rights reserved. */ 34 35 /* 36 * Copyright 2013 Damian Bogel. All rights reserved. 37 */ 38 39 /* 40 * grep -- print lines matching (or not matching) a pattern 41 * 42 * status returns: 43 * 0 - ok, and some matches 44 * 1 - ok, but no matches 45 * 2 - some error 46 */ 47 48 #include <sys/types.h> 49 50 #include <ctype.h> 51 #include <fcntl.h> 52 #include <locale.h> 53 #include <memory.h> 54 #include <regexpr.h> 55 #include <stdio.h> 56 #include <stdlib.h> 57 #include <string.h> 58 #include <unistd.h> 59 #include <ftw.h> 60 #include <limits.h> 61 #include <sys/param.h> 62 63 static const char *errstr[] = { 64 "Range endpoint too large.", 65 "Bad number.", 66 "``\\digit'' out of range.", 67 "No remembered search string.", 68 "\\( \\) imbalance.", 69 "Too many \\(.", 70 "More than 2 numbers given in \\{ \\}.", 71 "} expected after \\.", 72 "First number exceeds second in \\{ \\}.", 73 "[ ] imbalance.", 74 "Regular expression overflow.", 75 "Illegal byte sequence.", 76 "Unknown regexp error code!!", 77 NULL 78 }; 79 80 #define STDIN_FILENAME gettext("(standard input)") 81 82 #define errmsg(msg, arg) (void) fprintf(stderr, gettext(msg), arg) 83 #define BLKSIZE 512 84 #define GBUFSIZ 8192 85 #define MAX_DEPTH 1000 86 87 static int temp; 88 static long long lnum; 89 static char *linebuf; 90 static char *prntbuf = NULL; 91 static long fw_lPrntBufLen = 0; 92 static int nflag; 93 static int bflag; 94 static int lflag; 95 static int cflag; 96 static int rflag; 97 static int Rflag; 98 static int vflag; 99 static int sflag; 100 static int iflag; 101 static int wflag; 102 static int hflag; 103 static int Hflag; 104 static int qflag; 105 static int errflg; 106 static int nfile; 107 static long long tln; 108 static int nsucc; 109 static int outfn = 0; 110 static int nlflag; 111 static char *ptr, *ptrend; 112 static char *expbuf; 113 114 static void execute(const char *, int); 115 static void regerr(int); 116 static void prepare(const char *); 117 static int recursive(const char *, const struct stat *, int, struct FTW *); 118 static int succeed(const char *); 119 120 int 121 main(int argc, char **argv) 122 { 123 int c; 124 char *arg; 125 extern int optind; 126 127 (void) setlocale(LC_ALL, ""); 128 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 129 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 130 #endif 131 (void) textdomain(TEXT_DOMAIN); 132 133 while ((c = getopt(argc, argv, "hHqblcnRrsviyw")) != -1) 134 switch (c) { 135 /* based on options order h or H is set as in GNU grep */ 136 case 'h': 137 hflag++; 138 Hflag = 0; /* h excludes H */ 139 break; 140 case 'H': 141 if (!lflag) /* H is excluded by l */ 142 Hflag++; 143 hflag = 0; /* H excludes h */ 144 break; 145 case 'q': /* POSIX: quiet: status only */ 146 qflag++; 147 break; 148 case 'v': 149 vflag++; 150 break; 151 case 'c': 152 cflag++; 153 break; 154 case 'n': 155 nflag++; 156 break; 157 case 'R': 158 Rflag++; 159 /* FALLTHROUGH */ 160 case 'r': 161 rflag++; 162 break; 163 case 'b': 164 bflag++; 165 break; 166 case 's': 167 sflag++; 168 break; 169 case 'l': 170 lflag++; 171 Hflag = 0; /* l excludes H */ 172 break; 173 case 'y': 174 case 'i': 175 iflag++; 176 break; 177 case 'w': 178 wflag++; 179 break; 180 case '?': 181 errflg++; 182 } 183 184 if (errflg || (optind >= argc)) { 185 errmsg("Usage: grep [-c|-l|-q] [-r|-R] -hHbnsviw " 186 "pattern file . . .\n", 187 (char *)NULL); 188 exit(2); 189 } 190 191 argv = &argv[optind]; 192 argc -= optind; 193 nfile = argc - 1; 194 195 if (strrchr(*argv, '\n') != NULL) 196 regerr(41); 197 198 if (iflag) { 199 for (arg = *argv; *arg != NULL; ++arg) 200 *arg = (char)tolower((int)((unsigned char)*arg)); 201 } 202 203 if (wflag) { 204 unsigned int wordlen; 205 char *wordbuf; 206 207 wordlen = strlen(*argv) + 5; /* '\\' '<' *argv '\\' '>' '\0' */ 208 if ((wordbuf = malloc(wordlen)) == NULL) { 209 errmsg("grep: Out of memory for word\n", (char *)NULL); 210 exit(2); 211 } 212 213 (void) strcpy(wordbuf, "\\<"); 214 (void) strcat(wordbuf, *argv); 215 (void) strcat(wordbuf, "\\>"); 216 *argv = wordbuf; 217 } 218 219 expbuf = compile(*argv, (char *)0, (char *)0); 220 if (regerrno) 221 regerr(regerrno); 222 223 if (--argc == 0) 224 execute(NULL, 0); 225 else 226 while (argc-- > 0) 227 prepare(*++argv); 228 229 return (nsucc == 2 ? 2 : (nsucc == 0 ? 1 : 0)); 230 } 231 232 static void 233 prepare(const char *path) 234 { 235 struct stat st; 236 int walkflags = FTW_CHDIR; 237 char *buf = NULL; 238 239 if (rflag) { 240 if (stat(path, &st) != -1 && 241 (st.st_mode & S_IFMT) == S_IFDIR) { 242 outfn = 1; 243 244 /* 245 * Add trailing slash if arg 246 * is directory, to resolve symlinks. 247 */ 248 if (path[strlen(path) - 1] != '/') { 249 (void) asprintf(&buf, "%s/", path); 250 if (buf != NULL) 251 path = buf; 252 } 253 254 /* 255 * Search through subdirs if path is directory. 256 * Don't follow symlinks if Rflag is not set. 257 */ 258 if (!Rflag) 259 walkflags |= FTW_PHYS; 260 261 if (nftw(path, recursive, MAX_DEPTH, walkflags) != 0) { 262 if (!sflag) 263 errmsg("grep: can't open %s\n", path); 264 nsucc = 2; 265 } 266 return; 267 } 268 } 269 execute(path, 0); 270 } 271 272 static int 273 recursive(const char *name, const struct stat *statp, int info, struct FTW *ftw) 274 { 275 /* 276 * process files and follow symlinks if Rflag set. 277 */ 278 if (info != FTW_F) { 279 if (!sflag && 280 (info == FTW_SLN || info == FTW_DNR || info == FTW_NS)) { 281 /* report broken symlinks and unreadable files */ 282 errmsg("grep: can't open %s\n", name); 283 } 284 return (0); 285 } 286 287 /* skip devices and pipes if Rflag is not set */ 288 if (!Rflag && !S_ISREG(statp->st_mode)) 289 return (0); 290 291 /* pass offset to relative name from FTW_CHDIR */ 292 execute(name, ftw->base); 293 return (0); 294 } 295 296 static void 297 execute(const char *file, int base) 298 { 299 char *lbuf, *p; 300 long count; 301 long offset = 0; 302 char *next_ptr = NULL; 303 long next_count = 0; 304 305 tln = 0; 306 307 if (prntbuf == NULL) { 308 fw_lPrntBufLen = GBUFSIZ + 1; 309 if ((prntbuf = malloc(fw_lPrntBufLen)) == NULL) { 310 exit(2); /* out of memory - BAIL */ 311 } 312 if ((linebuf = malloc(fw_lPrntBufLen)) == NULL) { 313 exit(2); /* out of memory - BAIL */ 314 } 315 } 316 317 if (file == NULL) { 318 temp = 0; 319 file = STDIN_FILENAME; 320 } else if ((temp = open(file + base, O_RDONLY)) == -1) { 321 if (!sflag) 322 errmsg("grep: can't open %s\n", file); 323 nsucc = 2; 324 return; 325 } 326 327 /* read in first block of bytes */ 328 if ((count = read(temp, prntbuf, GBUFSIZ)) <= 0) { 329 (void) close(temp); 330 331 if (cflag && !qflag) { 332 if (Hflag || (nfile > 1 && !hflag)) 333 (void) fprintf(stdout, "%s:", file); 334 if (!rflag) 335 (void) fprintf(stdout, "%lld\n", tln); 336 } 337 return; 338 } 339 340 lnum = 0; 341 ptr = prntbuf; 342 for (;;) { 343 /* look for next newline */ 344 if ((ptrend = memchr(ptr + offset, '\n', count)) == NULL) { 345 offset += count; 346 347 /* 348 * shift unused data to the beginning of the buffer 349 */ 350 if (ptr > prntbuf) { 351 (void) memmove(prntbuf, ptr, offset); 352 ptr = prntbuf; 353 } 354 355 /* 356 * re-allocate a larger buffer if this one is full 357 */ 358 if (offset + GBUFSIZ > fw_lPrntBufLen) { 359 /* 360 * allocate a new buffer and preserve the 361 * contents... 362 */ 363 fw_lPrntBufLen += GBUFSIZ; 364 if ((prntbuf = realloc(prntbuf, 365 fw_lPrntBufLen)) == NULL) 366 exit(2); 367 368 /* 369 * set up a bigger linebuffer (this is only used 370 * for case insensitive operations). Contents do 371 * not have to be preserved. 372 */ 373 free(linebuf); 374 if ((linebuf = malloc(fw_lPrntBufLen)) == NULL) 375 exit(2); 376 377 ptr = prntbuf; 378 } 379 380 p = prntbuf + offset; 381 if ((count = read(temp, p, GBUFSIZ)) > 0) 382 continue; 383 384 if (offset == 0) 385 /* end of file already reached */ 386 break; 387 388 /* last line of file has no newline */ 389 ptrend = ptr + offset; 390 nlflag = 0; 391 } else { 392 next_ptr = ptrend + 1; 393 next_count = offset + count - (next_ptr - ptr); 394 nlflag = 1; 395 } 396 lnum++; 397 *ptrend = '\0'; 398 399 if (iflag) { 400 /* 401 * Make a lower case copy of the record 402 */ 403 p = ptr; 404 for (lbuf = linebuf; p < ptrend; ) 405 *lbuf++ = (char)tolower((int) 406 (unsigned char)*p++); 407 *lbuf = '\0'; 408 lbuf = linebuf; 409 } else 410 /* 411 * Use record as is 412 */ 413 lbuf = ptr; 414 415 /* lflag only once */ 416 if ((step(lbuf, expbuf) ^ vflag) && succeed(file) == 1) 417 break; 418 419 if (!nlflag) 420 break; 421 422 ptr = next_ptr; 423 count = next_count; 424 offset = 0; 425 } 426 (void) close(temp); 427 428 if (cflag && !qflag) { 429 if (Hflag || (!hflag && ((nfile > 1) || 430 (rflag && outfn)))) 431 (void) fprintf(stdout, "%s:", file); 432 (void) fprintf(stdout, "%lld\n", tln); 433 } 434 } 435 436 static int 437 succeed(const char *f) 438 { 439 int nchars; 440 nsucc = (nsucc == 2) ? 2 : 1; 441 442 if (qflag) { 443 /* no need to continue */ 444 return (1); 445 } 446 447 if (cflag) { 448 tln++; 449 return (0); 450 } 451 452 if (lflag) { 453 (void) fprintf(stdout, "%s\n", f); 454 return (1); 455 } 456 457 if (Hflag || (!hflag && (nfile > 1 || (rflag && outfn)))) { 458 /* print filename */ 459 (void) fprintf(stdout, "%s:", f); 460 } 461 462 if (bflag) 463 /* print block number */ 464 (void) fprintf(stdout, "%lld:", (offset_t) 465 ((lseek(temp, (off_t)0, SEEK_CUR) - 1) / BLKSIZE)); 466 467 if (nflag) 468 /* print line number */ 469 (void) fprintf(stdout, "%lld:", lnum); 470 471 if (nlflag) { 472 /* newline at end of line */ 473 *ptrend = '\n'; 474 nchars = ptrend - ptr + 1; 475 } else { 476 /* don't write sentinel \0 */ 477 nchars = ptrend - ptr; 478 } 479 480 (void) fwrite(ptr, 1, nchars, stdout); 481 return (0); 482 } 483 484 static void 485 regerr(int err) 486 { 487 errmsg("grep: RE error %d: ", err); 488 switch (err) { 489 case 11: 490 err = 0; 491 break; 492 case 16: 493 err = 1; 494 break; 495 case 25: 496 err = 2; 497 break; 498 case 41: 499 err = 3; 500 break; 501 case 42: 502 err = 4; 503 break; 504 case 43: 505 err = 5; 506 break; 507 case 44: 508 err = 6; 509 break; 510 case 45: 511 err = 7; 512 break; 513 case 46: 514 err = 8; 515 break; 516 case 49: 517 err = 9; 518 break; 519 case 50: 520 err = 10; 521 break; 522 case 67: 523 err = 11; 524 break; 525 default: 526 err = 12; 527 break; 528 } 529 530 errmsg("%s\n", gettext(errstr[err])); 531 exit(2); 532 }