file_io.h File Reference

I/O types and functions. More...

Go to the source code of this file.

Classes
union	io_buf
struct	file_pair

Macros
#define	IO_BUFFER_SIZE   8192

Functions
void	io_init (void)
	Initialize the I/O module. More...
void	io_write_to_user_abort_pipe (void)
	Write a byte to user_abort_pipe[1]. More...
void	io_no_sparse (void)
	Disable creation of sparse files when decompressing. More...
file_pair *	io_open_src (const char *src_name)
	Open the source file. More...
bool	io_open_dest (file_pair *pair)
	Open the destination file. More...
void	io_close (file_pair *pair, bool success)
	Closes the file descriptors and frees possible allocated memory. More...
size_t	io_read (file_pair *pair, io_buf *buf, size_t size)
	Reads from the source file to a buffer. More...
void	io_fix_src_pos (file_pair *pair, size_t rewind_size)
	Fix the position in src_fd. More...
bool	io_pread (file_pair *pair, io_buf *buf, size_t size, off_t pos)
	Read from source file from given offset to a buffer. More...
bool	io_write (file_pair *pair, const io_buf *buf, size_t size)
	Writes a buffer to the destination file. More...

Detailed Description

I/O types and functions.

Definition in file file_io.h.

Macro Definition Documentation

IO_BUFFER_SIZE

#define IO_BUFFER_SIZE   8192

Definition at line 16 of file file_io.h.

Function Documentation

io_close()

void io_close	(	file_pair *	pair,
		bool	success
	)

Closes the file descriptors and frees possible allocated memory.

The success argument determines if source or destination file gets unlinked:

• false: The destination file is unlinked.
• true: The source file is unlinked unless writing to stdout or –keep was used.

Definition at line 1052 of file file_io.c.

{
    // Take care of sparseness at the end of the output file.
    if (success && pair->dest_try_sparse
            && pair->dest_pending_sparse > 0) {
        // Seek forward one byte less than the size of the pending
        // hole, then write one zero-byte. This way the file grows
        // to its correct size. An alternative would be to use
        // ftruncate() but that isn't portable enough (e.g. it
        // doesn't work with FAT on Linux; FAT isn't that important
        // since it doesn't support sparse files anyway, but we don't
        // want to create corrupt files on it).
        if (lseek(pair->dest_fd, pair->dest_pending_sparse - 1,
                SEEK_CUR) == -1) {
            message_error(_("%s: Seeking failed when trying "
                    "to create a sparse file: %s"),
                    pair->dest_name, strerror(errno));
            success = false;
        } else {
            const uint8_t zero[1] = { '\0' };
            if (io_write_buf(pair, zero, 1))
                success = false;
        }
    }
 
    signals_block();
 
    // Copy the file attributes. We need to skip this if destination
    // file isn't open or it is standard output.
    if (success && pair->dest_fd != -1 && pair->dest_fd != STDOUT_FILENO)
        io_copy_attrs(pair);
 
    // Close the destination first. If it fails, we must not remove
    // the source file!
    if (io_close_dest(pair, success))
        success = false;
 
    // Close the source file, and unlink it if the operation using this
    // file pair was successful and we haven't requested to keep the
    // source file.
    io_close_src(pair, success);
 
    signals_unblock();
 
    return;
}

References _, file_pair::dest_fd, file_pair::dest_name, file_pair::dest_pending_sparse, file_pair::dest_try_sparse, io_close_dest(), io_close_src(), io_copy_attrs(), io_write_buf(), lseek, message_error(), SEEK_CUR, signals_block(), signals_unblock(), and STDOUT_FILENO.

Referenced by coder_run(), and list_file().

io_fix_src_pos()

void io_fix_src_pos	(	file_pair *	pair,
		size_t	rewind_size
	)

Fix the position in src_fd.

This is used when –single-thream has been specified and decompression is successful. If the input file descriptor supports seeking, this function fixes the input position to point to the next byte after the decompressed stream.

Parameters

pair	File pair having the source file open for reading
rewind_size	How many bytes of extra have been read i.e. how much to seek backwards.

Definition at line 1101 of file file_io.c.

{
    assert(rewind_size <= IO_BUFFER_SIZE);
 
    if (rewind_size > 0) {
        // This doesn't need to work on unseekable file descriptors,
        // so just ignore possible errors.
        (void)lseek(pair->src_fd, -(off_t)(rewind_size), SEEK_CUR);
    }
 
    return;
}

References assert(), IO_BUFFER_SIZE, lseek, SEEK_CUR, and file_pair::src_fd.

Referenced by coder_normal().

io_init()

void io_init

(

void

)

Initialize the I/O module.

Definition at line 95 of file file_io.c.

