contrib/xz/src/xz/file_io.h

   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);