emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some busybox updates. See the changelog for details if you care.

Browse Source 
-Erik
This commit is contained in:
Erik Andersen
2000-01-25 18:13:53 +00:00
parent bf3a838aac
commit 3fe39dce5d
18 changed files with 966 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
coreutils/head.c
View File

@@ -61,7 +61,7 @@ head_main(int argc, char **argv)
switch (opt) {
case 'n':
tmplen = 0;
if (i++ < argc)
if (++i < argc)
tmplen = atoi(argv[i]);
if (tmplen < 1)
usage(head_usage);
@@ -105,4 +105,4 @@ head_main(int argc, char **argv)
exit(0);
}
/* $Id: head.c,v 1.5 2000/01/23 18:19:02 erik Exp $ */
/* $Id: head.c,v 1.6 2000/01/25 18:13:53 erik Exp $ */

2
coreutils/printf.c
View File

@@ -121,8 +121,6 @@
#define hextobin(c) ((c)>='a'&&(c)<='f' ? (c)-'a'+10 : (c)>='A'&&(c)<='F' ? (c)-'A'+10 : (c)-'0')
#define octtobin(c) ((c) - '0')
char *xmalloc ();
static double xstrtod __P ((char *s));
static int print_esc __P ((char *escstart));
static int print_formatted __P ((char *format, int argc, char **argv));

446
coreutils/tail.c
View File