{
    // Make sure that stdin, stdout, and stderr are connected to
    // a valid file descriptor. Exit immediately with exit code ERROR
    // if we cannot make the file descriptors valid. Maybe we should
    // print an error message, but our stderr could be screwed anyway.
    tuklib_open_stdxxx(E_ERROR);
 
#ifndef TUKLIB_DOSLIKE
    // If fchown() fails setting the owner, we warn about it only if
    // we are root.
    warn_fchown = geteuid() == 0;
 
    // Create a pipe for the self-pipe trick.
    if (pipe(user_abort_pipe))
        message_fatal(_("Error creating a pipe: %s"),
                strerror(errno));
 
    // Make both ends of the pipe non-blocking.
    for (unsigned i = 0; i < 2; ++i) {
        int flags = fcntl(user_abort_pipe[i], F_GETFL);
        if (flags == -1 || fcntl(user_abort_pipe[i], F_SETFL,
                flags | O_NONBLOCK) == -1)
            message_fatal(_("Error creating a pipe: %s"),
                    strerror(errno));
    }
#endif
 
#ifdef __DJGPP__
    // Avoid doing useless things when statting files.
    // This isn't important but doesn't hurt.
    _djstat_flags = _STAT_EXEC_EXT | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
#endif
 
    return;
}

References _, E_ERROR, F_GETFL, F_SETFL, fcntl, flags, i, message_fatal(), O_NONBLOCK, pipe, tuklib_open_stdxxx(), user_abort_pipe, and warn_fchown.

Referenced by main().

io_no_sparse()

void io_no_sparse

(

void

)

Disable creation of sparse files when decompressing.

Definition at line 151 of file file_io.c.

{
    try_sparse = false;
    return;
}

References try_sparse.

Referenced by parse_real().

io_open_dest()

bool io_open_dest

(

file_pair *

pair

)

Open the destination file.

Definition at line 991 of file file_io.c.

{
    signals_block();
    const bool ret = io_open_dest_real(pair);
    signals_unblock();
    return ret;
}

References io_open_dest_real(), signals_block(), and signals_unblock().

Referenced by coder_run().

io_open_src()

file_pair* io_open_src

(

const char *

src_name

)

Open the source file.

Definition at line 741 of file file_io.c.

{
    if (is_empty_filename(src_name))
        return NULL;
 
    // Since we have only one file open at a time, we can use
    // a statically allocated structure.
    static file_pair pair;
 
    pair = (file_pair){
        .src_name = src_name,
        .dest_name = NULL,
        .src_fd = -1,
        .dest_fd = -1,
        .src_eof = false,
        .src_has_seen_input = false,
        .flush_needed = false,
        .dest_try_sparse = false,
        .dest_pending_sparse = 0,
    };
 
    // Block the signals, for which we have a custom signal handler, so
    // that we don't need to worry about EINTR.
    signals_block();
    const bool error = io_open_src_real(&pair);
    signals_unblock();
 
#ifdef ENABLE_SANDBOX
    if (!error)
        io_sandbox_enter(pair.src_fd);
#endif
 
    return error ? NULL : &pair;
}

References error(), io_open_src_real(), is_empty_filename(), NULL, signals_block(), signals_unblock(), file_pair::src_fd, and file_pair::src_name.

Referenced by coder_run(), and list_file().

io_pread()

bool io_pread	(	file_pair *	pair,
		io_buf *	buf,
		size_t	size,
		off_t	pos
	)

Read from source file from given offset to a buffer.

This is remotely similar to standard pread(). This uses lseek() though, so the read offset is changed on each call.

Parameters

pair	Seekable source file
buf	Destination buffer
size	Amount of data to read
pos	Offset relative to the beginning of the file, from which the data should be read.

Returns

On success, false is returned. On error, error message is printed and true is returned.

Definition at line 1186 of file file_io.c.

{
    // Using lseek() and read() is more portable than pread() and
    // for us it is as good as real pread().
    if (lseek(pair->src_fd, pos, SEEK_SET) != pos) {
        message_error(_("%s: Error seeking the file: %s"),
                pair->src_name, strerror(errno));
        return true;
    }
 
    const size_t amount = io_read(pair, buf, size);
    if (amount == SIZE_MAX)
        return true;
 
    if (amount != size) {
        message_error(_("%s: Unexpected end of file"),
                pair->src_name);
        return true;
    }
 
    return false;
}

References _, io_read(), lseek, message_error(), pos, SEEK_SET, SIZE_MAX, file_pair::src_fd, and file_pair::src_name.

Referenced by parse_block_header(), parse_check_value(), and parse_indexes().

io_read()

size_t io_read	(	file_pair *	pair,
		io_buf *	buf,
		size_t	size
	)

Reads from the source file to a buffer.

Parameters

pair	File pair having the source file open for reading
buf	Destination buffer to hold the read data
size	Size of the buffer; assumed be smaller than SSIZE_MAX

Returns

On success, number of bytes read is returned. On end of file zero is returned and pair->src_eof set to true. On error, SIZE_MAX is returned and error message printed.

Definition at line 1116 of file file_io.c.

