1 #ifndef OSMIUM_IO_GZIP_COMPRESSION_HPP 2 #define OSMIUM_IO_GZIP_COMPRESSION_HPP 3 4 /* 5 6 This file is part of Osmium (https://osmcode.org/libosmium). 7 8 Copyright 2013-2021 Jochen Topf <jochen@topf.org> and others (see README). 9 10 Boost Software License - Version 1.0 - August 17th, 2003 11 12 Permission is hereby granted, free of charge, to any person or organization 13 obtaining a copy of the software and accompanying documentation covered by 14 this license (the "Software") to use, reproduce, display, distribute, 15 execute, and transmit the Software, and to prepare derivative works of the 16 Software, and to permit third-parties to whom the Software is furnished to 17 do so, all subject to the following: 18 19 The copyright notices in the Software and this entire statement, including 20 the above license grant, this restriction and the following disclaimer, 21 must be included in all copies of the Software, in whole or in part, and 22 all derivative works of the Software, unless such copies or derivative 23 works are solely in the form of machine-executable object code generated by 24 a source language processor. 25 26 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 27 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 28 FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 29 SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 30 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 31 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 32 DEALINGS IN THE SOFTWARE. 33 34 */ 35 36 /** 37 * @file 38 * 39 * Include this file if you want to read or write gzip-compressed OSM 40 * files. 41 * 42 * @attention If you include this file, you'll need to link with `libz`. 43 */ 44 45 #include <osmium/io/compression.hpp> 46 #include <osmium/io/detail/read_write.hpp> 47 #include <osmium/io/error.hpp> 48 #include <osmium/io/file_compression.hpp> 49 #include <osmium/io/writer_options.hpp> 50 51 #include <zlib.h> 52 53 #include <cassert> 54 #include <cerrno> 55 #include <cstddef> 56 #include <limits> 57 #include <string> 58 59 #ifndef _MSC_VER 60 # include <unistd.h> 61 #endif 62 63 namespace osmium { 64 65 /** 66 * Exception thrown when there are problems compressing or 67 * decompressing gzip files. 68 */ 69 struct gzip_error : public io_error { 70 71 int gzip_error_code = 0; 72 int system_errno = 0; 73 gzip_errorosmium::gzip_error74 explicit gzip_error(const std::string& what) : 75 io_error(what) { 76 } 77 gzip_errorosmium::gzip_error78 gzip_error(const std::string& what, const int error_code) : 79 io_error(what), 80 gzip_error_code(error_code) { 81 if (error_code == Z_ERRNO) { 82 system_errno = errno; 83 } 84 } 85 86 }; // struct gzip_error 87 88 namespace io { 89 90 namespace detail { 91 throw_gzip_error(gzFile gzfile,const char * msg)92 [[noreturn]] inline void throw_gzip_error(gzFile gzfile, const char* msg) { 93 std::string error{"gzip error: "}; 94 error += msg; 95 error += ": "; 96 int error_code = 0; 97 if (gzfile) { 98 error += ::gzerror(gzfile, &error_code); 99 } 100 throw osmium::gzip_error{error, error_code}; 101 } 102 103 } // namespace detail 104 105 class GzipCompressor final : public Compressor { 106 107 std::size_t m_file_size = 0; 108 int m_fd; 109 gzFile m_gzfile; 110 111 public: 112 GzipCompressor(const int fd,const fsync sync)113 explicit GzipCompressor(const int fd, const fsync sync) : 114 Compressor(sync), 115 m_fd(fd) { 116 #ifdef _MSC_VER 117 osmium::detail::disable_invalid_parameter_handler diph; 118 #endif 119 m_gzfile = ::gzdopen(osmium::io::detail::reliable_dup(fd), "wb"); 120 if (!m_gzfile) { 121 throw gzip_error{"gzip error: write initialization failed"}; 122 } 123 } 124 125 GzipCompressor(const GzipCompressor&) = delete; 126 GzipCompressor& operator=(const GzipCompressor&) = delete; 127 128 GzipCompressor(GzipCompressor&&) = delete; 129 GzipCompressor& operator=(GzipCompressor&&) = delete; 130 ~GzipCompressor()131 ~GzipCompressor() noexcept override { 132 try { 133 close(); 134 } catch (...) { 135 // Ignore any exceptions because destructor must not throw. 136 } 137 } 138 write(const std::string & data)139 void write(const std::string& data) override { 140 #ifdef _MSC_VER 141 osmium::detail::disable_invalid_parameter_handler diph; 142 #endif 143 assert(m_gzfile); 144 assert(data.size() < std::numeric_limits<unsigned int>::max()); 145 if (!data.empty()) { 146 const int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast<unsigned int>(data.size())); 147 if (nwrite == 0) { 148 detail::throw_gzip_error(m_gzfile, "write failed"); 149 } 150 } 151 } 152 close()153 void close() override { 154 if (m_gzfile) { 155 #ifdef _MSC_VER 156 osmium::detail::disable_invalid_parameter_handler diph; 157 #endif 158 const int result = ::gzclose_w(m_gzfile); 159 m_gzfile = nullptr; 160 if (result != Z_OK) { 161 throw gzip_error{"gzip error: write close failed", result}; 162 } 163 164 // Do not sync or close stdout 165 if (m_fd == 1) { 166 return; 167 } 168 169 m_file_size = osmium::file_size(m_fd); 170 171 if (do_fsync()) { 172 osmium::io::detail::reliable_fsync(m_fd); 173 } 174 osmium::io::detail::reliable_close(m_fd); 175 } 176 } 177 file_size() const178 std::size_t file_size() const override { 179 return m_file_size; 180 } 181 182 }; // class GzipCompressor 183 184 class GzipDecompressor final : public Decompressor { 185 186 gzFile m_gzfile = nullptr; 187 int m_fd; 188 189 public: 190 GzipDecompressor(const int fd)191 explicit GzipDecompressor(const int fd) : m_fd(fd) { 192 #ifdef _MSC_VER 193 osmium::detail::disable_invalid_parameter_handler diph; 194 #endif 195 m_gzfile = ::gzdopen(fd, "rb"); 196 if (!m_gzfile) { 197 try { 198 osmium::io::detail::reliable_close(fd); 199 } catch (...) { 200 } 201 throw gzip_error{"gzip error: read initialization failed"}; 202 } 203 } 204 205 GzipDecompressor(const GzipDecompressor&) = delete; 206 GzipDecompressor& operator=(const GzipDecompressor&) = delete; 207 208 GzipDecompressor(GzipDecompressor&&) = delete; 209 GzipDecompressor& operator=(GzipDecompressor&&) = delete; 210 ~GzipDecompressor()211 ~GzipDecompressor() noexcept override { 212 try { 213 close(); 214 } catch (...) { 215 // Ignore any exceptions because destructor must not throw. 216 } 217 } 218 read()219 std::string read() override { 220 assert(m_gzfile); 221 #ifdef _MSC_VER 222 osmium::detail::disable_invalid_parameter_handler diph; 223 #else 224 # if ZLIB_VERNUM >= 0x1240 225 const auto offset = ::gzoffset(m_gzfile); 226 if (offset > 0 && want_buffered_pages_removed()) { 227 osmium::io::detail::remove_buffered_pages(m_fd, static_cast<std::size_t>(offset)); 228 } 229 # endif 230 #endif 231 std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0'); 232 assert(buffer.size() < std::numeric_limits<unsigned int>::max()); 233 int nread = ::gzread(m_gzfile, &*buffer.begin(), static_cast<unsigned int>(buffer.size())); 234 if (nread < 0) { 235 detail::throw_gzip_error(m_gzfile, "read failed"); 236 } 237 buffer.resize(static_cast<std::string::size_type>(nread)); 238 #if ZLIB_VERNUM >= 0x1240 239 set_offset(static_cast<std::size_t>(::gzoffset(m_gzfile))); 240 #endif 241 return buffer; 242 } 243 close()244 void close() override { 245 if (m_gzfile) { 246 if (want_buffered_pages_removed()) { 247 osmium::io::detail::remove_buffered_pages(m_fd); 248 } 249 #ifdef _MSC_VER 250 osmium::detail::disable_invalid_parameter_handler diph; 251 #endif 252 const int result = ::gzclose_r(m_gzfile); 253 m_gzfile = nullptr; 254 if (result != Z_OK) { 255 throw gzip_error{"gzip error: read close failed", result}; 256 } 257 } 258 } 259 260 }; // class GzipDecompressor 261 262 class GzipBufferDecompressor final : public Decompressor { 263 264 const char* m_buffer; 265 std::size_t m_buffer_size; 266 z_stream m_zstream; 267 268 public: 269 GzipBufferDecompressor(const char * buffer,const std::size_t size)270 GzipBufferDecompressor(const char* buffer, const std::size_t size) : 271 m_buffer(buffer), 272 m_buffer_size(size), 273 m_zstream() { 274 m_zstream.next_in = reinterpret_cast<unsigned char*>(const_cast<char*>(buffer)); 275 assert(size < std::numeric_limits<unsigned int>::max()); 276 m_zstream.avail_in = static_cast<unsigned int>(size); 277 const int result = inflateInit2(&m_zstream, MAX_WBITS | 32); // NOLINT(hicpp-signed-bitwise) 278 if (result != Z_OK) { 279 std::string message{"gzip error: decompression init failed: "}; 280 if (m_zstream.msg) { 281 message.append(m_zstream.msg); 282 } 283 throw osmium::gzip_error{message, result}; 284 } 285 } 286 287 GzipBufferDecompressor(const GzipBufferDecompressor&) = delete; 288 GzipBufferDecompressor& operator=(const GzipBufferDecompressor&) = delete; 289 290 GzipBufferDecompressor(GzipBufferDecompressor&&) = delete; 291 GzipBufferDecompressor& operator=(GzipBufferDecompressor&&) = delete; 292 ~GzipBufferDecompressor()293 ~GzipBufferDecompressor() noexcept override { 294 try { 295 close(); 296 } catch (...) { 297 // Ignore any exceptions because destructor must not throw. 298 } 299 } 300 read()301 std::string read() override { 302 std::string output; 303 304 if (m_buffer) { 305 const std::size_t buffer_size = 10240; 306 output.append(buffer_size, '\0'); 307 m_zstream.next_out = reinterpret_cast<unsigned char*>(&*output.begin()); 308 m_zstream.avail_out = buffer_size; 309 const int result = inflate(&m_zstream, Z_SYNC_FLUSH); 310 311 if (result != Z_OK) { 312 m_buffer = nullptr; 313 m_buffer_size = 0; 314 } 315 316 if (result != Z_OK && result != Z_STREAM_END) { 317 std::string message{"gzip error: inflate failed: "}; 318 if (m_zstream.msg) { 319 message.append(m_zstream.msg); 320 } 321 throw osmium::gzip_error{message, result}; 322 } 323 324 output.resize(static_cast<std::size_t>(m_zstream.next_out - reinterpret_cast<const unsigned char*>(output.data()))); 325 } 326 327 return output; 328 } 329 close()330 void close() override { 331 inflateEnd(&m_zstream); 332 } 333 334 }; // class GzipBufferDecompressor 335 336 namespace detail { 337 338 // we want the register_compression() function to run, setting 339 // the variable is only a side-effect, it will never be used 340 const bool registered_gzip_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip, __anon727ad6bb0102(const int fd, const fsync sync) 341 [](const int fd, const fsync sync) { return new osmium::io::GzipCompressor{fd, sync}; }, __anon727ad6bb0202(const int fd) 342 [](const int fd) { return new osmium::io::GzipDecompressor{fd}; }, __anon727ad6bb0302(const char* buffer, const std::size_t size) 343 [](const char* buffer, const std::size_t size) { return new osmium::io::GzipBufferDecompressor{buffer, size}; } 344 ); 345 346 // dummy function to silence the unused variable warning from above get_registered_gzip_compression()347 inline bool get_registered_gzip_compression() noexcept { 348 return registered_gzip_compression; 349 } 350 351 } // namespace detail 352 353 } // namespace io 354 355 } // namespace osmium 356 357 #endif // OSMIUM_IO_GZIP_COMPRESSION_HPP 358