@@ -1,3 +1,402 @@
#include "internal.h"
/* This file contains _two_ implementations of tail. One is
* a bit more full featured, but costs 6k. The other (i.e. the
* SIMPLE_TAIL one) is less capable, but is good enough for about
* 99% of the things folks want to use tail for, and only costs 2k.
*/
#ifdef BB_FEATURE_SIMPLE_TAIL
/* tail -- output the last part of file(s)
Copyright (C) 89, 90, 91, 95, 1996 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original version by Paul Rubin <phr@ocf.berkeley.edu>.
Extensions by David MacKenzie <djm@gnu.ai.mit.edu>.
tail -f for multiple files by Ian Lance Taylor <ian@airs.com>.
Rewrote the option parser, removed locales support,
and generally busyboxed, Erik Andersen <andersen@lineo.com>
Removed superfluous options and associated code ("-c", "-n", "-q").
Removed "tail -f" suport for multiple files.
Both changes by Friedrich Vedder <fwv@myrtle.lahn.de>.
*/
#include <stdio.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
#define XWRITE(fd, buffer, n_bytes) \
do { \
if (n_bytes > 0 && fwrite ((buffer), 1, (n_bytes), stdout) == 0) \
error("write error"); \
} while (0)
/* Number of items to tail. */
#define DEFAULT_N_LINES 10
/* Size of atomic reads. */
#ifndef BUFSIZ
#define BUFSIZ (512 * 8)
#endif
/* If nonzero, read from the end of one file until killed. */
static int forever;
/* If nonzero, print filename headers. */
static int print_headers;
const char tail_usage[] =
"tail [OPTION] [FILE]...\n\n"
"Print last 10 lines of each FILE to standard output.\n"
"With more than one FILE, precede each with a header giving the\n"
"file name. With no FILE, or when FILE is -, read standard input.\n\n"
"Options:\n"
"\t-n NUM\t\tPrint last NUM lines instead of first 10\n"
"\t-f\t\tOutput data as the file grows. This version\n"
"\t\t\tof 'tail -f' supports only one file at a time.\n";
static void write_header(const char *filename)
{
static int first_file = 1;
printf("%s==> %s <==\n", (first_file ? "" : "\n"), filename);
first_file = 0;
}
/* Print the last N_LINES lines from the end of file FD.
Go backward through the file, reading `BUFSIZ' bytes at a time (except
probably the first), until we hit the start of the file or have
read NUMBER newlines.
POS starts out as the length of the file (the offset of the last
byte of the file + 1).
Return 0 if successful, 1 if an error occurred. */
static int
file_lines(const char *filename, int fd, long int n_lines, off_t pos)
{
char buffer[BUFSIZ];
int bytes_read;
int i; /* Index into `buffer' for scanning. */
if (n_lines == 0)
return 0;
/* Set `bytes_read' to the size of the last, probably partial, buffer;
0 < `bytes_read' <= `BUFSIZ'. */
bytes_read = pos % BUFSIZ;
if (bytes_read == 0)
bytes_read = BUFSIZ;
/* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
reads will be on block boundaries, which might increase efficiency. */
pos -= bytes_read;
lseek(fd, pos, SEEK_SET);
bytes_read = fullRead(fd, buffer, bytes_read);
if (bytes_read == -1)
error("read error");
/* Count the incomplete line on files that don't end with a newline. */
if (bytes_read && buffer[bytes_read - 1] != '\n')
--n_lines;
do {
/* Scan backward, counting the newlines in this bufferfull. */
for (i = bytes_read - 1; i >= 0; i--) {
/* Have we counted the requested number of newlines yet? */
if (buffer[i] == '\n' && n_lines-- == 0) {
/* If this newline wasn't the last character in the buffer,
print the text after it. */
if (i != bytes_read - 1)
XWRITE(STDOUT_FILENO, &buffer[i + 1],
bytes_read - (i + 1));
return 0;
}
}
/* Not enough newlines in that bufferfull. */
if (pos == 0) {
/* Not enough lines in the file; print the entire file. */
lseek(fd, (off_t) 0, SEEK_SET);
return 0;
}
pos -= BUFSIZ;
lseek(fd, pos, SEEK_SET);
}
while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0);
if (bytes_read == -1)
error("read error");
return 0;
}
/* Print the last N_LINES lines from the end of the standard input,
open for reading as pipe FD.
Buffer the text as a linked list of LBUFFERs, adding them as needed.
Return 0 if successful, 1 if an error occured. */
static int pipe_lines(const char *filename, int fd, long int n_lines)
{
struct linebuffer {
int nbytes, nlines;
char buffer[BUFSIZ];
struct linebuffer *next;
};
typedef struct linebuffer LBUFFER;
LBUFFER *first, *last, *tmp;
int i; /* Index into buffers. */
int total_lines = 0; /* Total number of newlines in all buffers. */
int errors = 0;
first = last = (LBUFFER *) xmalloc(sizeof(LBUFFER));
first->nbytes = first->nlines = 0;
first->next = NULL;
tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
/* Input is always read into a fresh buffer. */
while ((tmp->nbytes = fullRead(fd, tmp->buffer, BUFSIZ)) > 0) {
tmp->nlines = 0;
tmp->next = NULL;
/* Count the number of newlines just read. */
for (i = 0; i < tmp->nbytes; i++)
if (tmp->buffer[i] == '\n')
++tmp->nlines;
total_lines += tmp->nlines;
/* If there is enough room in the last buffer read, just append the new
one to it. This is because when reading from a pipe, `nbytes' can
often be very small. */
if (tmp->nbytes + last->nbytes < BUFSIZ) {
memcpy(&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
last->nbytes += tmp->nbytes;
last->nlines += tmp->nlines;
} else {
/* If there's not enough room, link the new buffer onto the end of
the list, then either free up the oldest buffer for the next
read if that would leave enough lines, or else malloc a new one.
Some compaction mechanism is possible but probably not
worthwhile. */
last = last->next = tmp;
if (total_lines - first->nlines > n_lines) {
tmp = first;
total_lines -= first->nlines;
first = first->next;
} else
tmp = (LBUFFER *) xmalloc(sizeof(LBUFFER));
}
}
if (tmp->nbytes == -1)
error("read error");
free((char *) tmp);
/* This prevents a core dump when the pipe contains no newlines. */
if (n_lines == 0)
goto free_lbuffers;
/* Count the incomplete line on files that don't end with a newline. */
if (last->buffer[last->nbytes - 1] != '\n') {
++last->nlines;
++total_lines;
}
/* Run through the list, printing lines. First, skip over unneeded
buffers. */
for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
total_lines -= tmp->nlines;
/* Find the correct beginning, then print the rest of the file. */
if (total_lines > n_lines) {
char *cp;
/* Skip `total_lines' - `n_lines' newlines. We made sure that
`total_lines' - `n_lines' <= `tmp->nlines'. */
cp = tmp->buffer;
for (i = total_lines - n_lines; i; --i)
while (*cp++ != '\n')
/* Do nothing. */ ;
i = cp - tmp->buffer;
} else
i = 0;
XWRITE(STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
for (tmp = tmp->next; tmp; tmp = tmp->next)
XWRITE(STDOUT_FILENO, tmp->buffer, tmp->nbytes);
free_lbuffers:
while (first) {
tmp = first->next;
free((char *) first);
first = tmp;
}
return errors;
}
/* Display file FILENAME from the current position in FD to the end.
If `forever' is nonzero, keep reading from the end of the file
until killed. Return the number of bytes read from the file. */
static long dump_remainder(const char *filename, int fd)
{
char buffer[BUFSIZ];
int bytes_read;
long total;
total = 0;
output:
while ((bytes_read = fullRead(fd, buffer, BUFSIZ)) > 0) {
XWRITE(STDOUT_FILENO, buffer, bytes_read);
total += bytes_read;
}
if (bytes_read == -1)
error("read error");
if (forever) {
fflush(stdout);
sleep(1);
goto output;
}
return total;
}
/* Output the last N_LINES lines of file FILENAME open for reading in FD.
Return 0 if successful, 1 if an error occurred. */
static int tail_lines(const char *filename, int fd, long int n_lines)
{
struct stat stats;
off_t length;
if (print_headers)
write_header(filename);
if (fstat(fd, &stats))
error("fstat error");
/* Use file_lines only if FD refers to a regular file with
its file pointer positioned at beginning of file. */
/* FIXME: adding the lseek conjunct is a kludge.
Once there's a reasonable test suite, fix the true culprit:
file_lines. file_lines shouldn't presume that the input
file pointer is initially positioned to beginning of file. */
if (S_ISREG(stats.st_mode)
&& lseek(fd, (off_t) 0, SEEK_CUR) == (off_t) 0) {
length = lseek(fd, (off_t) 0, SEEK_END);
if (length != 0 && file_lines(filename, fd, n_lines, length))
return 1;
dump_remainder(filename, fd);
} else
return pipe_lines(filename, fd, n_lines);
return 0;
}
/* Display the last N_UNITS lines of file FILENAME.
"-" for FILENAME means the standard input.
Return 0 if successful, 1 if an error occurred. */
static int tail_file(const char *filename, off_t n_units)
{
int fd, errors;
if (!strcmp(filename, "-")) {
filename = "standard input";
errors = tail_lines(filename, 0, (long) n_units);
} else {
/* Not standard input. */
fd = open(filename, O_RDONLY);
if (fd == -1)
error("open error");
errors = tail_lines(filename, fd, (long) n_units);
close(fd);
}
return errors;
}
extern int tail_main(int argc, char **argv)
{
int exit_status = 0;
int n_units = DEFAULT_N_LINES;
int n_tmp, i;
char opt;
forever = print_headers = 0;
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case 'f':
forever = 1;
break;
case 'n':
n_tmp = 0;
if (++i < argc)
n_tmp = atoi(argv[i]);
if (n_tmp < 1)
usage(tail_usage);
n_units = n_tmp;
break;
case '-':
case 'h':
usage(tail_usage);
default:
fprintf(stderr, "tail: invalid option -- %c\n", opt);
usage(tail_usage);
}
} else {
break;
}
}
if (i + 1 < argc) {
if (forever) {
fprintf(stderr,
"tail: option -f is invalid with multiple files\n");
usage(tail_usage);
}
print_headers = 1;
}
if (i >= argc) {
exit_status |= tail_file("-", n_units);
} else {
for (; i < argc; i++)
exit_status |= tail_file(argv[i], n_units);
}
exit(exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
#else
// Here follows the code for the full featured tail code
/* tail -- output the last part of file(s)
Copyright (C) 89, 90, 91, 95, 1996 Free Software Foundation, Inc.
@@ -42,7 +441,7 @@
#define NDEBUG 1
static void error(int i, int errnum, char* fmt, ...)
static void detailed_error(int i, int errnum, char* fmt, ...)
{
va_list arguments;
@@ -60,7 +459,7 @@ static void error(int i, int errnum, char* fmt, ...)
assert ((fd) == 1); \
assert ((n_bytes) >= 0); \
if (n_bytes > 0 && fwrite ((buffer), 1, (n_bytes), stdout) == 0) \
error (EXIT_FAILURE, errno, "write error"); \
detailed_error (EXIT_FAILURE, errno, "write error"); \
} \
while (0)
@@ -100,8 +499,6 @@ enum header_mode
multiple_files, always, never
};
char *xmalloc ();
/* The name this program was run with. */
char *program_name;
@@ -168,7 +565,7 @@ file_lines (const char *filename, int fd, long int n_lines, off_t pos)
bytes_read = fullRead (fd, buffer, bytes_read);
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
@@ -204,7 +601,7 @@ file_lines (const char *filename, int fd, long int n_lines, off_t pos)
while ((bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0);
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
return 0;
@@ -276,7 +673,7 @@ pipe_lines (const char *filename, int fd, long int n_lines)
}
if (tmp->nbytes == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
errors = 1;
free ((char *) tmp);
goto free_lbuffers;
@@ -390,7 +787,7 @@ pipe_bytes (const char *filename, int fd, off_t n_bytes)
}
if (tmp->nbytes == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
errors = 1;
free ((char *) tmp);
goto free_cbuffers;
@@ -438,7 +835,7 @@ start_bytes (const char *filename, int fd, off_t n_bytes)
n_bytes -= bytes_read;
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
else if (n_bytes < 0)
@@ -466,7 +863,7 @@ start_lines (const char *filename, int fd, long int n_lines)
}
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
else if (bytes_to_skip < bytes_read)
@@ -496,7 +893,7 @@ output:
total += bytes_read;
}
if (bytes_read == -1)
error (EXIT_FAILURE, errno, "%s", filename);
detailed_error (EXIT_FAILURE, errno, "%s", filename);
if (forever)
{
fflush (stdout);
@@ -540,7 +937,7 @@ tail_forever (char **names, int nfiles)
continue;
if (fstat (file_descs[i], &stats) < 0)
{
error (0, errno, "%s", names[i]);
detailed_error (0, errno, "%s", names[i]);
file_descs[i] = -1;
continue;
}
@@ -590,7 +987,7 @@ tail_bytes (const char *filename, int fd, off_t n_bytes)
error, either. */
if (fstat (fd, &stats))
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
@@ -619,7 +1016,7 @@ tail_bytes (const char *filename, int fd, off_t n_bytes)
}
else
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
@@ -656,7 +1053,7 @@ tail_lines (const char *filename, int fd, long int n_lines)
if (fstat (fd, &stats))
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
return 1;
}
@@ -723,12 +1120,12 @@ tail_file (const char *filename, off_t n_units, int filenum)
{
if (fstat (0, &stats) < 0)
{
error (0, errno, "standard input");
detailed_error (0, errno, "standard input");
errors = 1;
}
else if (!S_ISREG (stats.st_mode))
{
error (0, 0,
detailed_error (0, 0,
"standard input: cannot follow end of non-regular file");
errors = 1;
}
@@ -749,7 +1146,7 @@ tail_file (const char *filename, off_t n_units, int filenum)
{
if (forever_multiple)
file_descs[filenum] = -1;
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
errors = 1;
}
else
@@ -761,12 +1158,12 @@ tail_file (const char *filename, off_t n_units, int filenum)
{
if (fstat (fd, &stats) < 0)
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
errors = 1;
}
else if (!S_ISREG (stats.st_mode))
{
error (0, 0, "%s: cannot follow end of non-regular file",
detailed_error (0, 0, "%s: cannot follow end of non-regular file",
filename);
errors = 1;
}
@@ -785,7 +1182,7 @@ tail_file (const char *filename, off_t n_units, int filenum)
{
if (close (fd))
{
error (0, errno, "%s", filename);
detailed_error (0, errno, "%s", filename);
errors = 1;
}
}
@@ -903,8 +1300,11 @@ tail_main (int argc, char **argv)
}
if (have_read_stdin && close (0) < 0)
error (EXIT_FAILURE, errno, "-");
detailed_error (EXIT_FAILURE, errno, "-");
if (fclose (stdout) == EOF)
error (EXIT_FAILURE, errno, "write error");
detailed_error (EXIT_FAILURE, errno, "write error");
exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
#endif