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