void archive_options_diff::set_furtive_read_mode(bool furtive_read) { NLS_SWAP_IN; try { #if FURTIVE_READ_MODE_AVAILABLE x_furtive_read = furtive_read; if(furtive_read) { x_old_alter_atime = x_alter_atime; x_alter_atime = true; // this is required to avoid libdar manipulating ctime of inodes } else x_alter_atime = x_old_alter_atime; #else if(furtive_read) throw Ecompilation(gettext("Furtive read mode")); x_furtive_read = false; #endif } catch(...) { NLS_SWAP_OUT; throw; } NLS_SWAP_OUT; }
void fichier_local::open(const string & chemin, gf_mode m, U_I permission, bool fail_if_exists, bool erase, bool furtive_mode) { U_I o_mode = O_BINARY; const char *name = chemin.c_str(); adv = advise_normal; switch(m) { case gf_read_only : o_mode |= O_RDONLY; break; case gf_write_only : o_mode |= O_WRONLY; break; case gf_read_write : o_mode |= O_RDWR; break; default: throw SRC_BUG; } if(m != gf_read_only) { o_mode |= O_CREAT; if(fail_if_exists) o_mode |= O_EXCL; if(erase) o_mode |= O_TRUNC; } #if FURTIVE_READ_MODE_AVAILABLE if(furtive_mode) // only used for read-only, but available for write-only and read-write modes o_mode |= O_NOATIME; #else if(furtive_mode) throw Ecompilation(gettext("Furtive read mode")); #endif try { do { if(m != gf_read_only) filedesc = ::open(name, o_mode, permission); else filedesc = ::open(name, o_mode); if(filedesc < 0) { switch(errno) { case ENOSPC: if(get_mode() == gf_read_only) throw SRC_BUG; // in read_only mode we do not need to create a new inode !!! get_ui().pause(gettext("No space left for inode, you have the opportunity to make some room now. When done : can we continue ?")); break; case EEXIST: throw Esystem("fichier_local::open", tools_strerror_r(errno), Esystem::io_exist); case ENOENT: throw Esystem("fichier_local::open", tools_strerror_r(errno), Esystem::io_absent); default: throw Erange("fichier_local::open", string(gettext("Cannot open file : ")) + tools_strerror_r(errno)); } } } while(filedesc < 0 && errno == ENOSPC); } catch(...) { if(filedesc >= 0) { ::close(filedesc); filedesc = -1; } throw; } }
void compressor::init(compression algo, generic_file *compressed_side, U_I compression_level) { // these are eventually overwritten below wrapperlib_mode wr_mode = zlib_mode; current_algo = algo; current_level = compression_level; if(compressed_side == NULL) throw SRC_BUG; if(compression_level > 9) throw SRC_BUG; compr = decompr = NULL; lzo_read_buffer = lzo_write_buffer = NULL; lzo_compressed = NULL; lzo_wrkmem = NULL; switch(algo) { case none: read_ptr = &compressor::none_read; write_ptr = &compressor::none_write; break; case bzip2: wr_mode = bzlib_mode; // NO BREAK ! case gzip: read_ptr = &compressor::gzip_read; write_ptr = &compressor::gzip_write; compr = new (nothrow) xfer(BUFFER_SIZE, wr_mode); if(compr == NULL) throw Ememory("compressor::compressor"); decompr = new (nothrow) xfer(BUFFER_SIZE, wr_mode); if(decompr == NULL) { delete compr; compr = NULL; throw Ememory("compressor::compressor"); } switch(compr->wrap.compressInit(compression_level)) { case WR_OK: break; case WR_MEM_ERROR: delete compr; compr = NULL; delete decompr; decompr = NULL; throw Ememory("compressor::compressor"); case WR_VERSION_ERROR: delete compr; compr = NULL; delete decompr; decompr = NULL; throw Erange("compressor::compressor", gettext("incompatible Zlib version")); case WR_STREAM_ERROR: default: delete compr; compr = NULL; delete decompr; decompr = NULL; throw SRC_BUG; } switch(decompr->wrap.decompressInit()) { case WR_OK: decompr->wrap.set_avail_in(0); break; case WR_MEM_ERROR: compr->wrap.compressEnd(); delete compr; compr = NULL; delete decompr; decompr = NULL; throw Ememory("compressor::compressor"); case WR_VERSION_ERROR: compr->wrap.compressEnd(); delete compr; compr = NULL; delete decompr; decompr = NULL; throw Erange("compressor::compressor", gettext("incompatible Zlib version")); case WR_STREAM_ERROR: default: compr->wrap.compressEnd(); delete compr; compr = NULL; delete decompr; decompr = NULL; throw SRC_BUG; } break; case lzo: #if LIBLZO2_AVAILABLE read_ptr = &compressor::lzo_read; write_ptr = &compressor::lzo_write; lzo_read_size = lzo_write_size = 0; lzo_read_start = 0; lzo_write_flushed = true; lzo_read_reached_eof = false; try { lzo_read_buffer = new (nothrow) char[LZO_CLEAR_BUFFER_SIZE]; lzo_write_buffer = new (nothrow) char[LZO_CLEAR_BUFFER_SIZE]; lzo_compressed = new (nothrow) char[LZO_COMPRESSED_BUFFER_SIZE]; lzo_wrkmem = new (nothrow) char[LZO1X_999_MEM_COMPRESS]; if(lzo_read_buffer == NULL || lzo_write_buffer == NULL || lzo_compressed == NULL || lzo_wrkmem == NULL) throw Ememory("compressor::init"); } catch(...) { if(lzo_read_buffer != NULL) { delete [] lzo_read_buffer; lzo_read_buffer = NULL; } if(lzo_write_buffer != NULL) { delete [] lzo_write_buffer; lzo_write_buffer = NULL; } if(lzo_compressed != NULL) { delete [] lzo_compressed; lzo_compressed = NULL; } if(lzo_wrkmem != NULL) { delete [] lzo_wrkmem; lzo_wrkmem = NULL; } throw; } break; #else throw Ecompilation("lzo compression support"); #endif default : throw SRC_BUG; } compressed = compressed_side; }