// Read Handler, wird asynchron aufgerufen, wenn das OS signalisiert,
// dass Daten von STDIN gelesen werden koennen
void read_handler(const boost::system::error_code &ec, std::size_t bytes_transferred)
{
if (!ec)
{
std::cout.write(bytes.data(), bytes_transferred);
// weiter asynchron von STDIN lesen
in.async_read_some(boost::asio::buffer(bytes), read_handler);
}
}
void put_string(entry& e, std::array<char, 64>& sig
, std::uint64_t& seq
, std::string const& salt
, std::array<char, 32> const& pk
, std::array<char, 64> const& sk
, char const* str)
{
using libtorrent::dht::sign_mutable_item;
e = std::string(str);
std::vector<char> buf;
bencode(std::back_inserter(buf), e);
dht::signature sign;
++seq;
sign_mutable_item(buf, salt, dht::sequence_number(seq)
, dht::public_key(pk.data())
, dht::secret_key(sk.data()), sign);
sig = sign.bytes;
}
std::chrono::nanoseconds Encryption::DirectEncryptECB(void) {
rijndael_context rk;
rijndaelKeySetup(&rk, sc_key.data(), 256);
auto start = high_resolution_clock::now();
for (size_t i = 0; i < buffer.size(); i += 16) {
rijndaelEncrypt(&rk, &buffer[i], &buffer[i]);
}
return high_resolution_clock::now() - start;
}
ResultCode UpdateConfigNANDSavegame() {
FileSys::Mode mode = {};
mode.write_flag = 1;
mode.create_flag = 1;
FileSys::Path path("config");
auto file = cfg_system_save_data->OpenFile(path, mode);
_assert_msg_(Service_CFG, file != nullptr, "could not open file");
file->Write(0, CONFIG_SAVEFILE_SIZE, 1, cfg_config_file_buffer.data());
return RESULT_SUCCESS;
}
ResultCode FormatConfig() {
ResultCode res = DeleteConfigNANDSaveFile();
if (!res.IsSuccess())
return res;
// Delete the old data
cfg_config_file_buffer.fill(0);
// Create the header
SaveFileConfig* config = reinterpret_cast<SaveFileConfig*>(cfg_config_file_buffer.data());
// This value is hardcoded, taken from 3dbrew, verified by hardware, it's always the same value
config->data_entries_offset = 0x455C;
// Insert the default blocks
res = CreateConfigInfoBlk(0x00050005, sizeof(STEREO_CAMERA_SETTINGS), 0xE,
reinterpret_cast<const u8*>(STEREO_CAMERA_SETTINGS.data()));
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x00090001, sizeof(CONSOLE_UNIQUE_ID), 0xE,
reinterpret_cast<const u8*>(&CONSOLE_UNIQUE_ID));
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x000F0004, sizeof(CONSOLE_MODEL), 0x8,
reinterpret_cast<const u8*>(&CONSOLE_MODEL));
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x000A0002, sizeof(CONSOLE_LANGUAGE), 0xA, &CONSOLE_LANGUAGE);
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x00070001, sizeof(SOUND_OUTPUT_MODE), 0xE, &SOUND_OUTPUT_MODE);
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x000B0000, sizeof(COUNTRY_INFO), 0xE,
reinterpret_cast<const u8*>(&COUNTRY_INFO));
if (!res.IsSuccess())
return res;
res = CreateConfigInfoBlk(0x000A0000, sizeof(CONSOLE_USERNAME_BLOCK), 0xE,
reinterpret_cast<const u8*>(&CONSOLE_USERNAME_BLOCK));
if (!res.IsSuccess())
return res;
// Save the buffer to the file
res = UpdateConfigNANDSavegame();
if (!res.IsSuccess())
return res;
return RESULT_SUCCESS;
}
void
move(C<I>, const_iterator&& other)
{
if(n_ == I)
{
new(buf_.data()) iter_t<I>{
std::move(other.iter<I>())};
return;
}
move(C<I+1>{}, std::move(other));
}
void
copy(C<I>, const_iterator const& other)
{
if(n_ == I)
{
new(buf_.data()) iter_t<I>{
other.iter<I>()};
return;
}
copy(C<I+1>{}, other);
}
void
decrement(C<sizeof...(Bs)>)
{
auto constexpr I = sizeof...(Bs);
if(n_ == I)
{
--n_;
new(buf_.data()) iter_t<I-1>{
std::get<I-1>(*bs_).end()};
}
decrement(C<I-1>{});
}
virtual Real value(std::array<Real, Dimension + 1> coordinates)
const {
assert(interpolant);
// Pack and call
NaryMethodConst<Real, Interpolant<Dimension>,
Dimension, Real> tmp =
&Interpolant<Dimension>::operator();
return packAndCall<Dimension>(interpolant, tmp,
coordinates.data() + 1);
}
static bool WipeFile(const string& Name, int TotalPercent, bool& Cancel, ConsoleTitle* DeleteTitle)
{
bool Result = false;
api::SetFileAttributes(Name,FILE_ATTRIBUTE_NORMAL);
api::FileWalker WipeFile;
if(WipeFile.Open(Name, FILE_READ_DATA|FILE_WRITE_DATA, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_WRITE_THROUGH|FILE_FLAG_SEQUENTIAL_SCAN))
{
const DWORD BufSize=65536;
if(WipeFile.InitWalk(BufSize))
{
static std::array<BYTE, BufSize> Buf;
static bool BufInit = false;
if(!BufInit)
{
Buf.fill(Global->Opt->WipeSymbol); // используем символ заполнитель
BufInit = true;
}
DWORD StartTime=GetTickCount();
do
{
DWORD Written;
WipeFile.Write(Buf.data(), WipeFile.GetChunkSize(), Written);
DWORD CurTime=GetTickCount();
if (CurTime-StartTime>(DWORD)Global->Opt->RedrawTimeout)
{
StartTime=CurTime;
if (CheckForEscSilent() && ConfirmAbortOp())
{
Cancel=true;
return false;
}
ShellDeleteMsg(Name, DEL_WIPEPROCESS, TotalPercent, WipeFile.GetPercent(), DeleteTitle);
}
}
while(WipeFile.Step());
WipeFile.SetPointer(0,nullptr,FILE_BEGIN);
WipeFile.SetEnd();
}
WipeFile.Close();
string strTempName;
FarMkTempEx(strTempName,nullptr,FALSE);
Result = api::MoveFile(Name,strTempName) && api::DeleteFile(strTempName);
}
return Result;
}
void sc_synth::run_traced(void)
{
trace = 0;
#ifndef thread_local
spin_lock::scoped_lock lock (log_guard);
#endif
scratchpad_printer printer(trace_scratchpad.data());
printer.printf("\nTRACE %d %s #units: %d\n", id(), this->definition_name(), calc_unit_count);
for (size_t calc_unit_index = 0; calc_unit_index != calc_unit_count; ++calc_unit_index) {
Unit * unit = calc_units[calc_unit_index];
sc_ugen_def * def = reinterpret_cast<sc_ugen_def*>(unit->mUnitDef);
printer.printf(" unit %zd %s\n in ", calc_unit_index, def->name());
for (uint16_t j=0; j!=unit->mNumInputs; ++j) {
printer.printf(" %g", unit->mInBuf[j][0]);
if (printer.shouldFlush()) {
#ifdef thread_local
spin_lock::scoped_lock lock (log_guard);
#endif
log(printer.data());
printer.clear();
}
}
printer.printf("\n");
(unit->mCalcFunc)(unit, unit->mBufLength);
printer.printf(" out");
for (int j=0; j<unit->mNumOutputs; ++j) {
printer.printf(" %g", unit->mOutBuf[j][0]);
if (printer.shouldFlush()) {
#ifdef thread_local
spin_lock::scoped_lock lock (log_guard);
#endif
log(printer.data());
printer.clear();
}
}
printer.printf("\n");
}
printer.printf("\n");
#ifdef thread_local
spin_lock::scoped_lock lock (log_guard);
#endif
log(printer.data());
}
//private
void StatsReporter::draw()
{
if (!visible) return;
nim::SetNextWindowSizeConstraints({ 300.f, 200.f }, { 400.f, 1000.f });
nim::Begin("Stats:", &visible, ImGuiWindowFlags_ShowBorders);
static std::array<float, 90> timeValues = { 0.f };
static std::array<float, 90> frameValues = { 0.f };
static std::size_t valuesIndex = 0;
const float elapsed = frameTimer.restart().asSeconds();
const float frameTime = elapsed * 1000.f;
const float frameRate = 1.f / elapsed;
static float avgTime = 0.f;
avgTime -= avgTime / timeValues.size();
avgTime += frameTime / timeValues.size();
std::string avgTStr = "Avg: " + std::to_string(avgTime) + " (ms)";
static float avgFrame = 0.f;
avgFrame -= avgFrame / frameValues.size();
avgFrame += frameRate / frameValues.size();
std::string avgFStr = "Avg: " + std::to_string(avgFrame);
timeValues[valuesIndex] = frameTime;
frameValues[valuesIndex] = frameRate;
valuesIndex = (valuesIndex + 1) % timeValues.size();
nim::PlotLines("Frame Time", timeValues.data(), timeValues.size(), valuesIndex, avgTStr.c_str(), 0.f, std::max(33.f, frameTime), ImVec2(0, 40));
nim::PlotLines("Frame Rate", frameValues.data(), frameValues.size(), valuesIndex, avgFStr.c_str(), 0.f, std::max(950.f, frameRate), ImVec2(0, 40));
nim::BeginChild("ScrollingRegion", ImVec2(0, -nim::GetItemsLineHeightWithSpacing()), false, ImGuiWindowFlags_HorizontalScrollbar);
nim::TextUnformatted(Stats::getString().c_str(), Stats::getString().c_str() + Stats::getString().size());
nim::SetScrollHere();
nim::EndChild();
nim::End();
//nim::ShowTestWindow(&visible);
}
void
construct(C<I>)
{
if(std::get<I>(*bs_).begin() !=
std::get<I>(*bs_).end())
{
n_ = I;
new(buf_.data()) iter_t<I>{
std::get<I>(*bs_).begin()};
return;
}
construct(C<I+1>{});
}
static std::vector<uint8_t> encrypt(
const std::vector<uint8_t> header,
const std::vector<uint8_t> plain,
const std::vector<uint8_t> footer,
const std::array<uint8_t, 16>& nonce,
const std::array<uint8_t, 16>& key) {
std::vector<uint8_t> cipher;
cipher.resize(plain.size() + 128);
unsigned char* c = cipher.data();
size_t cLen = cipher.size();
const unsigned char* h = header.empty() ? 0 : header.data();
size_t hLen = header.size();
const unsigned char* p = plain.data();
size_t pLen = plain.size();
const unsigned char* t = footer.empty() ? 0 : footer.data();
size_t tLen = footer.size();
norx_aead_encrypt(c, &cLen, h, hLen, p, pLen, t, tLen, nonce.data(), key.data());
cipher.resize(cLen);
return cipher;
}
// ----------------------------------------------------------------------------
ENetPacket* Crypto::encryptSend(BareNetworkString& ns, bool reliable)
{
// 4 bytes counter and 4 bytes tag
ENetPacket* p = enet_packet_create(NULL, ns.m_buffer.size() + 8,
(reliable ? ENET_PACKET_FLAG_RELIABLE :
(ENET_PACKET_FLAG_UNSEQUENCED | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT))
);
if (p == NULL)
return NULL;
std::array<uint8_t, 12> iv = {};
std::unique_lock<std::mutex> ul(m_crypto_mutex);
uint32_t val = ++m_packet_counter;
if (NetworkConfig::get()->isClient())
memcpy(iv.data(), &val, 4);
else
memcpy(iv.data() + 4, &val, 4);
uint8_t* packet_start = p->data + 8;
if (EVP_EncryptInit_ex(m_encrypt, NULL, NULL, NULL, iv.data()) != 1)
{
enet_packet_destroy(p);
return NULL;
}
int elen;
if (EVP_EncryptUpdate(m_encrypt, packet_start, &elen, ns.m_buffer.data(),
(int)ns.m_buffer.size()) != 1)
{
enet_packet_destroy(p);
return NULL;
}
if (EVP_EncryptFinal_ex(m_encrypt, unused_16_blocks.data(), &elen) != 1)
{
enet_packet_destroy(p);
return NULL;
}
if (EVP_CIPHER_CTX_ctrl(m_encrypt, EVP_CTRL_GCM_GET_TAG, 4, p->data + 4)
!= 1)
{
enet_packet_destroy(p);
return NULL;
}
ul.unlock();
memcpy(p->data, &val, 4);
return p;
} // encryptSend
std::chrono::nanoseconds Encryption::DirectEncryptCFB(void) {
rijndael_context rk;
rijndaelKeySetup(&rk, sc_key.data(), 256);
auto start = high_resolution_clock::now();
unsigned char feedback[16] = {};
for (size_t i = 0; i < buffer.size(); i += 16) {
rijndaelEncrypt(&rk, feedback, feedback);
for (size_t j = 0; j < 16; j++)
feedback[j] ^= buffer[i + j];
}
return high_resolution_clock::now() - start;
}
void Server::receive() {
Peer peer;
boost::system::error_code error;
auto bytes_transferred =
socket_.receive_from(boost::asio::buffer(recv_buffer_), peer, 0, error);
std::cout << "Server received " << bytes_transferred << " bytes"
" from " << peer
<< " with " << error.message() << std::endl;
if (!error) {
std::cout << " >> ";
std::cout.write(recv_buffer_.data(), bytes_transferred);
std::cout << std::endl;
}
receive();
}
void pie_TransColouredTriangle(const std::array<Vector3f, 3> &vrt, PIELIGHT c, const glm::mat4 &modelViewMatrix)
{
pie_SetTexturePage(TEXPAGE_NONE);
pie_SetRendMode(REND_ADDITIVE);
glm::vec4 color(c.byte.r / 255.f, c.byte.g / 255.f, c.byte.b / 255.f, 128.f / 255.f);
const auto &program = pie_ActivateShader(SHADER_GENERIC_COLOR, pie_PerspectiveGet() * modelViewMatrix, color);
static glBufferWrapper buffer;
glBindBuffer(GL_ARRAY_BUFFER, buffer.id);
glBufferData(GL_ARRAY_BUFFER, 3 * sizeof(Vector3f), vrt.data(), GL_STREAM_DRAW);
glVertexAttribPointer(program.locVertex, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
glEnableVertexAttribArray(program.locVertex);
glDrawArrays(GL_TRIANGLE_FAN, 0, 3);
glDisableVertexAttribArray(program.locVertex);
}
void D3DVertexFormat::SetupVertexPointers()
{
if (!d3d_decl)
{
if (FAILED(DX9::D3D::dev->CreateVertexDeclaration(m_elems.data(), &d3d_decl)))
{
PanicAlert("Failed to create D3D vertex declaration!");
return;
}
}
if (d3d_decl)
DX9::D3D::SetVertexDeclaration(d3d_decl);
else
ERROR_LOG(VIDEO, "Invalid D3D decl");
}
void preparePipelines()
{
const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);
VkPipelineRasterizationStateCreateInfo rasterizationStateCI = vks::initializers::pipelineRasterizationStateCreateInfo(VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT, VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);
VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);
VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState);
VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);
VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0);
VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0);
// Vertex bindings and attributes
const std::vector<VkVertexInputBindingDescription> vertexInputBindings = {
vks::initializers::vertexInputBindingDescription(0, sizeof(vkglTF::Model::Vertex), VK_VERTEX_INPUT_RATE_VERTEX),
};
const std::vector<VkVertexInputAttributeDescription> vertexInputAttributes = {
vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0), // Location 0: Position
vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32B32_SFLOAT, sizeof(float) * 3), // Location 1: Normal
vks::initializers::vertexInputAttributeDescription(0, 2, VK_FORMAT_R32G32_SFLOAT, sizeof(float) * 6), // Location 2: UV
};
VkPipelineVertexInputStateCreateInfo vertexInputState = vks::initializers::pipelineVertexInputStateCreateInfo();
vertexInputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertexInputBindings.size());
vertexInputState.pVertexBindingDescriptions = vertexInputBindings.data();
vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size());
vertexInputState.pVertexAttributeDescriptions = vertexInputAttributes.data();
VkGraphicsPipelineCreateInfo pipelineCreateInfoCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);
pipelineCreateInfoCI.pVertexInputState = &vertexInputState;
pipelineCreateInfoCI.pInputAssemblyState = &inputAssemblyStateCI;
pipelineCreateInfoCI.pRasterizationState = &rasterizationStateCI;
pipelineCreateInfoCI.pColorBlendState = &colorBlendStateCI;
pipelineCreateInfoCI.pMultisampleState = &multisampleStateCI;
pipelineCreateInfoCI.pViewportState = &viewportStateCI;
pipelineCreateInfoCI.pDepthStencilState = &depthStencilStateCI;
pipelineCreateInfoCI.pDynamicState = &dynamicStateCI;
const std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = {
loadShader(getAssetPath() + "shaders/conditionalrender/model.vert.spv", VK_SHADER_STAGE_VERTEX_BIT),
loadShader(getAssetPath() + "shaders/conditionalrender/model.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT)
};
pipelineCreateInfoCI.stageCount = static_cast<uint32_t>(shaderStages.size());
pipelineCreateInfoCI.pStages = shaderStages.data();
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfoCI, nullptr, &pipeline));
}
TEST(ec, SignAndVerify)
{
static constexpr std::array<u8, 20> HASH = {{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9,
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}};
auto signature = Common::ec::Sign(PRIVATE_KEY.data(), HASH.data());
EXPECT_TRUE(Common::ec::VerifySignature(PUBLIC_KEY.data(), signature.data(), HASH.data()));
signature.fill(0xff);
EXPECT_FALSE(Common::ec::VerifySignature(PUBLIC_KEY.data(), signature.data(), HASH.data()));
}
bool ConeShape2D::load(const float width, const float height)
{
auto temp = std::make_unique<b2PolygonShape>();
const std::array<glm::vec2, 3> points =
{
glm::vec2(0.f, height*0.5f),
glm::vec2(-width * 0.5f, -height*0.5f),
glm::vec2(width * 0.5f, -height*0.5f)
};
temp->Set(reinterpret_cast<const b2Vec2*>(points.data()), points.size());
m_shape = std::move(temp);
return true;
}
void insertDataFrame(std::int32_t activeTermId, std::int32_t offset)
{
int termBufferIndex = LogBufferDescriptor::indexByTerm(INITIAL_TERM_ID, activeTermId);
AtomicBuffer& buffer = m_termBuffers[termBufferIndex];
DataFrameHeader::DataFrameHeaderDefn& frame = buffer.overlayStruct<DataFrameHeader::DataFrameHeaderDefn>(offset);
const index_t msgLength = static_cast<index_t>(DATA.size());
frame.frameLength = DataFrameHeader::LENGTH + msgLength;
frame.version = DataFrameHeader::CURRENT_VERSION;
frame.flags = FrameDescriptor::UNFRAGMENTED;
frame.type = DataFrameHeader::HDR_TYPE_DATA;
frame.termOffset = offset;
frame.sessionId = SESSION_ID;
frame.streamId = STREAM_ID;
frame.termId = activeTermId;
buffer.putBytes(offset + DataFrameHeader::LENGTH, DATA.data(), msgLength);
}
void put_string(entry& e, std::array<char, 64>& sig, boost::uint64_t& seq
, std::string const& salt, char const* public_key, char const* private_key
, char const* str)
{
using libtorrent::dht::sign_mutable_item;
e = std::string(str);
std::vector<char> buf;
bencode(std::back_inserter(buf), e);
++seq;
sign_mutable_item(std::pair<char const*, int>(&buf[0], int(buf.size()))
, std::pair<char const*, int>(&salt[0], int(salt.size()))
, seq
, public_key
, private_key
, sig.data());
}
//-----------------------------------------------------------------------
void GraphicsContextDirect3D11::SetSampler(int index, NativeSamplerState* samplerIn)
{
POMDOG_ASSERT(index >= 0);
POMDOG_ASSERT(index < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT);
POMDOG_ASSERT(samplerIn != nullptr);
auto sampler = static_cast<SamplerStateDirect3D11*>(samplerIn);
POMDOG_ASSERT(sampler != nullptr);
POMDOG_ASSERT(sampler == dynamic_cast<SamplerStateDirect3D11*>(samplerIn));
POMDOG_ASSERT(sampler->GetSamplerState() != nullptr);
std::array<ID3D11SamplerState*, 1> const states = {
sampler->GetSamplerState() };
POMDOG_ASSERT(deviceContext);
deviceContext->PSSetSamplers(index, states.size(), states.data());
}
void
decrement(C<I>)
{
if(n_ == I)
{
if(iter<I>() != std::get<I>(*bs_).begin())
{
--iter<I>();
return;
}
--n_;
using Iter = iter_t<I>;
iter<I>().~Iter();
new(buf_.data()) iter_t<I-1>{
std::get<I-1>(*bs_).end()};
}
decrement(C<I-1>{});
}
void c_tun_device_windows::set_ipv6_address
(const std::array<uint8_t, 16> &binary_address, int prefixLen)
{
_fact("Setting IPv6 address, prefixLen="<<prefixLen);
std::wstring human_name = get_human_name(m_guid);
NET_LUID luid = get_luid(human_name);
_fact("Setting address on human_name " << to_string(human_name));// << " luid=" << to_string(luid));
// remove old address
MIB_UNICASTIPADDRESS_TABLE *table = nullptr;
NETIOAPI_API status = GetUnicastIpAddressTable(AF_INET6, &table);
if (status != NO_ERROR) throw std::runtime_error("GetUnicastIpAddressTable error, code");
for (int i = 0; i < static_cast<int>(table->NumEntries); ++i) {
_info("Removing old addresses, i="<<i);
if (table->Table[i].InterfaceLuid.Value == luid.Value) {
_info("Removing old addresses, entry i="<<i<<" - will remove");
if (DeleteUnicastIpAddressEntry(&table->Table[i]) != NO_ERROR) {
FreeMibTable(table);
throw std::runtime_error("DeleteUnicastIpAddressEntry error");
}
}
}
FreeMibTable(table);
// set new address
_fact("Setting new IP address");
MIB_UNICASTIPADDRESS_ROW iprow;
std::memset(&iprow, 0, sizeof(iprow));
iprow.PrefixOrigin = IpPrefixOriginUnchanged;
iprow.SuffixOrigin = IpSuffixOriginUnchanged;
iprow.ValidLifetime = 0xFFFFFFFF;
iprow.PreferredLifetime = 0xFFFFFFFF;
iprow.OnLinkPrefixLength = 0xFF;
iprow.InterfaceLuid = luid;
iprow.Address.si_family = AF_INET6;
std::memcpy(&iprow.Address.Ipv6.sin6_addr, binary_address.data(), binary_address.size());
iprow.OnLinkPrefixLength = prefixLen;
_fact("Creating unicast IP");
status = CreateUnicastIpAddressEntry(&iprow);
if (status != NO_ERROR) throw std::runtime_error("CreateUnicastIpAddressEntry error");
_goal("Created unicast IP, status=" << status);
}
// ============================================================================
bool Crypto::encryptConnectionRequest(BareNetworkString& ns)
{
std::vector<uint8_t> cipher(ns.m_buffer.size() + 4, 0);
int elen;
if (EVP_EncryptInit_ex(m_encrypt, NULL, NULL, NULL, NULL) != 1)
return false;
if (EVP_EncryptUpdate(m_encrypt, cipher.data() + 4, &elen,
ns.m_buffer.data(), (int)ns.m_buffer.size()) != 1)
return false;
if (EVP_EncryptFinal_ex(m_encrypt, unused_16_blocks.data(), &elen) != 1)
return false;
if (EVP_CIPHER_CTX_ctrl(m_encrypt, EVP_CTRL_GCM_GET_TAG, 4, cipher.data())
!= 1)
return false;
std::swap(ns.m_buffer, cipher);
return true;
} // encryptConnectionRequest
void AppState::updateKeyInputState() {
DIDEVICEOBJECTDATA didod[kKeyInputBufferSize]; // Receives buffered data
KeyInputData data_buff[kKeyInputBufferSize];
DWORD dwElements = kKeyInputBufferSize;
dx::throwIfFailed(
keyboard_device_->GetDeviceState(sizeof(key_input_diks_), key_input_diks_.data())
);
HRESULT hr = keyboard_device_->GetDeviceData(sizeof(DIDEVICEOBJECTDATA), didod, &dwElements, 0);
if (hr == DI_OK) {
ASSERT(dwElements != 0);
std::transform(didod, didod + dwElements, data_buff, [this](DIDEVICEOBJECTDATA& d) {
return KeyInputData {getKeyCode(d.dwOfs) , d.dwData & 0x80};
});
KeyboardInput::instance().updateState( { data_buff, data_buff + dwElements });
} else {
LOGI(kLogSignWin,"GetDeviceData[%ld]", hr);
}
}
void onMessageReceived(const error_code& ec, size_t nrBytes)
{
auto onMessageReceivedWrapper = [this](const error_code& ec,
size_t nrBytes)
{
this->onMessageReceived(ec, nrBytes);
};
cout << "Received " << data_.data() << "\n";
try
{
socket_.read_some(boost::asio::buffer(data_));
socket_.async_read_some(boost::asio::buffer(data_),
onMessageReceivedWrapper);
data_.fill(0);
}
catch(std::exception& e)
{
cout << e.what() << "\n";
}
}