X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=libbb%2Fcopyfd.c;h=eda2747f991b0253b8fe3596d79035a5c373dff3;hb=b2320370be14811459718b9fe418efed75ea3615;hp=62ada8e02b2e1de4191450600fa28786d8022094;hpb=f0515dad66ab7340674a8695dfd60ffcef6cb5aa;p=oweals%2Fbusybox.git diff --git a/libbb/copyfd.c b/libbb/copyfd.c index 62ada8e02..eda2747f9 100644 --- a/libbb/copyfd.c +++ b/libbb/copyfd.c @@ -2,86 +2,134 @@ /* * Utility routines. * - * Copyright (C) 1999-2003 by Erik Andersen + * Copyright (C) 1999-2005 by Erik Andersen * - * 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 of the License, 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 + * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ -#include -#include -#include -#include +#include "libbb.h" -#include "busybox.h" +/* Used by NOFORK applets (e.g. cat) - must not use xmalloc. + * size < 0 means "ignore write errors", used by tar --to-command + * size = 0 means "copy till EOF" + */ +static off_t bb_full_fd_action(int src_fd, int dst_fd, off_t size) +{ + int status = -1; + off_t total = 0; + bool continue_on_write_error = 0; +#if CONFIG_FEATURE_COPYBUF_KB <= 4 + char buffer[CONFIG_FEATURE_COPYBUF_KB * 1024]; + enum { buffer_size = sizeof(buffer) }; +#else + char *buffer; + int buffer_size; +#endif + if (size < 0) { + size = -size; + continue_on_write_error = 1; + } -#if BUFSIZ < 4096 -#undef BUFSIZ -#define BUFSIZ 4096 +#if CONFIG_FEATURE_COPYBUF_KB > 4 + if (size > 0 && size <= 4 * 1024) + goto use_small_buf; + /* We want page-aligned buffer, just in case kernel is clever + * and can do page-aligned io more efficiently */ + buffer = mmap(NULL, CONFIG_FEATURE_COPYBUF_KB * 1024, + PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANON, + /* ignored: */ -1, 0); + buffer_size = CONFIG_FEATURE_COPYBUF_KB * 1024; + if (buffer == MAP_FAILED) { + use_small_buf: + buffer = alloca(4 * 1024); + buffer_size = 4 * 1024; + } #endif + if (src_fd < 0) + goto out; -/* If size is 0 copy until EOF */ -extern size_t bb_full_fd_action(int src_fd, int dst_fd, const size_t size, ssize_t (*action)(int fd, const void *, size_t)) -{ - size_t read_total = 0; - RESERVE_CONFIG_BUFFER(buffer,BUFSIZ); + if (!size) { + size = buffer_size; + status = 1; /* copy until eof */ + } - while ((size == 0) || (read_total < size)) { - size_t read_try; - ssize_t read_actual; + while (1) { + ssize_t rd; - if ((size == 0) || (size - read_total > BUFSIZ)) { - read_try = BUFSIZ; - } else { - read_try = size - read_total; - } + rd = safe_read(src_fd, buffer, size > buffer_size ? buffer_size : size); - read_actual = safe_read(src_fd, buffer, read_try); - if (read_actual > 0) { - if (action && (action(dst_fd, buffer, (size_t) read_actual) != read_actual)) { - bb_perror_msg(bb_msg_write_error); /* match Read error below */ - break; + if (!rd) { /* eof - all done */ + status = 0; + break; + } + if (rd < 0) { + bb_perror_msg(bb_msg_read_error); + break; + } + /* dst_fd == -1 is a fake, else... */ + if (dst_fd >= 0) { + ssize_t wr = full_write(dst_fd, buffer, rd); + if (wr < rd) { + if (!continue_on_write_error) { + bb_perror_msg(bb_msg_write_error); + break; + } + dst_fd = -1; } } - else if (read_actual == 0) { - if (size) { - bb_error_msg("Unable to read all data"); + total += rd; + if (status < 0) { /* if we aren't copying till EOF... */ + size -= rd; + if (!size) { + /* 'size' bytes copied - all done */ + status = 0; + break; } - break; - } else { - /* read_actual < 0 */ - bb_perror_msg("Read error"); - break; } - - read_total += read_actual; } + out: - RELEASE_CONFIG_BUFFER(buffer); +#if CONFIG_FEATURE_COPYBUF_KB > 4 + if (buffer_size != 4 * 1024) + munmap(buffer, buffer_size); +#endif + return status ? -1 : total; +} - return(read_total); + +#if 0 +void FAST_FUNC complain_copyfd_and_die(off_t sz) +{ + if (sz != -1) + bb_error_msg_and_die("short read"); + /* if sz == -1, bb_copyfd_XX already complained */ + xfunc_die(); } +#endif +off_t FAST_FUNC bb_copyfd_size(int fd1, int fd2, off_t size) +{ + if (size) { + return bb_full_fd_action(fd1, fd2, size); + } + return 0; +} -extern int bb_copyfd_size(int fd1, int fd2, const off_t size) +void FAST_FUNC bb_copyfd_exact_size(int fd1, int fd2, off_t size) { - return(bb_full_fd_action(fd1, fd2, size, bb_full_write)); + off_t sz = bb_copyfd_size(fd1, fd2, size); + if (sz == (size >= 0 ? size : -size)) + return; + if (sz != -1) + bb_error_msg_and_die("short read"); + /* if sz == -1, bb_copyfd_XX already complained */ + xfunc_die(); } -extern int bb_copyfd_eof(int fd1, int fd2) +off_t FAST_FUNC bb_copyfd_eof(int fd1, int fd2) { - return(bb_full_fd_action(fd1, fd2, 0, bb_full_write)); + return bb_full_fd_action(fd1, fd2, 0); }