SSLStateMachine *SSLStateMachine_new(const char *szCertificateFile,
const char *szKeyFile)
{
SSLStateMachine *pMachine=malloc(sizeof *pMachine);
int n;
die_unless(pMachine);
pMachine->pCtx=SSL_CTX_new(SSLv23_server_method());
die_unless(pMachine->pCtx);
n=SSL_CTX_use_certificate_file(pMachine->pCtx,szCertificateFile,
SSL_FILETYPE_PEM);
die_unless(n > 0);
n=SSL_CTX_use_PrivateKey_file(pMachine->pCtx,szKeyFile,SSL_FILETYPE_PEM);
die_unless(n > 0);
pMachine->pSSL=SSL_new(pMachine->pCtx);
die_unless(pMachine->pSSL);
pMachine->pbioRead=BIO_new(BIO_s_mem());
pMachine->pbioWrite=BIO_new(BIO_s_mem());
SSL_set_bio(pMachine->pSSL,pMachine->pbioRead,pMachine->pbioWrite);
SSL_set_accept_state(pMachine->pSSL);
return pMachine;
}
int main()
{
#if STXXL_PARALLEL_MULTIWAY_MERGE
LOG1 << "STXXL_PARALLEL_MULTIWAY_MERGE";
#endif
// special parameter type
using InputType = stxxl::stream::from_sorted_sequences<value_type>;
using CreateRunsAlg = stxxl::stream::runs_creator<
InputType, Cmp, 4096, foxxll::random_cyclic>;
using SortedRunsType = CreateRunsAlg::sorted_runs_type;
unsigned input_size = (10 * megabyte / sizeof(value_type));
Cmp c;
CreateRunsAlg SortedRuns(c, 10 * megabyte);
value_type checksum_before(0);
std::mt19937_64 randgen;
std::uniform_int_distribution<unsigned> distr_value;
for (unsigned cnt = input_size; cnt > 0; )
{
std::uniform_int_distribution<unsigned> distr_size(1, cnt);
unsigned run_size = distr_size(randgen); // random run length
cnt -= run_size;
LOG1 << "current run size: " << run_size;
std::vector<unsigned> tmp(run_size); // create temp storage for current run
// fill with random numbers
std::generate(tmp.begin(), tmp.end(), std::bind(distr_value, std::ref(randgen)) _STXXL_FORCE_SEQUENTIAL);
std::sort(tmp.begin(), tmp.end(), c); // sort
for (unsigned j = 0; j < run_size; ++j)
{
checksum_before += tmp[j];
SortedRuns.push(tmp[j]); // push sorted values to the current run
}
SortedRuns.finish(); // finish current run
}
SortedRunsType Runs = SortedRuns.result(); // get sorted_runs data structure
die_unless(check_sorted_runs(Runs, Cmp()));
// merge the runs
stxxl::stream::runs_merger<SortedRunsType, Cmp> merger(Runs, Cmp(), 10 * megabyte);
stxxl::vector<value_type, 4, stxxl::lru_pager<8> > array;
LOG1 << input_size << " " << Runs->elements;
LOG1 << "checksum before: " << checksum_before;
value_type checksum_after(0);
for (unsigned i = 0; i < input_size; ++i)
{
checksum_after += *merger;
array.push_back(*merger);
++merger;
}
LOG1 << "checksum after: " << checksum_after;
die_unless(stxxl::is_sorted(array.cbegin(), array.cend(), Cmp()));
die_unless(checksum_before == checksum_after);
die_unless(merger.empty());
return 0;
}
ReadStreamPtr Hdfs3OpenReadStream(
const std::string& _path, const common::Range& range) {
std::string path = _path;
// crop off hdfs://
die_unless(common::StartsWith(path, "hdfs://"));
path = path.substr(7);
// split uri into host/path
std::vector<std::string> splitted = common::Split(path, '/', 2);
die_unless(splitted.size() == 2);
// prepend root /
splitted[1] = "/" + splitted[1];
hdfsFS fs = Hdfs3FindConnection(splitted[0]);
// construct file handler
hdfsFile file = hdfsOpenFile(
fs, splitted[1].c_str(), O_RDONLY, /* bufferSize */ 0,
/* replication */ 0, /* blocksize */ 0);
if (!file)
die("Could not open HDFS file \"" << _path << "\": " << hdfsGetLastError());
return tlx::make_counting<Hdfs3ReadStream>(
fs, file, /* start_byte */ range.begin, /* byte_count */ range.size());
}
expression *parse_expression_from_string(char *text){
List *l = parse_expressions_from_string(text);
die_unless(l != NULL && l->cdr == NULL, "List should have a single element");
expression *exp = l->car;
my_free(l);
return exp;
}
void mapper_slot_print(mapper_slot slot)
{
printf("%s/%s", slot->signal->device->name, slot->signal->name);
int i = 0;
const char *key;
char type;
const void *val;
int length;
while (!mapper_slot_property_index(slot, i++, &key, &length, &type, &val)) {
die_unless(val!=0, "returned zero value\n");
// already printed these
if (strcmp(key, "device_name")==0 || strcmp(key, "signal_name")==0)
continue;
if (length) {
printf(", %s=", key);
if (strncmp(key, "bound", 5)==0) {
int bound = *(int*)val;
if (bound > 0 && bound < NUM_MAPPER_BOUNDARY_ACTIONS)
printf("%s", mapper_boundary_action_strings[bound]);
else
printf("undefined");
}
else
mapper_property_print(length, type, val);
}
}
}
void test(uint64_t data_mem, size_t memory_to_use, int seed)
{
uint64_t records_to_sort = data_mem / sizeof(T);
using vector_type = stxxl::vector<T, 2, stxxl::lru_pager<8>, block_size, alloc_strategy_type>;
vector_type v(records_to_sort);
using cmp = typename T::compare_less;
size_t ndisks = foxxll::config::get_instance()->disks_number();
LOG1 << "Sorting " << records_to_sort << " records of size " << sizeof(T);
LOG1 << "Total volume " << (records_to_sort * sizeof(T)) / MB << " MiB";
LOG1 << "Using " << memory_to_use / MB << " MiB";
LOG1 << "Using " << ndisks << " disks";
LOG1 << "Using " << alloc_strategy_type::name() << " allocation strategy ";
LOG1 << "Block size " << vector_type::block_type::raw_size / 1024 << " KiB";
LOG1 << "Filling vector...";
random_fill_vector(v, [](uint64_t x) -> T { return T(static_cast<uint32_t>(x)); }, seed);
LOG1 << "Sorting vector...";
foxxll::stats_data before(*foxxll::stats::get_instance());
stxxl::sort(v.begin(), v.end(), cmp(), memory_to_use);
foxxll::stats_data after(*foxxll::stats::get_instance());
LOG1 << "Checking order...";
die_unless(stxxl::is_sorted(v.cbegin(), v.cend(), cmp()));
LOG1 << "Sorting: " << (after - before);
LOG1 << "Total: " << *foxxll::stats::get_instance();
}
void printlink(mapper_db_link link)
{
printf(" %s -> %s", link->src_name, link->dest_name);
int i=0;
const char *key;
char type;
const void *val;
int length;
while(!mapper_db_link_property_index(link, i++, &key, &type,
&val, &length))
{
die_unless(val!=0, "returned zero value\n");
// already printed these
if (strcmp(key, "src_name")==0
|| strcmp(key, "dest_name")==0)
continue;
if (length) {
printf(", %s=", key);
mapper_prop_pp(type, length, val);
}
}
printf("\n");
}
void printconnection(mapper_db_connection con)
{
printf(" %s -> %s", con->src_name, con->dest_name);
int i=0;
const char *key;
char type;
const void *val;
int length;
while(!mapper_db_connection_property_index(con, i++, &key, &type,
&val, &length))
{
die_unless(val!=0, "returned zero value\n");
// already printed these
if (strcmp(key, "src_name")==0
|| strcmp(key, "dest_name")==0)
continue;
if (length) {
printf(", %s=", key);
if (strcmp(key, "mode")==0)
printf("%s", mode_strings[*((int*)val)]);
else if (strncmp(key, "bound", 5)==0)
printf("%s", bound_strings[*((int*)val)]);
else
mapper_prop_pp(type, length, val);
}
}
printf("\n");
}
void test(size_t data_mem, size_t memory_to_use, uint64_t seed)
{
size_t records_to_sort = data_mem / sizeof(T);
using vector_type = stxxl::vector<T, 2, stxxl::lru_pager<8>, block_size, alloc_strategy_type>;
memory_to_use = foxxll::div_ceil(memory_to_use, vector_type::block_type::raw_size) * vector_type::block_type::raw_size;
vector_type v(records_to_sort);
size_t ndisks = foxxll::config::get_instance()->disks_number();
LOG1 << "Sorting " << records_to_sort << " records of size " << sizeof(T);
LOG1 << "Total volume " << (records_to_sort * sizeof(T)) / MB << " MiB";
LOG1 << "Using " << memory_to_use / MB << " MiB";
LOG1 << "Using " << ndisks << " disks";
LOG1 << "Using " << alloc_strategy_type::name() << " allocation strategy ";
LOG1 << "Block size " << vector_type::block_type::raw_size / 1024 << " KiB";
random_fill_vector(v, seed);
LOG1 << "Sorting vector...";
foxxll::stats_data before(*foxxll::stats::get_instance());
using get_key = typename T::key_extract;
stxxl::stable_ksort(v.begin(), v.end(), get_key(), memory_to_use);
foxxll::stats_data after(*foxxll::stats::get_instance());
LOG1 << "Checking order...";
die_unless(stxxl::is_sorted(v.cbegin(), v.cend()));
LOG1 << "Sorting: " << (after - before);
LOG1 << "Total: " << *foxxll::stats::get_instance();
}
Hdfs3ReadStream(hdfsFS fs, hdfsFile file,
uint64_t start_byte, uint64_t /* byte_count */)
: fs_(fs), file_(file) {
int err = hdfsSeek(fs_, file_, start_byte);
die_unless(err == 0);
}
void printsignal(mapper_db_signal sig)
{
printf(" %s name=%s%s",
sig->is_output ? "output" : "input",
sig->device_name, sig->name);
int i=0;
const char *key;
char type;
const void *val;
int length;
while(!mapper_db_signal_property_index(sig, i++, &key, &type,
&val, &length))
{
die_unless(val!=0, "returned zero value\n");
// already printed these
if (strcmp(key, "device_name")==0
|| strcmp(key, "name")==0
|| strcmp(key, "direction")==0)
continue;
if (length) {
printf(", %s=", key);
mapper_prop_pp(type, length, val);
}
}
printf("\n");
}
void printdevice(mapper_db_device dev)
{
printf(" %s", dev->name);
int i=0;
const char *key;
char type;
const void *val;
int length;
while(!mapper_db_device_property_index(dev, i++, &key, &type,
&val, &length))
{
die_unless(val!=0, "returned zero value\n");
// already printed this
if (strcmp(key, "name")==0)
continue;
if (strcmp(key, "synced")==0) {
// check current time
mapper_timetag_t now;
mapper_monitor_now(mon, &now);
mapper_timetag_t *tt = (mapper_timetag_t *)val;
if (tt->sec == 0)
printf(", seconds_since_sync=unknown");
else
printf(", seconds_since_sync=%f",
mapper_timetag_difference(now, *tt));
}
else if (length) {
printf(", %s=", key);
mapper_prop_pp(type, length, val);
}
}
printf("\n");
}
const char *mapper_get_boundary_action_string(mapper_boundary_action bound)
{
die_unless(bound < N_MAPPER_BOUNDARY_ACTIONS,
"called mapper_get_boundary_action_string() with "
"bad parameter.\n");
return mapper_boundary_action_strings[bound];
}
const char *mapper_get_clipping_type_string(mapper_clipping_type clipping)
{
die_unless(clipping < N_MAPPER_CLIPPING_TYPES && clipping >= 0,
"called mapper_get_clipping_type_string() with "
"bad parameter.\n");
return mapper_clipping_type_strings[clipping];
}
const char *mapper_get_mode_type_string(mapper_mode_type mode)
{
die_unless(mode < N_MAPPER_MODE_TYPES,
"called mapper_get_mode_type_string() with "
"bad parameter.\n");
return mapper_mode_type_strings[mode];
}
int main()
{
// Create a vector with 3 default Test objects (-1) and reserved space for 6 objects.
// Content afterwards: {-1,-1,-1}
stxxl::swap_vector<Test> vec(3, 6);
// Push back 10 values from 0 to 9. Internally a swap resize will happen
// Content afterwards: {-1,-1,-1,0,1,2,3,4,5,6,7,8,9}
for (unsigned i = 0; i < 10; ++i) {
Test a(i);
vec.swap_back(a);
}
// Delete the third and the fourth object.
// Content afterwards: {-1,-1,1,2,3,4,5,6,7,8,9}
vec.erase(vec.begin() + 2, vec.begin() + 4);
// Delete the sixth object.
// Content afterwards: {-1,-1,1,2,3,5,6,7,8,9}
vec.erase(vec.begin() + 5);
// Check the values.
int expected_vals[10] = { -1, -1, 1, 2, 3, 5, 6, 7, 8, 9 };
die_unequal(vec.size(), 10u);
for (unsigned i = 0; i < vec.size(); ++i) {
die_unequal(vec[i].get_i(), expected_vals[i]);
}
// std::remove_if would fail because it makes use of copy assignment.
// We test stxxl's swap_remove_if implementation instead.
// STL: vec.erase(std::remove_if(vec.begin(), vec.end(), test_eraser()), vec.end());
vec.erase(stxxl::swap_remove_if(vec.begin(), vec.end(), test_eraser()), vec.end());
// Check the values.
int expected_vals2[10] = { 1, 2, 3, 5, 6, 7, 9 };
die_unequal(vec.size(), 7u);
for (unsigned i = 0; i < vec.size(); ++i) {
die_unequal(vec[i].get_i(), expected_vals2[i]);
}
// Clear the vector.
vec.clear();
die_unless(vec.empty());
// Resize to 100 and overwrite the last value.
// Content after resize and overwrite: {...,-1,100}
// Note: clear() does not overwrite any values in the underlaying array.
vec.resize(20);
Test t(11);
std::swap(vec[19], t);
// Check the values.
die_unequal(vec.size(), 20u);
die_unequal(vec[19].get_i(), 11);
return EXIT_SUCCESS;
}
void Hdfs3Glob(const std::string& _path, const GlobType& gtype,
FileList& filelist) {
std::string path = _path;
// crop off hdfs://
die_unless(common::StartsWith(path, "hdfs://"));
path = path.substr(7);
// split uri into host/path
std::vector<std::string> splitted = common::Split(path, '/', 2);
hdfsFS fs = Hdfs3FindConnection(splitted[0]);
std::string hosturi = "hdfs://" + splitted[0];
// prepend root /
splitted[1] = "/" + splitted[1];
// list directory
int num_entries = 0;
hdfsFileInfo* list = hdfsListDirectory(
fs, splitted[1].c_str(), &num_entries);
if (!list) return;
for (int i = 0; i < num_entries; ++i) {
FileInfo fi;
fi.path = list[i].mName;
// remove leading slashes
while (fi.path.size() >= 2 && fi.path[0] == '/' && fi.path[1] == '/')
fi.path.erase(fi.path.begin(), fi.path.begin() + 1);
// prepend host uri
fi.path = hosturi + fi.path;
if (list[i].mKind == kObjectKindFile) {
if (gtype == GlobType::All || gtype == GlobType::File) {
// strangely full file name globs return the file with a / at
// the end.
while (fi.path.back() == '/')
fi.path.resize(fi.path.size() - 1);
fi.type = Type::File;
fi.size = list[i].mSize;
filelist.emplace_back(fi);
}
}
else if (list[i].mKind == kObjectKindDirectory) {
if (gtype == GlobType::All || gtype == GlobType::Directory) {
fi.type = Type::Directory;
fi.size = list[i].mSize;
filelist.emplace_back(fi);
}
}
}
hdfsFreeFileInfo(list, num_entries);
}
Hash *frame_create(List *args, List *values){
Hash *frame = create_empty_frame();
while (args != NULL && values != NULL){
frame_add(frame, args->car, values->car);
args = args->cdr;
values = values->cdr;
}
die_unless(args == NULL && values == NULL, "Arg names and values have different lengths");
return frame;
}
tlx::CountingPtr<Subclass> GetOrDie(Id object_id) {
auto it = map_.find(object_id);
if (it != map_.end()) {
die_unless(dynamic_cast<Subclass*>(it->second.get()));
return tlx::CountingPtr<Subclass>(
dynamic_cast<Subclass*>(it->second.get()));
}
die("object " + std::to_string(object_id) + " not in repository");
}
int main(int argc, char* argv[])
{
size_t nins;
{
die_verbose_if(argc < 2, "Usage: " << argv[0] << " #log_ins");
const auto log_nins = foxxll::atoi64(argv[1]);
die_verbose_if(log_nins > 31, "This test can't do more than 2^31 operations, you requested 2^" << log_nins);
nins = 1ULL << log_nins;
}
// prepare random unique keys
stxxl::vector<key_type> values(nins);
std::mt19937_64 randgen;
{
random_fill_vector(values, randgen);
LOG1 << "Sorting the random values";
stxxl::sort(values.begin(), values.end(), comp_type(), 128 * 1024 * 1024);
LOG1 << "Deleting duplicate values";
{
auto new_end = std::unique(values.begin(), values.end());
values.resize(std::distance(values.begin(), new_end));
}
LOG1 << "Randomly permute input values";
stxxl::shuffle(values.begin(), values.end(), randgen, 128 * 1024 * 1024);
}
btree_type BTree(1024 * 128, 1024 * 128);
{
LOG1 << "Inserting " << values.size() << " random values into btree";
for (auto it = values.cbegin(); it != values.cend(); ++it)
BTree.insert({ *it, static_cast<payload_type>(*it + 1) });
LOG1 << "Number of elements in btree: " << BTree.size();
}
{
LOG1 << "Searching " << values.size() << " existing elements and erasing them";
for (auto it = values.cbegin(); it != values.cend(); ++it) {
auto bIt = BTree.find(*it);
die_unless(bIt != BTree.end());
// erasing non-existent element
die_unless(BTree.erase((*it) + 1) == 0);
// erasing existing element
die_unless(BTree.erase(*it) == 1);
// checking it is not there
die_unless(BTree.find(*it) == BTree.end());
// trying to erase it again
die_unless(BTree.erase(*it) == 0);
}
}
die_unless(BTree.empty());
LOG1 << "Test passed.";
return 0;
}
void Multiplexer::Close() {
std::unique_lock<std::mutex> lock(mutex_);
if (!d_->stream_sets_.map().empty()) {
LOG1 << "Multiplexer::Close()"
<< " remaining_streams=" << d_->stream_sets_.map().size();
die_unless(d_->stream_sets_.map().empty());
}
// destroy all still open Streams
d_->stream_sets_.map().clear();
closed_ = true;
}
tlx::CountingPtr<Subclass>
GetOrCreate(Id object_id, Types&& ... construction) {
auto it = map_.find(object_id);
if (it != map_.end()) {
die_unless(dynamic_cast<Subclass*>(it->second.get()));
return tlx::CountingPtr<Subclass>(
dynamic_cast<Subclass*>(it->second.get()));
}
// construct new object
tlx::CountingPtr<Subclass> value = tlx::make_counting<Subclass>(
std::forward<Types>(construction) ...);
map_.insert(std::make_pair(object_id, ObjectPtr(value)));
return value;
}
static int
xpcload_main(const char *name)
{
const char *mozhome = BOOST_PP_STRINGIZE(USE_XPCOM);
setenv("MOZILLA_FIVE_HOME", mozhome, 0);
nsCOMPtr<nsIServiceManager> servman;
nsresult rv = NS_InitXPCOM2(getter_AddRefs(servman), nsnull, nsnull);
die_unless(NS_SUCCEEDED(rv), "XPCOM init");
nsCOMPtr<nsISupports> obj = do_CreateInstance(name, &rv);
if (NS_SUCCEEDED(rv)) {
fprintf(stderr, "success\n");
} else {
fprintf(stderr, "failed\n");
const char *errstr = dlerror();
fprintf(stderr, "dlerror: %s\n", errstr);
}
rv = NS_ShutdownXPCOM(NULL);
return 0;
}
void Multiplexer::OnMixStreamBlock(
size_t peer, Connection& s, const StreamMultiplexerHeader& header,
const MixStreamDataPtr& stream, PinnedByteBlockPtr&& bytes) {
die_unless(d_->ongoing_requests_[peer] > 0);
d_->ongoing_requests_[peer]--;
sLOG << "Multiplexer::OnMixStreamBlock()"
<< "got block" << *bytes << "seq" << header.seq << "on" << s
<< "in MixStream" << header.stream_id
<< "from worker" << header.sender_worker;
stream->OnStreamBlock(
header.sender_worker, header.seq,
Block(std::move(bytes).ReleasePin(), /* begin */ 0, header.size,
header.first_item, header.num_items,
header.typecode_verify));
if (header.is_last_block)
stream->OnStreamBlock(header.sender_worker, header.seq + 1, Block());
AsyncReadMultiplexerHeader(peer, s);
}
void basic_test()
{
using value_type = std::pair<int, int>;
const size_t value_size = sizeof(value_type);
const size_t n_values = 6000;
const size_t n_tests = 3000;
// make sure all changes will be buffered (*)
const size_t buffer_size = n_values * (value_size + sizeof(int*));
const size_t mem_to_sort = 32 * 1024 * 1024;
const size_t subblock_raw_size = 4 * 1024;
const size_t block_size = 4;
using unordered_map = stxxl::unordered_map<int, int, hash_int, cmp,
subblock_raw_size, block_size>;
using iterator = unordered_map::iterator;
using const_iterator = unordered_map::const_iterator;
foxxll::stats_data stats_begin;
unordered_map map;
map.max_buffer_size(buffer_size);
const unordered_map& cmap = map;
// generate random values
std::vector<value_type> values1(n_values);
std::vector<value_type> values2(n_values);
std::vector<value_type> values3(n_values / 2);
{
auto broadcast = [](uint64_t x) -> value_type {
return {
x, x
};
};
random_fill_vector(values1, broadcast);
random_fill_vector(values2, broadcast);
random_fill_vector(values3, broadcast);
}
// --- initial import
std::cout << "Initial import...";
stats_begin = *foxxll::stats::get_instance();
die_unless(map.begin() == map.end());
map.insert(values1.begin(), values1.end(), mem_to_sort);
die_unless(map.begin() != map.end());
die_unless(map.size() == n_values);
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
// (*) all these values are stored in external memory; the remaining
// changes will be buffered in internal memory
// --- insert: new (from values2) and existing (from values1) values, with
// --- and without checking
std::cout << "Insert...";
stats_begin = *foxxll::stats::get_instance();
for (size_t i = 0; i < n_values / 2; i++) {
// new without checking
map.insert_oblivious(values2[2 * i]);
// new with checking
std::pair<iterator, bool> res = map.insert(values2[2 * i + 1]);
die_unless(res.second && (*(res.first)).first == values2[2 * i + 1].first);
// existing without checking
map.insert_oblivious(values1[2 * i]);
// exiting with checking
res = map.insert(values1[2 * i + 1]);
die_unless(!res.second && (*(res.first)).first == values1[2 * i + 1].first);
}
die_unless(map.size() == 2 * n_values);
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
// "old" values are stored in external memory, "new" values are stored in
// internal memory
// --- find: existing (from external and internal memory) and non-existing
// --- values
std::cout << "Find...";
stats_begin = *foxxll::stats::get_instance();
std::random_shuffle(values1.begin(), values1.end());
std::random_shuffle(values2.begin(), values2.end());
for (size_t i = 0; i < n_tests; i++) {
die_unless(cmap.find(values1[i].first) != cmap.end());
die_unless(cmap.find(values2[i].first) != cmap.end());
die_unless(cmap.find(values3[i].first) == cmap.end());
}
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
// --- insert with overwriting
std::cout << "Insert with overwriting...";
stats_begin = *foxxll::stats::get_instance();
std::random_shuffle(values1.begin(), values1.end());
std::random_shuffle(values2.begin(), values2.end());
for (size_t i = 0; i < n_tests; i++) {
value_type value1 = values1[i]; // in external memory
value1.second++;
map.insert_oblivious(value1);
value_type value2 = values2[i]; // in internal memory
value2.second++;
map.insert_oblivious(value2);
}
// now check
die_unless(map.size() == 2 * n_values); // nothing added, nothing removed
for (size_t i = 0; i < n_tests; i++) {
const_iterator it1 = cmap.find(values1[i].first);
const_iterator it2 = cmap.find(values2[i].first);
die_unless((*it1).second == values1[i].second + 1);
die_unless((*it2).second == values2[i].second + 1);
}
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
// --- erase: existing and non-existing values, with and without checking
std::cout << "Erase...";
stats_begin = *foxxll::stats::get_instance();
std::random_shuffle(values1.begin(), values1.end());
std::random_shuffle(values2.begin(), values2.end());
std::random_shuffle(values3.begin(), values3.end());
for (size_t i = 0; i < n_tests / 2; i++) { // external
// existing without checking
map.erase_oblivious(values1[2 * i].first);
// existing with checking
die_unless(map.erase(values1[2 * i + 1].first) == 1);
}
for (size_t i = 0; i < n_tests / 2; i++) { // internal
// existing without checking
map.erase_oblivious(values2[2 * i].first);
// existing with checking
die_unless(map.erase(values2[2 * i + 1].first) == 1);
// non-existing without checking
map.erase_oblivious(values3[i].first);
// non-existing with checking
}
die_unless(map.size() == 2 * n_values - 2 * n_tests);
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
map.clear();
die_unless(map.size() == 0);
// --- find and manipulate values by []-operator
// make sure there are some values in our unordered_map: externally
// [0..n/2) and internally [n/2..n) from values1
std::cout << "[ ]-operator...";
stats_begin = *foxxll::stats::get_instance();
map.insert(values1.begin(), values1.begin() + n_values / 2, mem_to_sort);
for (size_t i = n_values / 2; i < n_values; i++) {
map.insert_oblivious(values1[i]);
}
// lookup of existing values
die_unless(map[values1[5].first] == values1[5].second); // external
die_unless(map[values1[n_values / 2 + 5].first] == values1[n_values / 2 + 5].second); // internal
// manipulate existing values
++(map[values1[7].first]);
++(map[values1[n_values / 2 + 7].first]);
{
const_iterator cit1 = cmap.find(values1[7].first);
die_unless((*cit1).second == (*cit1).first + 1);
const_iterator cit2 = cmap.find(values1[n_values / 2 + 7].first);
die_unless((*cit2).second == (*cit2).first + 1);
}
// lookup of non-existing values
die_unless(map[values2[5].first] == unordered_map::mapped_type());
// assignment of non-existing values
map[values2[7].first] = values2[7].second;
{
const_iterator cit = cmap.find(values2[7].first);
die_unless((*cit).first == values2[7].second);
}
die_unless(map.size() == n_values + 2);
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
map.clear();
die_unless(map.size() == 0);
// --- additional bulk insert test
std::cout << "additional bulk-insert...";
stats_begin = *foxxll::stats::get_instance();
map.insert(values1.begin(), values1.begin() + n_values / 2, mem_to_sort);
map.insert(values1.begin() + n_values / 2, values1.end(), mem_to_sort);
die_unless(map.size() == n_values);
// lookup some random values
std::random_shuffle(values1.begin(), values1.end());
for (size_t i = 0; i < n_tests; i++)
die_unless(cmap.find(values1[i].first) != cmap.end());
std::cout << "passed" << std::endl;
LOG1 << foxxll::stats_data(*foxxll::stats::get_instance()) - stats_begin;
// --- test equality predicate
unordered_map::key_equal key_eq = map.key_eq();
die_unless(key_eq(42, 42));
die_unless(!key_eq(42, 6 * 9));
std::cout << "\nAll tests passed" << std::endl;
map.buffer_size();
}
static int tls_drv_control(ErlDrvData handle,
unsigned int command,
char *buf, int len,
char **rbuf, int rlen)
{
tls_data *d = (tls_data *)handle;
int res;
int size;
ErlDrvBinary *b;
X509 *cert;
unsigned int flags = command;
command &= 0xffff;
ERR_clear_error();
switch (command)
{
case SET_CERTIFICATE_FILE_ACCEPT:
case SET_CERTIFICATE_FILE_CONNECT: {
time_t mtime = 0;
SSL_CTX *ssl_ctx = hash_table_lookup(buf, &mtime);
if (is_key_file_modified(buf, &mtime) || ssl_ctx == NULL)
{
SSL_CTX *ctx;
hash_table_insert(buf, mtime, NULL);
ctx = SSL_CTX_new(SSLv23_method());
die_unless(ctx, "SSL_CTX_new failed");
res = SSL_CTX_use_certificate_chain_file(ctx, buf);
die_unless(res > 0, "SSL_CTX_use_certificate_file failed");
res = SSL_CTX_use_PrivateKey_file(ctx, buf, SSL_FILETYPE_PEM);
die_unless(res > 0, "SSL_CTX_use_PrivateKey_file failed");
res = SSL_CTX_check_private_key(ctx);
die_unless(res > 0, "SSL_CTX_check_private_key failed");
SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
SSL_CTX_set_default_verify_paths(ctx);
#ifdef SSL_MODE_RELEASE_BUFFERS
SSL_CTX_set_mode(ctx, SSL_MODE_RELEASE_BUFFERS);
#endif
if (command == SET_CERTIFICATE_FILE_ACCEPT)
{
SSL_CTX_set_verify(ctx,
SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
verify_callback);
}
ssl_ctx = ctx;
hash_table_insert(buf, mtime, ssl_ctx);
}
d->ssl = SSL_new(ssl_ctx);
die_unless(d->ssl, "SSL_new failed");
if (flags & VERIFY_NONE)
SSL_set_verify(d->ssl, SSL_VERIFY_NONE, verify_callback);
d->bio_read = BIO_new(BIO_s_mem());
d->bio_write = BIO_new(BIO_s_mem());
SSL_set_bio(d->ssl, d->bio_read, d->bio_write);
if (command == SET_CERTIFICATE_FILE_ACCEPT) {
SSL_set_options(d->ssl, SSL_OP_NO_TICKET);
SSL_set_accept_state(d->ssl);
} else {
SSL_set_options(d->ssl, SSL_OP_NO_SSLv2|SSL_OP_NO_TICKET);
SSL_set_connect_state(d->ssl);
}
break;
}
case SET_ENCRYPTED_INPUT:
die_unless(d->ssl, "SSL not initialized");
BIO_write(d->bio_read, buf, len);
break;
case SET_DECRYPTED_OUTPUT:
die_unless(d->ssl, "SSL not initialized");
res = SSL_write(d->ssl, buf, len);
if (res <= 0)
{
res = SSL_get_error(d->ssl, res);
if (res == SSL_ERROR_WANT_READ || res == SSL_ERROR_WANT_WRITE)
{
b = driver_alloc_binary(1);
b->orig_bytes[0] = 2;
*rbuf = (char *)b;
return 1;
} else {
die_unless(0, "SSL_write failed");
}
}
break;
case GET_ENCRYPTED_OUTPUT:
die_unless(d->ssl, "SSL not initialized");
size = BUF_SIZE + 1;
rlen = 1;
b = driver_alloc_binary(size);
b->orig_bytes[0] = 0;
while ((res = BIO_read(d->bio_write,
b->orig_bytes + rlen, BUF_SIZE)) > 0)
{
//printf("%d bytes of encrypted data read from state machine\r\n", res);
rlen += res;
size += BUF_SIZE;
b = driver_realloc_binary(b, size);
}
b = driver_realloc_binary(b, rlen);
*rbuf = (char *)b;
return rlen;
case GET_DECRYPTED_INPUT:
if (!SSL_is_init_finished(d->ssl))
{
res = SSL_do_handshake(d->ssl);
if (res <= 0)
die_unless(SSL_get_error(d->ssl, res) == SSL_ERROR_WANT_READ,
"SSL_do_handshake failed");
} else {
size = BUF_SIZE + 1;
rlen = 1;
b = driver_alloc_binary(size);
b->orig_bytes[0] = 0;
while ((res = SSL_read(d->ssl,
b->orig_bytes + rlen, BUF_SIZE)) > 0)
{
//printf("%d bytes of decrypted data read from state machine\r\n",res);
rlen += res;
size += BUF_SIZE;
b = driver_realloc_binary(b, size);
}
if (res < 0)
{
int err = SSL_get_error(d->ssl, res);
if (err == SSL_ERROR_WANT_READ)
{
//printf("SSL_read wants more data\r\n");
//return 0;
}
// TODO
}
b = driver_realloc_binary(b, rlen);
*rbuf = (char *)b;
return rlen;
}
break;
case GET_PEER_CERTIFICATE:
cert = SSL_get_peer_certificate(d->ssl);
if (cert == NULL)
{
b = driver_alloc_binary(1);
b->orig_bytes[0] = 1;
*rbuf = (char *)b;
return 1;
} else {
unsigned char *tmp_buf;
rlen = i2d_X509(cert, NULL);
if (rlen >= 0)
{
rlen++;
b = driver_alloc_binary(rlen);
b->orig_bytes[0] = 0;
tmp_buf = (unsigned char *)&b->orig_bytes[1];
i2d_X509(cert, &tmp_buf);
X509_free(cert);
*rbuf = (char *)b;
return rlen;
} else
X509_free(cert);
}
break;
case GET_VERIFY_RESULT:
b = driver_alloc_binary(1);
b->orig_bytes[0] = SSL_get_verify_result(d->ssl);
*rbuf = (char *)b;
return 1;
break;
}
b = driver_alloc_binary(1);
b->orig_bytes[0] = 0;
*rbuf = (char *)b;
return 1;
}
int mapper_connection_perform(mapper_connection connection,
mapper_signal_history_t *from,
mapper_signal_history_t **expr_vars,
mapper_signal_history_t *to,
char *typestring)
{
int changed = 0, i;
int vector_length = from->length < to->length ? from->length : to->length;
if (connection->props.muted)
return 0;
/* If the destination type is unknown, we can't do anything
* intelligent here -- even bypass mode might screw up if we
* assume the types work out. */
if (connection->props.dest_type != 'f'
&& connection->props.dest_type != 'i'
&& connection->props.dest_type != 'd')
{
return 0;
}
if (!connection->props.mode || connection->props.mode == MO_BYPASS)
{
/* Increment index position of output data structure. */
to->position = (to->position + 1) % to->size;
if (connection->props.src_type == connection->props.dest_type) {
memcpy(msig_history_value_pointer(*to),
msig_history_value_pointer(*from),
mapper_type_size(to->type) * vector_length);
memset(msig_history_value_pointer(*to) +
mapper_type_size(to->type) * vector_length, 0,
(to->length - vector_length) * mapper_type_size(to->type));
}
else if (connection->props.src_type == 'f') {
float *vfrom = msig_history_value_pointer(*from);
if (connection->props.dest_type == 'i') {
int *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (int)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
else if (connection->props.dest_type == 'd') {
double *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (double)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
}
else if (connection->props.src_type == 'i') {
int *vfrom = msig_history_value_pointer(*from);
if (connection->props.dest_type == 'f') {
float *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (float)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
else if (connection->props.dest_type == 'd') {
double *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (double)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
}
else if (connection->props.src_type == 'd') {
double *vfrom = msig_history_value_pointer(*from);
if (connection->props.dest_type == 'i') {
int *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (int)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
else if (connection->props.dest_type == 'f') {
float *vto = msig_history_value_pointer(*to);
for (i = 0; i < vector_length; i++) {
vto[i] = (float)vfrom[i];
}
for (; i < to->length; i++) {
vto[i] = 0;
}
}
}
for (i = 0; i < vector_length; i++) {
typestring[i] = to->type;
}
return 1;
}
else if (connection->props.mode == MO_EXPRESSION
|| connection->props.mode == MO_LINEAR)
{
die_unless(connection->expr!=0, "Missing expression.\n");
return (mapper_expr_evaluate(connection->expr, from, expr_vars,
to, typestring));
}
else if (connection->props.mode == MO_CALIBRATE)
{
/* Increment index position of output data structure. */
to->position = (to->position + 1) % to->size;
if (!connection->props.src_min) {
connection->props.src_min =
malloc(connection->props.src_length *
mapper_type_size(connection->props.src_type));
}
if (!connection->props.src_max) {
connection->props.src_max =
malloc(connection->props.src_length *
mapper_type_size(connection->props.src_type));
}
/* If calibration mode has just taken effect, first data
* sample sets source min and max */
if (connection->props.src_type == 'f') {
float *v = msig_history_value_pointer(*from);
float *src_min = (float*)connection->props.src_min;
float *src_max = (float*)connection->props.src_max;
if (!connection->calibrating) {
for (i = 0; i < from->length; i++) {
src_min[i] = v[i];
src_max[i] = v[i];
}
connection->calibrating = 1;
changed = 1;
}
else {
for (i = 0; i < from->length; i++) {
if (v[i] < src_min[i]) {
src_min[i] = v[i];
changed = 1;
}
if (v[i] > src_max[i]) {
src_max[i] = v[i];
changed = 1;
}
}
}
}
else if (connection->props.src_type == 'i') {
int *v = msig_history_value_pointer(*from);
int *src_min = (int*)connection->props.src_min;
int *src_max = (int*)connection->props.src_max;
if (!connection->calibrating) {
for (i = 0; i < from->length; i++) {
src_min[i] = v[i];
src_max[i] = v[i];
}
connection->calibrating = 1;
changed = 1;
}
else {
for (i = 0; i < from->length; i++) {
if (v[i] < src_min[i]) {
src_min[i] = v[i];
changed = 1;
}
if (v[i] > src_max[i]) {
src_max[i] = v[i];
changed = 1;
}
}
}
}
else if (connection->props.src_type == 'd') {
double *v = msig_history_value_pointer(*from);
double *src_min = (double*)connection->props.src_min;
double *src_max = (double*)connection->props.src_max;
if (!connection->calibrating) {
for (i = 0; i < from->length; i++) {
src_min[i] = v[i];
src_max[i] = v[i];
}
connection->calibrating = 1;
changed = 1;
}
else {
for (i = 0; i < from->length; i++) {
if (v[i] < src_min[i]) {
src_min[i] = v[i];
changed = 1;
}
if (v[i] > src_max[i]) {
src_max[i] = v[i];
changed = 1;
}
}
}
}
if (changed) {
mapper_connection_set_mode_linear(connection);
/* Stay in calibrate mode. */
connection->props.mode = MO_CALIBRATE;
}
if (connection->expr)
return (mapper_expr_evaluate(connection->expr, from, expr_vars,
to, typestring));
else
return 0;
}
return 1;
}
int mapper_connection_perform(mapper_connection connection,
mapper_signal sig,
mapper_signal_value_t *from_value,
mapper_signal_value_t *to_value)
{
int changed = 0;
float f = 0;
if (connection->props.muted)
return 0;
/* If the destination type is unknown, we can't do anything
* intelligent here -- even bypass mode might screw up if we
* assume the types work out. */
if (connection->props.dest_type != 'f'
&& connection->props.dest_type != 'i')
{
return 0;
}
if (!connection->props.mode || connection->props.mode == MO_BYPASS)
{
if (connection->props.src_type == connection->props.dest_type)
*to_value = *from_value;
else if (connection->props.src_type == 'f'
&& connection->props.dest_type == 'i')
to_value->i32 = (int)from_value->f;
else if (connection->props.src_type == 'i'
&& connection->props.dest_type == 'f')
to_value->f = (float)from_value->i32;
}
else if (connection->props.mode == MO_EXPRESSION
|| connection->props.mode == MO_LINEAR)
{
die_unless(connection->expr!=0, "Missing expression.\n");
*to_value = mapper_expr_evaluate(connection->expr, from_value);
}
else if (connection->props.mode == MO_CALIBRATE)
{
if (connection->props.src_type == 'f')
f = from_value->f;
else if (connection->props.src_type == 'i')
f = (float)from_value->i32;
/* If calibration mode has just taken effect, first data
* sample sets source min and max */
if (!connection->calibrating) {
connection->props.range.src_min = f;
connection->props.range.src_max = f;
connection->props.range.known |=
CONNECTION_RANGE_SRC_MIN | CONNECTION_RANGE_SRC_MAX;
connection->calibrating = 1;
changed = 1;
} else {
if (f < connection->props.range.src_min) {
connection->props.range.src_min = f;
connection->props.range.known |= CONNECTION_RANGE_SRC_MIN;
changed = 1;
}
if (f > connection->props.range.src_max) {
connection->props.range.src_max = f;
connection->props.range.known |= CONNECTION_RANGE_SRC_MAX;
changed = 1;
}
}
if (changed) {
mapper_connection_set_linear_range(connection, sig,
&connection->props.range);
/* Stay in calibrate mode. */
connection->props.mode = MO_CALIBRATE;
}
if (connection->expr)
*to_value = mapper_expr_evaluate(connection->expr, from_value);
}
return 1;
}
bool test_block_cache()
{
using value_type = std::pair<int, int>;
constexpr size_t magic1 = 0xc01ddead;
constexpr unsigned subblock_raw_size = 1024 * 8; // 8KB subblocks
constexpr unsigned block_size = 128; // 1MB blocks (=128 subblocks)
constexpr unsigned num_blocks = 64; // number of blocks to use for this test
constexpr unsigned cache_size = 8; // size of cache in blocks
using subblock_type = foxxll::typed_block<subblock_raw_size, value_type>;
using block_type = foxxll::typed_block<block_size* sizeof(subblock_type), subblock_type>;
constexpr unsigned subblock_size = subblock_type::size; // size in values
using bid_type = block_type::bid_type;
using bid_container_type = std::vector<bid_type>;
// prepare test: allocate blocks, fill them with values and write to disk
bid_container_type bids(num_blocks);
foxxll::block_manager* bm = foxxll::block_manager::get_instance();
bm->new_blocks(foxxll::striping(), bids.begin(), bids.end());
block_type* block = new block_type;
for (unsigned i_block = 0; i_block < num_blocks; i_block++) {
for (unsigned i_subblock = 0; i_subblock < block_size; i_subblock++) {
for (unsigned i_value = 0; i_value < subblock_size; i_value++) {
int value = i_value + i_subblock * subblock_size + i_block * block_size;
(*block)[i_subblock][i_value] = value_type(value, value);
}
}
foxxll::request_ptr req = block->write(bids[i_block]);
req->wait();
}
std::mt19937 randgen;
std::uniform_int_distribution<int> distr_num(0, num_blocks - 1);
std::uniform_int_distribution<int> distr_size(0, block_size - 1);
// create block_cache
using cache_type = stxxl::hash_map::block_cache<block_type>;
cache_type cache(cache_size);
// load random subblocks and check for values
int n_runs = cache_size * 10;
for (int i_run = 0; i_run < n_runs; i_run++) {
int i_block = distr_num(randgen);
int i_subblock = distr_size(randgen);
subblock_type* subblock = cache.get_subblock(bids[i_block], i_subblock);
int expected = i_block * block_size + i_subblock * subblock_size + 1;
die_unless((*subblock)[1].first == expected);
}
// do the same again but this time with prefetching
for (int i_run = 0; i_run < n_runs; i_run++) {
int i_block = distr_num(randgen);
int i_subblock = distr_size(randgen);
cache.prefetch_block(bids[i_block]);
subblock_type* subblock = cache.get_subblock(bids[i_block], i_subblock);
int expected = i_block * block_size + i_subblock * subblock_size + 1;
die_unless((*subblock)[1].first == expected);
}
// load and modify some subblocks; flush cache and check values
randgen.seed(magic1);
for (int i_run = 0; i_run < n_runs; i_run++) {
int i_block = distr_num(randgen);
int i_subblock = distr_size(randgen);
subblock_type* subblock = cache.get_subblock(bids[i_block], i_subblock);
die_unless(cache.make_dirty(bids[i_block]));
(*subblock)[1].first = (*subblock)[1].second + 42;
}
randgen.seed(magic1);
for (int i_run = 0; i_run < n_runs; i_run++) {
int i_block = distr_num(randgen);
int i_subblock = distr_size(randgen);
subblock_type* subblock = cache.get_subblock(bids[i_block], i_subblock);
int expected = i_block * block_size + i_subblock * subblock_size + 1;
die_unequal((*subblock)[1].first, expected + 42);
}
// test retaining
cache.clear();
// not yet cached
die_unless(cache.retain_block(bids[0]) == false);
cache.prefetch_block(bids[0]);
// cached, should be retained
die_unless(cache.retain_block(bids[0]) == true);
// release again
die_unless(cache.release_block(bids[0]) == true);
// retrain-count should be 0, release fails
die_unless(cache.release_block(bids[0]) == false);
// cache new block
subblock_type* kicked_subblock = cache.get_subblock(bids[1], 0);
// load other blocks, so that kicked_subblock, well, gets kicked
for (unsigned i = 0; i < cache_size + 5; i++) {
cache.prefetch_block(bids[i + 3]);
}
// load kicked subblock again, should be at a different location
die_unless(cache.get_subblock(bids[1], 0) != kicked_subblock);
subblock_type* retained_subblock = cache.get_subblock(bids[1], 0);
// now retain subblock
die_unless(cache.retain_block(bids[1]) == true);
for (unsigned i = 0; i < cache_size + 5; i++) {
cache.prefetch_block(bids[i + 3]);
}
// retained_subblock should not have been kicked
die_unless(cache.get_subblock(bids[1], 0) == retained_subblock);
cache.clear();
// test swapping
subblock_type* a_subblock = cache.get_subblock(bids[6], 1);
cache_type cache2(cache_size / 2);
std::swap(cache, cache2);
die_unless(cache.size() == cache_size / 2);
die_unless(cache2.size() == cache_size);
die_unless(cache2.get_subblock(bids[6], 1) == a_subblock);
delete block;
LOG1 << "Passed Block-Cache Test";
return true;
}
static int ejabberd_zlib_drv_control(ErlDrvData handle,
unsigned int command,
char *buf, int len,
char **rbuf, int rlen)
{
ejabberd_zlib_data *d = (ejabberd_zlib_data *)handle;
int err;
int size;
ErlDrvBinary *b;
switch (command)
{
case DEFLATE:
size = BUF_SIZE + 1;
rlen = 1;
b = driver_alloc_binary(size);
b->orig_bytes[0] = 0;
d->d_stream->next_in = (unsigned char *)buf;
d->d_stream->avail_in = len;
d->d_stream->avail_out = 0;
err = Z_OK;
while (err == Z_OK && d->d_stream->avail_out == 0)
{
d->d_stream->next_out = (unsigned char *)b->orig_bytes + rlen;
d->d_stream->avail_out = BUF_SIZE;
err = deflate(d->d_stream, Z_SYNC_FLUSH);
die_unless((err == Z_OK) || (err == Z_STREAM_END),
"Deflate error");
rlen += (BUF_SIZE - d->d_stream->avail_out);
size += (BUF_SIZE - d->d_stream->avail_out);
b = driver_realloc_binary(b, size);
}
b = driver_realloc_binary(b, rlen);
*rbuf = (char *)b;
return rlen;
case INFLATE:
size = BUF_SIZE + 1;
rlen = 1;
b = driver_alloc_binary(size);
b->orig_bytes[0] = 0;
if (len > 0) {
d->i_stream->next_in = (unsigned char *)buf;
d->i_stream->avail_in = len;
d->i_stream->avail_out = 0;
err = Z_OK;
while (err == Z_OK && d->i_stream->avail_out == 0)
{
d->i_stream->next_out = (unsigned char *)b->orig_bytes + rlen;
d->i_stream->avail_out = BUF_SIZE;
err = inflate(d->i_stream, Z_SYNC_FLUSH);
die_unless((err == Z_OK) || (err == Z_STREAM_END),
"Inflate error");
rlen += (BUF_SIZE - d->i_stream->avail_out);
size += (BUF_SIZE - d->i_stream->avail_out);
b = driver_realloc_binary(b, size);
}
}
b = driver_realloc_binary(b, rlen);
*rbuf = (char *)b;
return rlen;
}
b = driver_alloc_binary(1);
b->orig_bytes[0] = 0;
*rbuf = (char *)b;
return 1;
}
