void compressor::lzo_compress_buffer_and_write()
{
#if LIBLZO2_AVAILABLE
lzo_block_header lzo_bh;
lzo_uint compr_size = LZO_COMPRESSED_BUFFER_SIZE;
S_I status;
//compressing data to lzo_compress buffer
status = lzo1x_999_compress_level((lzo_bytep)lzo_write_buffer, lzo_write_size, (lzo_bytep)lzo_compressed, &compr_size, lzo_wrkmem, NULL, 0, 0, current_level);
switch(status)
{
case LZO_E_OK:
break; // all is fine
default:
throw Erange("compressor::lzo_compress_buffer_and_write", tools_printf(gettext("Probable bug in liblzo2: lzo1x_*_compress returned unexpected code %d"), status));
}
// writing down the TL(V) before the compressed data
lzo_bh.type = BLOCK_HEADER_LZO;
lzo_bh.size = compr_size;
if(compressed == NULL)
throw SRC_BUG;
lzo_bh.dump(*compressed);
compressed->write(lzo_compressed, compr_size);
lzo_write_size = 0;
#else
throw Efeature(gettext("lzo compression"));
#endif
}
void compressor::lzo_write(const char *a, U_I size)
{
#if LIBLZO2_AVAILABLE
U_I wrote = 0;
lzo_write_flushed = false;
while(wrote < size)
{
U_I to_write = size - wrote;
U_I space = LZO_CLEAR_BUFFER_SIZE - lzo_write_size;
if(to_write < space)
{
(void)memcpy(lzo_write_buffer + lzo_write_size, a + wrote, to_write);
wrote += to_write;
lzo_write_size += to_write;
}
else
{
(void)memcpy(lzo_write_buffer + lzo_write_size, a + wrote, space);
wrote += space;
lzo_write_size += space;
lzo_compress_buffer_and_write();
}
}
#else
throw Efeature(gettext("lzo compression"));
#endif
}
void crypto_asym::decrypt(generic_file & ciphered, generic_file & clear)
{
#if GPGME_SUPPORT
generic_file_overlay_for_gpgme o_clear = &clear;
generic_file_overlay_for_gpgme o_ciphered = &ciphered;
gpgme_error_t err = gpgme_op_decrypt_verify(context, o_ciphered.get_gpgme_handle(), o_clear.get_gpgme_handle());
signing_result.clear();
switch(gpgme_err_code(err))
{
case GPG_ERR_NO_ERROR:
fill_signing_result();
break;
case GPG_ERR_INV_VALUE:
throw SRC_BUG;
case GPG_ERR_NO_DATA:
throw Erange("crypto_asym::decrypt", gettext("No data to decrypt"));
case GPG_ERR_DECRYPT_FAILED:
throw Erange("crypto_asym::decrypt", gettext("Invalid Cipher text"));
case GPG_ERR_BAD_PASSPHRASE:
throw Erange("crypto_asym::decrypt", gettext("Failed retreiving passphrase"));
default:
throw Erange("crypto_asym::decrypt", string(gettext("Unexpected error reported by GPGME: ")) + tools_gpgme_strerror_r(err));
}
#else
throw Efeature("Asymetric Strong encryption algorithms using GPGME");
#endif
}
void crypto_asym::set_signatories(const std::vector<std::string> & signatories)
{
#if GPGME_SUPPORT
gpgme_key_t *signatories_key = NULL;
if(signatories.empty())
{
gpgme_signers_clear(context);
has_signatories = false;
}
else
{
build_key_list(signatories, signatories_key, true);
try
{
gpgme_signers_clear(context);
gpgme_key_t *ptr = signatories_key;
gpgme_error_t err;
if(ptr == NULL)
throw SRC_BUG; // build_key_list failed
while(*ptr != NULL)
{
err = gpgme_signers_add(context, *ptr);
switch(gpgme_err_code(err))
{
case GPG_ERR_NO_ERROR:
break;
default:
throw Erange("crypto_asym::encrypt", string(gettext("Unexpected error reported by GPGME: ")) + tools_gpgme_strerror_r(err));
}
++ptr;
}
}
catch(...)
{
release_key_list(signatories_key);
gpgme_signers_clear(context);
has_signatories = false;
throw;
}
release_key_list(signatories_key);
has_signatories = true;
}
#else
throw Efeature("Asymetric Strong encryption algorithms using GPGME");
#endif
}
void crypto_asym::encrypt(const vector<string> & recipients_email, generic_file & clear, generic_file & ciphered)
{
#if GPGME_SUPPORT
gpgme_key_t *ciphering_keys = NULL;
build_key_list(recipients_email, ciphering_keys, false);
try
{
generic_file_overlay_for_gpgme o_clear = &clear;
generic_file_overlay_for_gpgme o_ciphered = &ciphered;
gpgme_error_t err;
if(!has_signatories)
err = gpgme_op_encrypt(context,
ciphering_keys,
(gpgme_encrypt_flags_t)(GPGME_ENCRYPT_NO_ENCRYPT_TO|GPGME_ENCRYPT_ALWAYS_TRUST),
o_clear.get_gpgme_handle(),
o_ciphered.get_gpgme_handle());
else
err = gpgme_op_encrypt_sign(context,
ciphering_keys,
(gpgme_encrypt_flags_t)(GPGME_ENCRYPT_NO_ENCRYPT_TO|GPGME_ENCRYPT_ALWAYS_TRUST),
o_clear.get_gpgme_handle(),
o_ciphered.get_gpgme_handle());
switch(gpgme_err_code(err))
{
case GPG_ERR_NO_ERROR:
break;
case GPG_ERR_INV_VALUE:
throw SRC_BUG;
case GPG_ERR_UNUSABLE_PUBKEY:
throw Erange("crypto_asym::encrypt", gettext("Key found but users are not all trusted"));
default:
throw Erange("crypto_asym::encrypt", string(gettext("Unexpected error reported by GPGME: ")) + tools_gpgme_strerror_r(err));
}
}
catch(...)
{
release_key_list(ciphering_keys);
throw;
}
release_key_list(ciphering_keys);
#else
throw Efeature("Asymetric Strong encryption algorithms using GPGME");
#endif
}
U_I compressor::lzo_read(char *a, U_I size)
{
#if LIBLZO2_AVAILABLE
U_I read = 0;
while(read < size && !lzo_read_reached_eof)
{
U_I available = lzo_read_size - lzo_read_start;
U_I to_read = size - read;
if(available > to_read)
{
(void)memcpy(a+read, lzo_read_buffer+lzo_read_start, to_read);
lzo_read_start += to_read;
read += to_read;
}
else
{
if(available > 0)
{
(void)memcpy(a+read, lzo_read_buffer+lzo_read_start, available);
lzo_read_start += available;
read += available;
}
if(lzo_read_start < lzo_read_size)
throw SRC_BUG;
lzo_read_and_uncompress_to_buffer();
lzo_read_reached_eof = (lzo_read_size == 0); // either true or false
}
}
return read;
#else
throw Efeature(gettext("lzo compression"));
#endif
}
sar(const sar & ref) : generic_file(ref), mem_ui(ref) { throw Efeature("class sar's copy constructor is not implemented"); };
void compressor::lzo_read_and_uncompress_to_buffer()
{
#if LIBLZO2_AVAILABLE
lzo_block_header lzo_bh;
lzo_uint compr_size;
int status;
#if LZO1X_MEM_DECOMPRESS > 0
char wrkmem[LZO1X_MEM_DECOMPRESS];
#else
char *wrkmem = NULL;
#endif
if(compressed == NULL)
throw SRC_BUG;
lzo_bh.set_from(*compressed);
if(lzo_bh.type != BLOCK_HEADER_LZO && lzo_bh.type != BLOCK_HEADER_EOF)
throw Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("data corruption detected: Incoherence in LZO compressed data"));
if(lzo_bh.type == BLOCK_HEADER_EOF)
{
if(lzo_bh.size != 0)
throw Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("compressed data corruption detected"));
lzo_read_size = 0;
lzo_read_start = 0;
}
else
{
lzo_uint read;
if(lzo_bh.size > LZO_COMPRESSED_BUFFER_SIZE)
#if !defined(SSIZE_MAX) || SSIZE_MAX > BUFFER_SIZE
throw Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("data corruption detected: Too large block of compressed data"));
#else
throw Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("Too large block of compressed data: Either due to data corruption or current system limitation where SSIZE_MAX value implied smaller buffers than required"));
#endif
compr_size = 0;
lzo_bh.size.unstack(compr_size);
if(lzo_bh.size != 0)
throw SRC_BUG;
read = compressed->read(lzo_compressed, compr_size);
if(read != compr_size)
Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("compressed data corruption detected"));
read = LZO_CLEAR_BUFFER_SIZE;
status = lzo1x_decompress_safe((lzo_bytep)lzo_compressed, compr_size, (lzo_bytep)lzo_read_buffer, &read, wrkmem);
lzo_read_size = read;
lzo_read_start = 0;
switch(status)
{
case LZO_E_OK:
break; // all is fine
case LZO_E_INPUT_NOT_CONSUMED:
throw SRC_BUG;
default:
lzo_read_size = 0;
throw Erange("compressor::lzo_read_and_uncompress_to_buffer", gettext("compressed data corruption detected"));
}
}
#else
throw Efeature(gettext("lzo compression"));
#endif
}
