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