void save_binary_chunk(void const* address, std::size_t count) // override { if (filter_ || chunks_ == 0 || count < HPX_ZERO_COPY_SERIALIZATION_THRESHOLD) { // fall back to serialization_chunk-less archive this->output_container::save_binary(address, count); } else { HPX_ASSERT(get_num_chunks() > current_chunk_); HPX_ASSERT( get_chunk_type(current_chunk_) == chunk_type_index || get_chunk_size(current_chunk_) != 0); // complement current serialization_chunk by setting its length if (get_chunk_type(current_chunk_) == chunk_type_index) { HPX_ASSERT(get_chunk_size(current_chunk_) == 0); set_chunk_size(current_chunk_, current_ - get_chunk_data(current_chunk_).index_); } // add a new serialization_chunk referring to the external buffer chunks_->push_back(create_pointer_chunk(address, count)); ++current_chunk_; } }
void save_binary(void const* address, std::size_t count) // override { HPX_ASSERT(count != 0); { if (filter_) { filter_->save(address, count); } else { // make sure there is a current serialization_chunk descriptor // available if (chunks_) { HPX_ASSERT(get_num_chunks() > current_chunk_); if (get_chunk_type(current_chunk_) == chunk_type_pointer || get_chunk_size(current_chunk_) != 0) { // add a new serialization_chunk chunks_->push_back(create_index_chunk(current_, 0)); ++current_chunk_; } } if (cont_.size() < current_ + count) cont_.resize(cont_.size() + count); if (count == 1) cont_[current_] = *static_cast<unsigned char const*>(address); else std::memcpy(&cont_[current_], address, count); } current_ += count; } }
void set_filter(binary_filter* filter) // override { HPX_ASSERT(0 == filter_); filter_ = filter; start_compressing_at_ = current_; if (chunks_) { HPX_ASSERT(get_num_chunks() == 1 && get_chunk_size(0) == 0); chunks_->clear(); } }
static int htc_aes_crypt(FILE *in, FILE *out, char *key, char *iv, unsigned char chunks_in, htc_aes_progress_t callback, htc_aes_crypt_t crypt_func) { char buf[HTC_AES_READBUF], orig_iv[HTC_AES_KEYSIZE]; unsigned int pos, size, chunks, bytes, chunksdone = 0; unsigned int count = HTC_AES_READBUF_ROUNDS + 1; unsigned int chunk_size = (((int)chunks_in)<<HTC_AES_CHUNK_SIZE); MCRYPT td; /* Get size of zip data. */ pos = ftell(in); fseek(in, 0, SEEK_END); size = ftell(in) - pos; fseek(in, pos, SEEK_SET); chunks = get_num_chunks(size, chunk_size); td = mcrypt_module_open(MCRYPT_RIJNDAEL_128, NULL, MCRYPT_CBC, NULL); if(td == MCRYPT_FAILED) { perror("failed to open mcrypt module"); return 0; } memcpy(orig_iv, iv, HTC_AES_KEYSIZE); while((bytes = fread(buf, sizeof(char), sizeof(buf), in)) > 0) { if(callback) callback(ftell(in), size); if(chunksdone < chunks) { if((ftell(in) - bytes - pos) % chunk_size == 0) { count = 0; memcpy(iv, orig_iv, HTC_AES_KEYSIZE); } if(count < HTC_AES_READBUF_ROUNDS) { crypt_func(td, buf, sizeof(buf), key, iv); count++; } else if(count == HTC_AES_READBUF_ROUNDS) { chunksdone++; count++; } } fwrite(buf, sizeof(char), sizeof(buf), out); } mcrypt_module_close(td); return 1; }
void save_binary(void const* address, std::size_t count) // override { HPX_ASSERT(count != 0); { if (filter_) { filter_->save(address, count); } else { // make sure there is a current serialization_chunk descriptor // available if (chunks_) { HPX_ASSERT(get_num_chunks() > current_chunk_); if (get_chunk_type(current_chunk_) == chunk_type_pointer || get_chunk_size(current_chunk_) != 0) { // add a new serialization_chunk, reuse chunks, // if possible // the chunk size will be set at the end if (chunks_->size() <= current_chunk_ + 1) { chunks_->push_back( create_index_chunk(current_, 0)); ++current_chunk_; } else { (*chunks_)[++current_chunk_] = create_index_chunk(current_, 0); } } } if (cont_.size() < current_ + count) cont_.resize(cont_.size() + count); detail::access_data<Container>::write( cont_, count, current_, address); } current_ += count; } }
~output_container() { if (filter_) { std::size_t written = 0; if (cont_.size() < current_) cont_.resize(current_); current_ = start_compressing_at_; do { bool flushed = filter_->flush(&cont_[current_], cont_.size()-current_, written); current_ += written; if (flushed) break; // resize container cont_.resize(cont_.size()*2); } while (true); cont_.resize(current_); // truncate container } else if (chunks_) { HPX_ASSERT(get_num_chunks() > current_chunk_); HPX_ASSERT( get_chunk_type(current_chunk_) == chunk_type_index || get_chunk_size(current_chunk_) != 0); // complement current serialization_chunk by setting its length if (get_chunk_type(current_chunk_) == chunk_type_index) { HPX_ASSERT(get_chunk_size(current_chunk_) == 0); set_chunk_size(current_chunk_, current_ - get_chunk_data(current_chunk_).index_); } } }