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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 22 /* All Rights Reserved */ 23 24 25 /* 26 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 31 /* 32 * Concatenate files. 33 */ 34 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <ctype.h> 38 #include <sys/types.h> 39 #include <sys/stat.h> 40 #include <locale.h> 41 #include <unistd.h> 42 #include <sys/mman.h> 43 #include <errno.h> 44 #include <string.h> 45 46 #include <widec.h> 47 #include <wctype.h> 48 #include <limits.h> 49 #include <libintl.h> 50 #define IDENTICAL(A, B) (A.st_dev == B.st_dev && A.st_ino == B.st_ino) 51 52 #define MAXMAPSIZE (8*1024*1024) /* map at most 8MB */ 53 #define SMALLFILESIZE (32*1024) /* don't use mmap on little files */ 54 55 static int vncat(FILE *); 56 static int cat(FILE *, struct stat *, struct stat *, char *); 57 58 static int silent = 0; /* s flag */ 59 static int visi_mode = 0; /* v flag */ 60 static int visi_tab = 0; /* t flag */ 61 static int visi_newline = 0; /* e flag */ 62 static int bflg = 0; /* b flag */ 63 static int nflg = 0; /* n flag */ 64 static long ibsize; 65 static long obsize; 66 static unsigned char buf[SMALLFILESIZE]; 67 68 69 int 70 main(int argc, char **argv) 71 { 72 FILE *fi; 73 int c; 74 extern int optind; 75 int errflg = 0; 76 int stdinflg = 0; 77 int status = 0; 78 int estatus = 0; 79 struct stat source, target; 80 81 (void) setlocale(LC_ALL, ""); 82 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 83 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 84 #endif 85 (void) textdomain(TEXT_DOMAIN); 86 87 #ifdef STANDALONE 88 /* 89 * If the first argument is NULL, 90 * discard arguments until we find cat. 91 */ 92 if (argv[0][0] == '\0') 93 argc = getargv("cat", &argv, 0); 94 #endif 95 96 /* 97 * Process the options for cat. 98 */ 99 100 while ((c = getopt(argc, argv, "usvtebn")) != EOF) { 101 switch (c) { 102 103 case 'u': 104 105 /* 106 * If not standalone, set stdout to 107 * completely unbuffered I/O when 108 * the 'u' option is used. 109 */ 110 111 #ifndef STANDALONE 112 setbuf(stdout, (char *)NULL); 113 #endif 114 continue; 115 116 case 's': 117 118 /* 119 * The 's' option requests silent mode 120 * where no messages are written. 121 */ 122 123 silent++; 124 continue; 125 126 case 'v': 127 128 /* 129 * The 'v' option requests that non-printing 130 * characters (with the exception of newlines, 131 * form-feeds, and tabs) be displayed visibly. 132 * 133 * Control characters are printed as "^x". 134 * DEL characters are printed as "^?". 135 * Non-printable and non-contrlol characters with the 136 * 8th bit set are printed as "M-x". 137 */ 138 139 visi_mode++; 140 continue; 141 142 case 't': 143 144 /* 145 * When in visi_mode, this option causes tabs 146 * to be displayed as "^I". 147 */ 148 149 visi_tab++; 150 continue; 151 152 case 'e': 153 154 /* 155 * When in visi_mode, this option causes newlines 156 * and form-feeds to be displayed as "$" at the end 157 * of the line prior to the newline. 158 */ 159 160 visi_newline++; 161 continue; 162 163 case 'b': 164 165 /* 166 * Precede each line output with its line number, 167 * but omit the line numbers from blank lines. 168 */ 169 170 bflg++; 171 nflg++; 172 continue; 173 174 case 'n': 175 176 /* 177 * Precede each line output with its line number. 178 */ 179 180 nflg++; 181 continue; 182 183 case '?': 184 errflg++; 185 break; 186 } 187 break; 188 } 189 190 if (errflg) { 191 if (!silent) 192 (void) fprintf(stderr, 193 gettext("usage: cat [ -usvtebn ] [-|file] ...\n")); 194 exit(2); 195 } 196 197 /* 198 * Stat stdout to be sure it is defined. 199 */ 200 201 if (fstat(fileno(stdout), &target) < 0) { 202 if (!silent) 203 (void) fprintf(stderr, 204 gettext("cat: Cannot stat stdout\n")); 205 exit(2); 206 } 207 obsize = target.st_blksize; 208 209 /* 210 * If no arguments given, then use stdin for input. 211 */ 212 213 if (optind == argc) { 214 argc++; 215 stdinflg++; 216 } 217 218 /* 219 * Process each remaining argument, 220 * unless there is an error with stdout. 221 */ 222 223 224 for (argv = &argv[optind]; 225 optind < argc && !ferror(stdout); optind++, argv++) { 226 227 /* 228 * If the argument was '-' or there were no files 229 * specified, take the input from stdin. 230 */ 231 232 if (stdinflg || 233 ((*argv)[0] == '-' && (*argv)[1] == '\0')) 234 fi = stdin; 235 else { 236 /* 237 * Attempt to open each specified file. 238 */ 239 240 if ((fi = fopen(*argv, "r")) == NULL) { 241 if (!silent) 242 (void) fprintf(stderr, gettext( 243 "cat: cannot open %s: %s\n"), 244 *argv, strerror(errno)); 245 status = 2; 246 continue; 247 } 248 } 249 250 /* 251 * Stat source to make sure it is defined. 252 */ 253 254 if (fstat(fileno(fi), &source) < 0) { 255 if (!silent) 256 (void) fprintf(stderr, 257 gettext("cat: cannot stat %s: %s\n"), 258 (stdinflg) ? "-" : *argv, strerror(errno)); 259 status = 2; 260 continue; 261 } 262 263 264 /* 265 * If the source is not a character special file, socket or a 266 * block special file, make sure it is not identical 267 * to the target. 268 */ 269 270 if (!S_ISCHR(target.st_mode) && 271 !S_ISBLK(target.st_mode) && 272 !S_ISSOCK(target.st_mode) && 273 IDENTICAL(target, source)) { 274 if (!silent) 275 (void) fprintf(stderr, 276 gettext("cat: input/output files '%s' identical\n"), 277 stdinflg?"-": *argv); 278 if (fclose(fi) != 0) 279 (void) fprintf(stderr, 280 gettext("cat: close error: %s\n"), 281 strerror(errno)); 282 status = 2; 283 continue; 284 } 285 ibsize = source.st_blksize; 286 287 /* 288 * If in visible mode and/or nflg, use vncat; 289 * otherwise, use cat. 290 */ 291 292 if (visi_mode || nflg) 293 estatus = vncat(fi); 294 else 295 estatus = cat(fi, &source, &target, 296 fi != stdin ? *argv : "standard input"); 297 298 if (estatus) 299 status = estatus; 300 301 /* 302 * If the input is not stdin, close the source file. 303 */ 304 305 if (fi != stdin) { 306 if (fclose(fi) != 0) 307 if (!silent) 308 (void) fprintf(stderr, 309 gettext("cat: close error: %s\n"), 310 strerror(errno)); 311 } 312 } 313 314 /* 315 * Display any error with stdout operations. 316 */ 317 318 if (fclose(stdout) != 0) { 319 if (!silent) 320 perror(gettext("cat: close error")); 321 status = 2; 322 } 323 return (status); 324 } 325 326 327 328 static int 329 cat(FILE *fi, struct stat *statp, struct stat *outp, char *filenm) 330 { 331 int nitems; 332 int nwritten; 333 int offset; 334 int fi_desc; 335 long buffsize; 336 char *bufferp; 337 off_t mapsize, munmapsize; 338 off_t filesize; 339 off_t mapoffset; 340 341 fi_desc = fileno(fi); 342 if (S_ISREG(statp->st_mode) && (lseek(fi_desc, (off_t)0, SEEK_CUR) 343 == 0) && (statp->st_size > SMALLFILESIZE)) { 344 mapsize = (off_t)MAXMAPSIZE; 345 if (statp->st_size < mapsize) 346 mapsize = statp->st_size; 347 munmapsize = mapsize; 348 349 /* 350 * Mmap time! 351 */ 352 bufferp = mmap((caddr_t)NULL, (size_t)mapsize, PROT_READ, 353 MAP_SHARED, fi_desc, (off_t)0); 354 if (bufferp == (caddr_t)-1) 355 mapsize = 0; /* I guess we can't mmap today */ 356 } else 357 mapsize = 0; /* can't mmap non-regular files */ 358 359 if (mapsize != 0) { 360 int read_error = 0; 361 char x; 362 363 /* 364 * NFS V2 will let root open a file it does not have permission 365 * to read. This read() is here to make sure that the access 366 * time on the input file will be updated. The VSC tests for 367 * cat do this: 368 * cat file > /dev/null 369 * In this case the write()/mmap() pair will not read the file 370 * and the access time will not be updated. 371 */ 372 373 if (read(fi_desc, &x, 1) == -1) 374 read_error = 1; 375 mapoffset = 0; 376 filesize = statp->st_size; 377 for (;;) { 378 /* 379 * Note that on some systems (V7), very large writes to 380 * a pipe return less than the requested size of the 381 * write. In this case, multiple writes are required. 382 */ 383 offset = 0; 384 nitems = (int)mapsize; 385 do { 386 if ((nwritten = write(fileno(stdout), 387 &bufferp[offset], (size_t)nitems)) < 0) { 388 if (!silent) { 389 if (read_error == 1) 390 (void) fprintf( 391 stderr, gettext( 392 "cat: cannot read " 393 "%s: "), filenm); 394 else 395 (void) fprintf(stderr, 396 gettext( 397 "cat: write " 398 "error: ")); 399 perror(""); 400 } 401 (void) munmap(bufferp, 402 (size_t)munmapsize); 403 (void) lseek(fi_desc, (off_t)mapoffset, 404 SEEK_SET); 405 return (2); 406 } 407 offset += nwritten; 408 } while ((nitems -= nwritten) > 0); 409 410 filesize -= mapsize; 411 mapoffset += mapsize; 412 if (filesize == 0) 413 break; 414 if (filesize < mapsize) 415 mapsize = filesize; 416 if (mmap(bufferp, (size_t)mapsize, PROT_READ, 417 MAP_SHARED|MAP_FIXED, fi_desc, 418 mapoffset) == (caddr_t)-1) { 419 if (!silent) 420 perror(gettext("cat: mmap error")); 421 (void) munmap(bufferp, (size_t)munmapsize); 422 (void) lseek(fi_desc, (off_t)mapoffset, 423 SEEK_SET); 424 return (1); 425 } 426 } 427 /* 428 * Move the file pointer past what we read. Shell scripts 429 * rely on cat to do this, so that successive commands in 430 * the script won't re-read the same data. 431 */ 432 (void) lseek(fi_desc, (off_t)mapoffset, SEEK_SET); 433 (void) munmap(bufferp, (size_t)munmapsize); 434 } else { 435 if (S_ISREG(statp->st_mode) && S_ISREG(outp->st_mode)) { 436 bufferp = (char *)buf; 437 buffsize = SMALLFILESIZE; 438 } else { 439 if (obsize) 440 /* 441 * common case, use output blksize 442 */ 443 buffsize = obsize; 444 else if (ibsize) 445 buffsize = ibsize; 446 else 447 buffsize = (long)BUFSIZ; 448 449 if (buffsize <= SMALLFILESIZE) { 450 bufferp = (char *)buf; 451 } else if ((bufferp = 452 malloc((size_t)buffsize)) == NULL) { 453 perror(gettext("cat: no memory")); 454 return (1); 455 } 456 } 457 458 /* 459 * While not end of file, copy blocks to stdout. 460 */ 461 while ((nitems = read(fi_desc, bufferp, (size_t)buffsize)) > 462 0) { 463 offset = 0; 464 /* 465 * Note that on some systems (V7), very large writes 466 * to a pipe return less than the requested size of 467 * the write. In this case, multiple writes are 468 * required. 469 */ 470 do { 471 nwritten = write(1, bufferp+offset, 472 (size_t)nitems); 473 if (nwritten < 0) { 474 if (!silent) { 475 if (nwritten == -1) 476 nwritten = 0l; 477 (void) fprintf(stderr, gettext(\ 478 "cat: output error (%d/%d characters written)\n"), nwritten, nitems); 479 perror(""); 480 } 481 if (bufferp != (char *)buf) 482 free(bufferp); 483 return (2); 484 } 485 offset += nwritten; 486 } while ((nitems -= nwritten) > 0); 487 } 488 if (bufferp != (char *)buf) 489 free(bufferp); 490 if (nitems < 0) { 491 (void) fprintf(stderr, 492 gettext("cat: input error on %s: "), filenm); 493 perror(""); 494 return (1); 495 } 496 } 497 498 return (0); 499 } 500 501 static int 502 vncat(fi) 503 FILE *fi; 504 { 505 int c; 506 int lno; 507 int boln; /* = 1 if at beginning of line */ 508 /* = 0 otherwise */ 509 wchar_t wc; 510 int len, n; 511 unsigned char *p1, *p2; 512 513 lno = 1; 514 boln = 1; 515 p1 = p2 = buf; 516 for (;;) { 517 if (p1 >= p2) { 518 p1 = buf; 519 if ((len = fread(p1, 1, BUFSIZ, fi)) <= 0) 520 break; 521 p2 = p1 + len; 522 } 523 c = *p1++; 524 525 /* 526 * Display newlines as "$<newline>" 527 * if visi_newline set 528 */ 529 if (c == '\n') { 530 if (nflg && boln && !bflg) 531 (void) printf("%6d\t", lno++); 532 boln = 1; 533 534 if (visi_mode && visi_newline) 535 (void) putchar('$'); 536 (void) putchar(c); 537 continue; 538 } 539 540 if (nflg && boln) 541 (void) printf("%6d\t", lno++); 542 boln = 0; 543 544 /* 545 * For non-printable and non-cntrl chars, 546 * use the "M-x" notation. 547 */ 548 549 if (isascii(c)) { 550 if (isprint(c) || visi_mode == 0) { 551 (void) putchar(c); 552 continue; 553 } 554 555 /* 556 * For non-printable ascii characters. 557 */ 558 559 if (iscntrl(c)) { 560 /* For cntrl characters. */ 561 if ((c == '\t') || (c == '\f')) { 562 /* 563 * Display tab as "^I" if visi_tab set 564 */ 565 if (visi_mode && visi_tab) { 566 (void) putchar('^'); 567 (void) putchar(c^0100); 568 } else 569 (void) putchar(c); 570 continue; 571 } 572 (void) putchar('^'); 573 (void) putchar(c^0100); 574 continue; 575 } 576 continue; 577 } 578 579 /* 580 * For non-ascii characters. 581 */ 582 p1--; 583 if ((len = (p2 - p1)) < MB_LEN_MAX) { 584 for (n = 0; n < len; n++) 585 buf[n] = *p1++; 586 p1 = buf; 587 p2 = p1 + n; 588 if ((len = fread(p2, 1, BUFSIZ - n, fi)) > 0) 589 p2 += len; 590 } 591 592 if ((len = (p2 - p1)) > MB_LEN_MAX) 593 len = MB_LEN_MAX; 594 595 if ((len = mbtowc(&wc, (char *)p1, len)) > 0) { 596 if (iswprint(wc) || visi_mode == 0) { 597 (void) putwchar(wc); 598 p1 += len; 599 continue; 600 } 601 } 602 603 (void) putchar('M'); 604 (void) putchar('-'); 605 c -= 0200; 606 607 if (isprint(c)) { 608 (void) putchar(c); 609 } 610 611 /* For non-printable characters. */ 612 if (iscntrl(c)) { 613 /* For cntrl characters. */ 614 if ((c == '\t') || (c == '\f')) { 615 /* 616 * Display tab as "^I" if visi_tab set 617 */ 618 if (visi_mode && visi_tab) { 619 (void) putchar('^'); 620 (void) putchar(c^0100); 621 } else 622 (void) putchar(c); 623 } else { 624 (void) putchar('^'); 625 (void) putchar(c^0100); 626 } 627 } 628 p1++; 629 } 630 return (0); 631 } 632