{
    // We use small buffers here.
    assert(size < SSIZE_MAX);
 
    size_t pos = 0;
 
    while (pos < size) {
        const ssize_t amount = read(
                pair->src_fd, buf->u8 + pos, size - pos);
 
        if (amount == 0) {
            pair->src_eof = true;
            break;
        }
 
        if (amount == -1) {
            if (errno == EINTR) {
                if (user_abort)
                    return SIZE_MAX;
 
                continue;
            }
 
#ifndef TUKLIB_DOSLIKE
            if (IS_EAGAIN_OR_EWOULDBLOCK(errno)) {
                // Disable the flush-timeout if no input has
                // been seen since the previous flush and thus
                // there would be nothing to flush after the
                // timeout expires (avoids busy waiting).
                const int timeout = pair->src_has_seen_input
                        ? mytime_get_flush_timeout()
                        : -1;
 
                switch (io_wait(pair, timeout, true)) {
                case IO_WAIT_MORE:
                    continue;
 
                case IO_WAIT_ERROR:
                    return SIZE_MAX;
 
                case IO_WAIT_TIMEOUT:
                    pair->flush_needed = true;
                    return pos;
 
                default:
                    message_bug();
                }
            }
#endif
 
            message_error(_("%s: Read error: %s"),
                    pair->src_name, strerror(errno));
 
            return SIZE_MAX;
        }
 
        pos += (size_t)(amount);
 
        if (!pair->src_has_seen_input) {
            pair->src_has_seen_input = true;
            mytime_set_flush_time();
        }
    }
 
    return pos;
}

References _, assert(), EINTR, file_pair::flush_needed, io_wait(), IO_WAIT_ERROR, IO_WAIT_MORE, IO_WAIT_TIMEOUT, IS_EAGAIN_OR_EWOULDBLOCK, message_bug(), message_error(), mytime_get_flush_timeout(), mytime_set_flush_time(), pos, read(), SIZE_MAX, file_pair::src_eof, file_pair::src_fd, file_pair::src_has_seen_input, file_pair::src_name, SSIZE_MAX, timeout, and user_abort.

Referenced by coder_normal(), coder_passthru(), coder_run(), and io_pread().

io_write()

bool io_write	(	file_pair *	pair,
		const io_buf *	buf,
		size_t	size
	)

Writes a buffer to the destination file.

Parameters

pair	File pair having the destination file open for writing
buf	Buffer containing the data to be written
size	Size of the buffer; assumed be smaller than SSIZE_MAX

Returns

On success, zero is returned. On error, -1 is returned and error message printed.

Definition at line 1275 of file file_io.c.

{
    assert(size <= IO_BUFFER_SIZE);
 
    if (pair->dest_try_sparse) {
        // Check if the block is sparse (contains only zeros). If it
        // sparse, we just store the amount and return. We will take
        // care of actually skipping over the hole when we hit the
        // next data block or close the file.
        //
        // Since io_close() requires that dest_pending_sparse > 0
        // if the file ends with sparse block, we must also return
        // if size == 0 to avoid doing the lseek().
        if (size == IO_BUFFER_SIZE) {
            // Even if the block was sparse, treat it as non-sparse
            // if the pending sparse amount is large compared to
            // the size of off_t. In practice this only matters
            // on 32-bit systems where off_t isn't always 64 bits.
            const off_t pending_max
                = (off_t)(1) << (sizeof(off_t) * CHAR_BIT - 2);
            if (is_sparse(buf) && pair->dest_pending_sparse
                    < pending_max) {
                pair->dest_pending_sparse += (off_t)(size);
                return false;
            }
        } else if (size == 0) {
            return false;
        }
 
        // This is not a sparse block. If we have a pending hole,
        // skip it now.
        if (pair->dest_pending_sparse > 0) {
            if (lseek(pair->dest_fd, pair->dest_pending_sparse,
                    SEEK_CUR) == -1) {
                message_error(_("%s: Seeking failed when "
                        "trying to create a sparse "
                        "file: %s"), pair->dest_name,
                        strerror(errno));
                return true;
            }
 
            pair->dest_pending_sparse = 0;
        }
    }
 
    return io_write_buf(pair, buf->u8, size);
}

References _, assert(), CHAR_BIT, file_pair::dest_fd, file_pair::dest_name, file_pair::dest_pending_sparse, file_pair::dest_try_sparse, IO_BUFFER_SIZE, io_write_buf(), is_sparse(), lseek, message_error(), and SEEK_CUR.

Referenced by coder_passthru(), and coder_write_output().

io_write_to_user_abort_pipe()

void io_write_to_user_abort_pipe

(

void

)

Write a byte to user_abort_pipe[1].

This is called from a signal handler.

Definition at line 135 of file file_io.c.

{
    // If the write() fails, it's probably due to the pipe being full.
    // Failing in that case is fine. If the reason is something else,
    // there's not much we can do since this is called in a signal
    // handler. So ignore the errors and try to avoid warnings with
    // GCC and glibc when _FORTIFY_SOURCE=2 is used.
    uint8_t b = '\0';
    const int ret = write(user_abort_pipe[1], &b, 1);
    (void)ret;
    return;
}

References b, user_abort_pipe, and write.

Referenced by signal_handler().