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