diff --git a/usr.bin/tail/tail.c b/usr.bin/tail/tail.c index fc60a82287df..a92eee3881b4 100644 --- a/usr.bin/tail/tail.c +++ b/usr.bin/tail/tail.c @@ -1,368 +1,370 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Edward Sze-Tyan Wang. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "extern.h" int Fflag, fflag, qflag, rflag, rval, no_files, vflag; fileargs_t *fa; static void obsolete(char **); static void usage(void) __dead2; static const struct option long_opts[] = { {"blocks", required_argument, NULL, 'b'}, {"bytes", required_argument, NULL, 'c'}, {"lines", required_argument, NULL, 'n'}, {"quiet", no_argument, NULL, 'q'}, {"silent", no_argument, NULL, 'q'}, {"verbose", no_argument, NULL, 'v'}, {NULL, no_argument, NULL, 0} }; int main(int argc, char *argv[]) { struct stat sb; const char *fn; FILE *fp; off_t off; enum STYLE style; int ch, first; file_info_t file, *filep, *files; cap_rights_t rights; /* * Tail's options are weird. First, -n10 is the same as -n-10, not * -n+10. Second, the number options are 1 based and not offsets, * so -n+1 is the first line, and -c-1 is the last byte. Third, the * number options for the -r option specify the number of things that * get displayed, not the starting point in the file. The one major * incompatibility in this version as compared to historical versions * is that the 'r' option couldn't be modified by the -lbc options, * i.e. it was always done in lines. This version treats -rc as a * number of characters in reverse order. Finally, the default for * -r is the entire file, not 10 lines. */ #define ARG(units, forward, backward) { \ + int64_t num; \ if (style) \ usage(); \ - if (expand_number(optarg, &off)) \ + if (expand_number(optarg, &num)) \ err(1, "illegal offset -- %s", optarg); \ - if (off > INT64_MAX / units || off < INT64_MIN / units ) \ + if (num > INT64_MAX / units || num < INT64_MIN / units) \ errx(1, "illegal offset -- %s", optarg); \ - switch(optarg[0]) { \ + off = num * units; \ + switch (optarg[0]) { \ case '+': \ - if (off) \ + if (off != 0) \ off -= (units); \ style = (forward); \ break; \ case '-': \ off = -off; \ /* FALLTHROUGH */ \ default: \ style = (backward); \ break; \ } \ } obsolete(argv); style = NOTSET; off = 0; while ((ch = getopt_long(argc, argv, "+Fb:c:fn:qrv", long_opts, NULL)) != -1) - switch(ch) { + switch (ch) { case 'F': /* -F is superset of (and implies) -f */ Fflag = fflag = 1; break; case 'b': ARG(512, FBYTES, RBYTES); break; case 'c': ARG(1, FBYTES, RBYTES); break; case 'f': fflag = 1; break; case 'n': ARG(1, FLINES, RLINES); break; case 'q': qflag = 1; vflag = 0; break; case 'r': rflag = 1; break; case 'v': vflag = 1; qflag = 0; break; case '?': default: usage(); } argc -= optind; argv += optind; no_files = argc ? argc : 1; cap_rights_init(&rights, CAP_FSTAT, CAP_FSTATFS, CAP_FCNTL, CAP_MMAP_R); if (fflag) cap_rights_set(&rights, CAP_EVENT); if (caph_rights_limit(STDIN_FILENO, &rights) < 0 || caph_limit_stderr() < 0 || caph_limit_stdout() < 0) err(1, "unable to limit stdio rights"); fa = fileargs_init(argc, argv, O_RDONLY, 0, &rights, FA_OPEN); if (fa == NULL) err(1, "unable to init casper"); caph_cache_catpages(); if (caph_enter_casper() < 0) err(1, "unable to enter capability mode"); /* * If displaying in reverse, don't permit follow option, and convert * style values. */ if (rflag) { if (fflag) usage(); if (style == FBYTES) style = RBYTES; else if (style == FLINES) style = RLINES; } /* * If style not specified, the default is the whole file for -r, and * the last 10 lines if not -r. */ if (style == NOTSET) { if (rflag) { off = 0; style = REVERSE; } else { off = 10; style = RLINES; } } if (*argv && fflag) { files = malloc(no_files * sizeof(struct file_info)); if (files == NULL) err(1, "failed to allocate memory for file descriptors"); for (filep = files; (fn = *argv++); filep++) { filep->file_name = fn; filep->fp = fileargs_fopen(fa, filep->file_name, "r"); if (filep->fp == NULL || fstat(fileno(filep->fp), &filep->st)) { if (filep->fp != NULL) { fclose(filep->fp); filep->fp = NULL; } if (!Fflag || errno != ENOENT) ierr(filep->file_name); } } follow(files, style, off); free(files); } else if (*argv) { for (first = 1; (fn = *argv++);) { if ((fp = fileargs_fopen(fa, fn, "r")) == NULL || fstat(fileno(fp), &sb)) { ierr(fn); continue; } if (vflag || (qflag == 0 && argc > 1)) { printfn(fn, !first); first = 0; } if (rflag) reverse(fp, fn, style, off, &sb); else forward(fp, fn, style, off, &sb); } } else { fn = "stdin"; if (fstat(fileno(stdin), &sb)) { ierr(fn); exit(1); } /* * Determine if input is a pipe. 4.4BSD will set the SOCKET * bit in the st_mode field for pipes. Fix this then. */ if (lseek(fileno(stdin), (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE) { errno = 0; fflag = 0; /* POSIX.2 requires this. */ } if (rflag) { reverse(stdin, fn, style, off, &sb); } else if (fflag) { file.file_name = fn; file.fp = stdin; file.st = sb; follow(&file, style, off); } else { forward(stdin, fn, style, off, &sb); } } fileargs_free(fa); exit(rval); } /* * Convert the obsolete argument form into something that getopt can handle. * This means that anything of the form [+-][0-9][0-9]*[lbc][Ffr] that isn't * the option argument for a -b, -c or -n option gets converted. */ static void obsolete(char *argv[]) { char *ap, *p, *t; size_t len; char *start; while ((ap = *++argv)) { /* Return if "--" or not an option of any form. */ if (ap[0] != '-') { if (ap[0] != '+') return; } else if (ap[1] == '-') return; switch(*++ap) { /* Old-style option. */ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': /* Malloc space for dash, new option and argument. */ len = strlen(*argv); if ((start = p = malloc(len + 3)) == NULL) err(1, "failed to allocate memory"); *p++ = '-'; /* * Go to the end of the option argument. Save off any * trailing options (-3lf) and translate any trailing * output style characters. */ t = *argv + len - 1; if (*t == 'F' || *t == 'f' || *t == 'r') { *p++ = *t; *t-- = '\0'; } switch(*t) { case 'b': *p++ = 'b'; *t = '\0'; break; case 'c': *p++ = 'c'; *t = '\0'; break; case 'l': *t = '\0'; /* FALLTHROUGH */ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': *p++ = 'n'; break; default: errx(1, "illegal option -- %s", *argv); } *p++ = *argv[0]; (void)strcpy(p, ap); *argv = start; continue; /* * Options w/ arguments, skip the argument and continue * with the next option. */ case 'b': case 'c': case 'n': if (!ap[1]) ++argv; /* FALLTHROUGH */ /* Options w/o arguments, continue with the next option. */ case 'F': case 'f': case 'r': continue; /* Illegal option, return and let getopt handle it. */ default: return; } } } static void usage(void) { (void)fprintf(stderr, "usage: tail [-F | -f | -r] [-q] [-b # | -c # | -n #]" " [file ...]\n"); exit(1); } diff --git a/usr.bin/tail/tests/tail_test.sh b/usr.bin/tail/tests/tail_test.sh index 9c941f8a2c2f..74d6908f7568 100755 --- a/usr.bin/tail/tests/tail_test.sh +++ b/usr.bin/tail/tests/tail_test.sh @@ -1,451 +1,499 @@ # SPDX-License-Identifier: BSD-2-Clause # # Copyright (c) 2016 Alan Somers # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # 1. Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF # SUCH DAMAGE. # atf_test_case empty_r empty_r_head() { atf_set "descr" "Reverse an empty file" } empty_r_body() { touch infile expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_r file_r_head() { atf_set "descr" "Reverse a file" } file_r_body() { cat > infile < expectfile << HERE This is the third line This is the second line This is the first line HERE tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rn2 file_rn2_head() { atf_set "descr" "Reverse the last two lines of a file" } file_rn2_body() { cat > infile < expectfile << HERE This is the third line This is the second line HERE tail -rn2 infile > outfile tail -rn2 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } # Regression test for PR 222671 # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=222671 atf_test_case pipe_leading_newline_r pipe_leading_newline_r_head() { atf_set "descr" "Reverse a pipe whose first character is a newline" } pipe_leading_newline_r_body() { cat > expectfile << HERE 3 2 1 HERE printf '\n1\n2\n3\n' | tail -r > outfile printf '\n1\n2\n3\n' | tail -r > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rc28 file_rc28_head() { atf_set "descr" "Reverse a file and display the last 28 characters" } file_rc28_body() { cat > infile < expectfile << HERE This is the third line line HERE tail -rc28 infile > outfile tail -rc28 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case file_rc28 file_rc28_head() { atf_set "descr" "Reverse a file and display the last 28 characters" } file_rc28_body() { cat > infile < expectfile << HERE This is the third line line HERE tail -rc28 infile > outfile tail -rc28 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_r longfile_r_head() { atf_set "descr" "Reverse a long file" } longfile_r_body() { jot -w "%0511d" 1030 0 > infile jot -w "%0511d" 1030 1029 0 -1 > expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_r_enomem longfile_r_enomem_head() { atf_set "descr" "Reverse a file that's too long to store in RAM" } longfile_r_enomem_body() { # When we reverse a file that's too long for RAM, tail should drop the # first part and just print what it can. We'll check that the last # part is ok { ulimit -v 32768 || atf_skip "Can't adjust ulimit" jot -w "%01023d" 32768 0 | tail -r > outfile ; } if [ "$?" -ne 1 ]; then atf_skip "Didn't get ENOMEM. Adjust test parameters" fi # We don't know how much of the input we dropped. So just check that # the first ten lines of tail's output are the same as the last ten of # the input jot -w "%01023d" 10 32767 0 -1 > expectfile head -n 10 outfile > outtrunc diff expectfile outtrunc atf_check cmp expectfile outtrunc } atf_test_case longfile_r_longlines longfile_r_longlines_head() { atf_set "descr" "Reverse a long file with extremely long lines" } longfile_r_longlines_body() { jot -s " " -w "%07d" 18000 0 > infile jot -s " " -w "%07d" 18000 18000 >> infile jot -s " " -w "%07d" 18000 36000 >> infile jot -s " " -w "%07d" 18000 36000 > expectfile jot -s " " -w "%07d" 18000 18000 >> expectfile jot -s " " -w "%07d" 18000 0 >> expectfile tail -r infile > outfile tail -r < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rc135782 longfile_rc135782_head() { atf_set "descr" "Reverse a long file and print the last 135,782 bytes" } longfile_rc135782_body() { jot -w "%063d" 9000 0 > infile jot -w "%063d" 2121 8999 0 -1 > expectfile echo "0000000000000000000000000000000006878" >> expectfile tail -rc135782 infile > outfile tail -rc135782 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rc145782_longlines longfile_rc145782_longlines_head() { atf_set "descr" "Reverse a long file with extremely long lines and print the last 145,782 bytes" } longfile_rc145782_longlines_body() { jot -s " " -w "%07d" 18000 0 > infile jot -s " " -w "%07d" 18000 18000 >> infile jot -s " " -w "%07d" 18000 36000 >> infile jot -s " " -w "%07d" 18000 36000 > expectfile echo -n "35777 " >> expectfile jot -s " " -w "%07d" 222 35778 >> expectfile tail -rc145782 infile > outfile tail -rc145782 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case longfile_rn2500 longfile_rn2500_head() { atf_set "descr" "Reverse a long file and print the last 2,500 lines" } longfile_rn2500_body() { jot -w "%063d" 9000 0 > infile jot -w "%063d" 2500 8999 0 -1 > expectfile tail -rn2500 infile > outfile tail -rn2500 < infile > outpipe atf_check cmp expectfile outfile atf_check cmp expectfile outpipe } atf_test_case broken_pipe broken_pipe_head() { atf_set "descr" "Do not print bogus errno based output on short writes" } broken_pipe_body() { atf_check -o save:ints seq -f '%128g' 1 1000 atf_check -s ignore \ -e "inline:tail: stdout\nexit code: 1\n" \ -x '(tail -n 856 ints; echo exit code: $? >&2) | sleep 2' } atf_test_case stdin stdin_head() { atf_set "descr" "Check basic operations on standard input" } stdin_body() { seq 1 5 > infile seq 1 5 > expectfile seq 5 1 > expectfile_r tail < infile > outfile tail -r < infile > outfile_r atf_check cmp expectfile outfile atf_check cmp expectfile_r outfile_r } atf_test_case follow follow_head() { atf_set "descr" "Basic regression test for -f" } follow_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -f infile > outfile & pid=$! sleep 0.1 seq 4 5 >> infile sleep 0.1 atf_check cmp expectfile outfile atf_check kill $pid } atf_test_case follow_stdin follow_stdin_head() { atf_set "descr" "Verify that -f works with files piped to standard input" } follow_stdin_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -f < infile > outfile & pid=$! sleep 0.1 seq 4 5 >> infile sleep 0.1 atf_check cmp expectfile outfile atf_check kill $pid } atf_test_case follow_create follow_create_head() { atf_set "descr" "Verify that -F works when a file is created" } follow_create_body() { local pid rm -f infile tail -F infile > outfile & pid=$! seq 1 5 >infile sleep 2 atf_check cmp infile outfile atf_check kill $pid } atf_test_case follow_rename follow_rename_head() { atf_set "descr" "Verify that -F works when a file is replaced" } follow_rename_body() { local pid seq 1 5 > expectfile seq 1 3 > infile tail -F infile > outfile & pid=$! seq 4 5 > infile_new atf_check mv infile infile_old atf_check mv infile_new infile # tail -F polls for a new file every 1s. sleep 2 atf_check cmp expectfile outfile atf_check kill $pid } atf_test_case silent_header silent_header_head() { atf_set "descr" "Test tail(1)'s silent header feature" } silent_header_body() { jot 11 1 11 > file1 jot 11 2 12 > file2 jot 10 2 11 > expectfile jot 10 3 12 >> expectfile tail -q file1 file2 > outfile atf_check cmp outfile expectfile } atf_test_case verbose_header verbose_header_head() { atf_set "descr" "Test tail(1)'s verbose header feature" } verbose_header_body() { jot 11 1 11 > file1 echo '==> file1 <==' > expectfile jot 10 2 11 >> expectfile tail -v file1 > outfile atf_check cmp outfile expectfile } atf_test_case si_number si_number_head() { atf_set "descr" "Test tail(1)'s SI number feature" } si_number_body() { jot -b aaaaaaa 129 > file1 jot -b aaaaaaa 128 > expectfile tail -c 1k file1 > outfile atf_check cmp outfile expectfile jot 1025 1 1025 > file1 jot 1024 2 1025 > expectfile tail -n 1k file1 > outfile atf_check cmp outfile expectfile } atf_test_case no_lf_at_eof no_lf_at_eof_head() { atf_set "descr" "File does not end in newline" } no_lf_at_eof_body() { printf "a\nb\nc" >infile atf_check -o inline:"c" tail -1 infile atf_check -o inline:"b\nc" tail -2 infile atf_check -o inline:"a\nb\nc" tail -3 infile atf_check -o inline:"a\nb\nc" tail -4 infile } +atf_test_case tail_b +tail_b_head() +{ + atf_set "descr" "Test -b option" +} +tail_b_body() +{ + (jot -b a 256 ; jot -b b 256 ; jot -b c 256) >infile + (jot -b b 256 ; jot -b c 256) >outfile + # infile is 3 blocks long, outfile contains the last two + atf_check -o file:outfile tail -b +2 infile # start at the 2nd block + atf_check -o file:outfile tail -b -2 infile # 2 blocks from the end + atf_check -o file:outfile tail -b 2 infile # 2 blocks from the end +} + +atf_test_case tail_c +tail_c_head() +{ + atf_set "descr" "Test -c option" +} +tail_c_body() +{ + (jot -b a 256 ; jot -b b 256 ; jot -b c 256) >infile + (jot -b b 256 ; jot -b c 256) >outfile + # infile is 1536 bytes long, outfile contains the last 1024 + atf_check -o file:outfile tail -c +513 infile # start at the 513th byte + atf_check -o file:outfile tail -c -1024 infile # 1024 bytes from the end + atf_check -o file:outfile tail -c 1024 infile # 1024 bytes from the end +} + +atf_test_case tail_n +tail_n_head() +{ + atf_set "descr" "Test -n option" +} +tail_n_body() +{ + (jot -b a 256 ; jot -b b 256 ; jot -b c 256) >infile + (jot -b b 256 ; jot -b c 256) >outfile + # infile is 768 lines long, outfile contains the last 512 + atf_check -o file:outfile tail -n +257 infile # start at the 257th line + atf_check -o file:outfile tail -n -512 infile # 512 lines from the end + atf_check -o file:outfile tail -n 512 infile # 512 lines from the end +} + atf_init_test_cases() { atf_add_test_case empty_r atf_add_test_case file_r atf_add_test_case file_rc28 atf_add_test_case file_rn2 atf_add_test_case pipe_leading_newline_r # The longfile tests are designed to exercise behavior in r_buf(), # which operates on 128KB blocks atf_add_test_case longfile_r atf_add_test_case longfile_r_enomem atf_add_test_case longfile_r_longlines atf_add_test_case longfile_rc135782 atf_add_test_case longfile_rc145782_longlines atf_add_test_case longfile_rn2500 atf_add_test_case broken_pipe atf_add_test_case stdin atf_add_test_case follow atf_add_test_case follow_stdin atf_add_test_case follow_create atf_add_test_case follow_rename atf_add_test_case silent_header atf_add_test_case verbose_header atf_add_test_case si_number atf_add_test_case no_lf_at_eof + atf_add_test_case tail_b + atf_add_test_case tail_c + atf_add_test_case tail_n }