bytes_t Stream :: copy_all ( const bytes_t & num_bytes, const Stream & src ) const
{
FUNC_ENTRY ();
// a null ref should act like nothing was there
// the behavior of /dev/null is a different concept
if ( null_ref () )
return bytes_t ( 0 );
// access stream
StreamItf * itf = get_itf ( CAP_PROP_READ | CAP_WRITE );
// allocate buffer
bytes_t mtu = itf -> get_mtu ();
if ( num_bytes < mtu )
mtu = num_bytes;
Mem buffer = rsrc -> mmgr . alloc ( mtu, false );
// read from source
bytes_t num_read = src . read ( mtu, buffer, 0 );
if ( num_read == ( U64 ) 0 )
return num_read;
// write everything read
bytes_t total = write_all ( num_read, buffer, 0 );
assert ( total == num_read );
// enter loop to copy until end of stream
while ( 1 )
{
// TBD - must read with non-blocking timeout
num_read = src . read ( mtu, buffer, 0 );
if ( num_read == ( U64 ) 0 )
break;
bytes_t num_writ = write_all ( num_read, buffer, 0 );
assert ( num_writ == num_read );
total += num_writ;
}
return total;
}
bytes_t Stream :: write_all ( const bytes_t & num_bytes, const Mem & src, index_t start ) const
{
FUNC_ENTRY ();
if ( start < 0 )
THROW ( xc_param_err, "bad start index: %ld", start );
bytes_t size = src . size ();
if ( ( U64 ) start >= size )
return bytes_t ( 0 );
bytes_t all_bytes = size - ( U64 ) start;
if ( all_bytes > num_bytes )
all_bytes = num_bytes;
if ( null_ref () )
THROW ( xc_null_self_err, "wrote 0 of %lu bytes", ( U64 ) all_bytes );
StreamItf * itf = get_itf ( CAP_WRITE );
bytes_t mtu = itf -> get_mtu ();
bytes_t to_write = ( mtu < all_bytes ) ? mtu : all_bytes;
bytes_t total = itf -> write ( to_write, src, start );
while ( total < all_bytes )
{
to_write = all_bytes - total;
if ( mtu < to_write )
to_write = mtu;
bytes_t num_writ = itf -> write ( to_write, src, start + ( U64 ) total );
if ( num_writ == ( U64 ) 0 )
THROW ( xc_transfer_incomplete_err, "wrote %lu of %lu bytes", ( U64 ) total, ( U64 ) all_bytes );
total += num_writ;
}
return total;
}
static void echo_session(stackful_actor self)
{
log::logger_t& lg = self.get_context().get_logger();
try
{
boost::shared_ptr<ssl_socket_t> ssl_skt;
self->match("init").recv(ssl_skt);
ssl::stream<> skt(self, ssl_skt);
errcode_t ec;
skt.async_handshake(boost::asio::ssl::stream_base::server);
self->match(ssl::as_handshake).recv(ec);
GCE_VERIFY(!ec).except(ec);
amsg::zero_copy_buffer zbuf;
byte_t read_buff[256];
std::deque<bytes_t> write_queue;
echo_header hdr;
size_t const hdr_len = amsg::size_of(hdr);
match_t const recv_header = atom("header");
match_t const recv_body = atom("body");
skt.async_read(boost::asio::buffer(read_buff, hdr_len), message(recv_header));
while (true)
{
match_t type;
errcode_t ec;
self->match(recv_header, recv_body, tcp::as_send, type).recv(ec);
GCE_VERIFY(!ec).except(ec);
if (type == recv_header)
{
zbuf.set_read(read_buff, hdr_len);
amsg::read(zbuf, hdr);
GCE_VERIFY(!zbuf.bad()).except<std::runtime_error>();
skt.async_read(boost::asio::buffer(read_buff + hdr_len, hdr.size_), message(recv_body));
}
else if (type == recv_body)
{
zbuf.set_read(read_buff + hdr_len, hdr.size_);
std::string str;
amsg::read(zbuf, str);
GCE_VERIFY(!zbuf.bad()).except<std::runtime_error>();
//GCE_INFO(lg) << "server recved echo: " << str;
if (str == "bye")
{
break;
}
bool write_in_progress = !write_queue.empty();
write_queue.push_back(bytes_t(read_buff, hdr_len + hdr.size_));
if (!write_in_progress)
{
bytes_t const& echo = write_queue.front();
skt.async_write(boost::asio::buffer(echo.data(), echo.size()));
}
skt.async_read(boost::asio::buffer(read_buff, hdr_len), message(recv_header));
}
else
{
write_queue.pop_front();
if (!write_queue.empty())
{
bytes_t const& echo = write_queue.front();
skt.async_write(boost::asio::buffer(echo.data(), echo.size()));
}
}
}
skt.async_shutdown();
self->match(ssl::as_shutdown).recv();
}
catch (std::exception& ex)
{
GCE_ERROR(lg) << ex.what();
}
}
exhausted(const Arena& a,size_t n)
: SystemException(SYSTEM_EXCEPTION(SCIDB_SE_NO_MEMORY,SCIDB_LE_ARENA_EXHAUSTED) << a << bytes_t(n))
{}
bytes_t HGE_CALL HGE_Impl::Resource_Load(const char *filename, uint32_t *size)
{
static char *res_err = "Can't load resource: %s";
//resource_packs_item_t *resItem = m_resources;
char szName[_MAX_PATH];
char szZipName[_MAX_PATH];
unzFile zip;
unz_file_info file_info;
int done, i;
void * ptr;
HANDLE hF;
if (filename[0] == '\\' || filename[0] == '/' || filename[1] == ':')
goto _fromfile; // skip absolute paths
// Load from pack
strcpy(szName, filename);
strupr(szName);
for (i = 0; szName[i]; i++)
{
if (szName[i] == '/')
szName[i] = '\\';
}
//while (resItem)
// TODO: optimize this reopening shit out
for( auto itr = m_resources.begin(); itr != m_resources.end(); ++itr )
{
resource_packs_item_t & resItem = itr->second;
zip = unzOpen(resItem.filename.c_str());
done = unzGoToFirstFile(zip);
while (done == UNZ_OK)
{
unzGetCurrentFileInfo(zip, &file_info, szZipName, sizeof(szZipName), NULL, 0, NULL, 0);
strupr(szZipName);
for (i = 0; szZipName[i]; i++)
{
if (szZipName[i] == '/')
szZipName[i] = '\\';
}
if (!strcmp(szName, szZipName))
{
if (unzOpenCurrentFilePassword( zip, resItem.password.empty()
? resItem.password.c_str()
: nullptr ) != UNZ_OK)
{
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
ptr = malloc(file_info.uncompressed_size);
if (!ptr)
{
unzCloseCurrentFile(zip);
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
if (unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0)
{
unzCloseCurrentFile(zip);
unzClose(zip);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
unzCloseCurrentFile(zip);
unzClose(zip);
if (size)
*size = file_info.uncompressed_size;
return bytes_t( (char*)ptr );
}
done = unzGoToNextFile(zip);
}
unzClose(zip);
//resItem = resItem->next;
}
// Load from file
_fromfile:
hF = CreateFile(Resource_MakePath(filename), GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (hF == INVALID_HANDLE_VALUE)
{
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
file_info.uncompressed_size = GetFileSize(hF, NULL);
ptr = malloc(file_info.uncompressed_size);
if (!ptr)
{
CloseHandle(hF);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
if (ReadFile(hF, ptr, file_info.uncompressed_size, &file_info.uncompressed_size, NULL ) == 0)
{
CloseHandle(hF);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
CloseHandle(hF);
if (size)
*size = file_info.uncompressed_size;
return bytes_t( (char*)ptr);
}
