1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 /// \file file_io.h 4 /// \brief I/O types and functions 5 // 6 // Author: Lasse Collin 7 // 8 // This file has been put into the public domain. 9 // You can do whatever you want with this file. 10 // 11 /////////////////////////////////////////////////////////////////////////////// 12 13 // Some systems have suboptimal BUFSIZ. Use a bit bigger value on them. 14 // We also need that IO_BUFFER_SIZE is a multiple of 8 (sizeof(uint64_t)) 15 #if BUFSIZ <= 1024 16 # define IO_BUFFER_SIZE 8192 17 #else 18 # define IO_BUFFER_SIZE (BUFSIZ & ~7U) 19 #endif 20 21 22 /// is_sparse() accesses the buffer as uint64_t for maximum speed. 23 /// Use an union to make sure that the buffer is properly aligned. 24 typedef union { 25 uint8_t u8[IO_BUFFER_SIZE]; 26 uint32_t u32[IO_BUFFER_SIZE / sizeof(uint32_t)]; 27 uint64_t u64[IO_BUFFER_SIZE / sizeof(uint64_t)]; 28 } io_buf; 29 30 31 typedef struct { 32 /// Name of the source filename (as given on the command line) or 33 /// pointer to static "(stdin)" when reading from standard input. 34 const char *src_name; 35 36 /// Destination filename converted from src_name or pointer to static 37 /// "(stdout)" when writing to standard output. 38 char *dest_name; 39 40 /// File descriptor of the source file 41 int src_fd; 42 43 /// File descriptor of the target file 44 int dest_fd; 45 46 /// True once end of the source file has been detected. 47 bool src_eof; 48 49 /// If true, we look for long chunks of zeros and try to create 50 /// a sparse file. 51 bool dest_try_sparse; 52 53 /// This is used only if dest_try_sparse is true. This holds the 54 /// number of zero bytes we haven't written out, because we plan 55 /// to make that byte range a sparse chunk. 56 off_t dest_pending_sparse; 57 58 /// Stat of the source file. 59 struct stat src_st; 60 61 /// Stat of the destination file. 62 struct stat dest_st; 63 64 } file_pair; 65 66 67 /// \brief Initialize the I/O module 68 extern void io_init(void); 69 70 71 /// \brief Disable creation of sparse files when decompressing 72 extern void io_no_sparse(void); 73 74 75 /// \brief Open the source file 76 extern file_pair *io_open_src(const char *src_name); 77 78 79 /// \brief Open the destination file 80 extern bool io_open_dest(file_pair *pair); 81 82 83 /// \brief Closes the file descriptors and frees possible allocated memory 84 /// 85 /// The success argument determines if source or destination file gets 86 /// unlinked: 87 /// - false: The destination file is unlinked. 88 /// - true: The source file is unlinked unless writing to stdout or --keep 89 /// was used. 90 extern void io_close(file_pair *pair, bool success); 91 92 93 /// \brief Reads from the source file to a buffer 94 /// 95 /// \param pair File pair having the source file open for reading 96 /// \param buf Destination buffer to hold the read data 97 /// \param size Size of the buffer; assumed be smaller than SSIZE_MAX 98 /// 99 /// \return On success, number of bytes read is returned. On end of 100 /// file zero is returned and pair->src_eof set to true. 101 /// On error, SIZE_MAX is returned and error message printed. 102 extern size_t io_read(file_pair *pair, io_buf *buf, size_t size); 103 104 105 /// \brief Read from source file from given offset to a buffer 106 /// 107 /// This is remotely similar to standard pread(). This uses lseek() though, 108 /// so the read offset is changed on each call. 109 /// 110 /// \param pair Seekable source file 111 /// \param buf Destination buffer 112 /// \param size Amount of data to read 113 /// \param pos Offset relative to the beginning of the file, 114 /// from which the data should be read. 115 /// 116 /// \return On success, false is returned. On error, error message 117 /// is printed and true is returned. 118 extern bool io_pread(file_pair *pair, io_buf *buf, size_t size, off_t pos); 119 120 121 /// \brief Writes a buffer to the destination file 122 /// 123 /// \param pair File pair having the destination file open for writing 124 /// \param buf Buffer containing the data to be written 125 /// \param size Size of the buffer; assumed be smaller than SSIZE_MAX 126 /// 127 /// \return On success, zero is returned. On error, -1 is returned 128 /// and error message printed. 129 extern bool io_write(file_pair *pair, const io_buf *buf, size_t size); 130