wrap_thread::wrap_thread(wrap_thread &&rhs) noexcept {
_note("Moving thread -START- from rhs onto me ");
join();
m_future = std::move(rhs.m_future);
_note("Moving thread -DONE- from rhs onto me ");
}
void c_galaxysrv_peers::add_peer_simplestring(const string & simple) {
_clue("Adding peer from simplestring=" << simple);
t_peering_reference_parse parse = parse_peer_reference(simple); // partially parsed
_dbg1("Done the parse itself");
bool id_anyone=true;
string id;
const auto & cables = parse.second;
auto reference = make_unique<t_peer_reference_newloop>();
if (parse.first.size()==1) { // there was 1 ID parsed
_dbg1("There is some ID in that reference.");
id_anyone=false;
id = parse.first.at(0);
reference->hip = c_haship_addr( c_haship_addr::tag_constr_by_addr_dot() , id);
} else {
_dbg1("There is NO ID in that reference (anyone?)");
id_anyone=true;
_check(parse.first.size() == 0); // else there was no ID parsed
reference->hip = c_haship_addr::make_empty(); // clear it to be sure
}
_note(join_string_sep( id_anyone?"anyone":"id" , id ) );
_note("Cables: " << cables.size());
for(const auto & cablestr : cables) {
_note("Cable: " << cablestr); // cablestr like udp:192.168.1.107:9042
unique_ptr<c_cable_base_addr> cable_addr = c_cable_base_addr::cable_make_addr( cablestr );
reference->cable_addr.push_back( std::move(cable_addr) );
}
this->add_peer( std::move( reference ) ); // ***
}
wrap_thread &wrap_thread::operator=(wrap_thread &&rhs) noexcept {
_note("Moving thread -START- from rhs onto me ");
if (&rhs == this) {
_info("Moving onto myself? Ignoring.");
return *this;
}
join();
m_future = std::move(rhs.m_future);
_note("Moving thread -DONE- from rhs onto me ");
return *this;
}
void c_simulation::init () {
//this->close_button_pressed = false;
_note("Init. We are using m_screen=" << m_screen);
if (m_drawtarget_type == e_drawtarget_type_allegro) {
_note("Creating the allegro frame buffer for m_screen="<<m_screen);
_note("Screen size is: " << m_screen->w << "*" << m_screen->h );
m_frame = create_bitmap(m_screen->w, m_screen->h);
_note("Done, the m_frame="<<m_frame);
smallWindow = create_bitmap(m_screen->w,m_screen->h);
}
if (m_drawtarget_type == e_drawtarget_type_opengl) {
_note("Using the opengl in simulation");
// TODO @opengl load here some textures and other general things
}
_note("Simulation will create the world");
m_world = make_unique<c_world>();
m_world->add_test();
//m_world->add_i_objects(100);
_note("Simulation created m_world=" << m_world.get());
_note("Simulation is ready");
}
c_simulation::~c_simulation () {
_note("Destructing the simulation");
if (m_frame) {
destroy_bitmap(m_frame);
m_frame = nullptr;
}
if (smallWindow) {
destroy_bitmap (smallWindow);
smallWindow = nullptr;
}
_note("Destructing the simulation - done");
}
void c_galaxysrv_peers::add_peer(unique_ptr<t_peer_reference_newloop> && ref) {
_check(ref.get());
_note("Adding peer: "); // TODO << *ref );
auto peer = make_unique<c_peer_connection>( std::move( *ref ) );
m_peer.push_back( std::move( peer ) );
}
connection_basic::~connection_basic() noexcept(false) {
--(m_stats->sock_count);
std::string remote_addr_str = "?";
try { boost::system::error_code e; remote_addr_str = socket_.remote_endpoint(e).address().to_string(); } catch(...){} ;
_note("Destructing connection p2p#"<<mI->m_peer_number << " to " << remote_addr_str);
}
void c_node::send_osi3_data_to_name(const std::string &dest_name, std::string &&data)
{
_note("Sending OSI3 data, to dest_name="<<dest_name<<" data="<<data);
// TODO: this->m_world.find_object_by_name_as_switch(dest_name).get_uuid_reachable_from( this );
_NOTREADY();
}
c_tun_device::c_tun_device()
:
m_ifr_name(""),
m_ip6_ok(false)
{
_note("Creating new general TUN device class");
}
void c_rpc_server::rpc_start(bool network_listen, const std::string &listen_address, const unsigned short port) {
if (network_listen) {
// start waiting for new connection
_note("Starting RPC server listening on address="<<listen_address<<" port="<<port);
m_acceptor.async_accept(m_socket, [this](boost::system::error_code error) {
this->accept_handler(error);
});
}
else _warn("RPC server started, but not listening on network");
_fact("Starting RPC thread");
m_thread = std::thread([this]() {
dbg("RPC thread start (inside)");
try {
boost::system::error_code ec;
dbg("io_service run");
m_io_service.run(ec);
dbg("end of io_service run");
if (ec) {
dbg("error code " << ec.message());
}
dbg("io_service reset");
m_io_service.reset();
} catch (const std::exception &e) {
dbg("io_service exception" << e.what());
} catch (...) {
dbg("catch unhandled exception");
}
dbg("RPC thread stop");
}); // lambda
}
connection_basic::~connection_basic() {
string remote_addr_str = "?";
m_ref_sock_count--;
try {
remote_addr_str = socket_.remote_endpoint().address().to_string();
}
catch(...) {} ;
_note("Destructing connection p2p#"<<mI->m_peer_number << " to " << remote_addr_str);
}
wrap_thread::wrap_thread() noexcept
:
m_time_created( t_timepoint::clock::now() ), // created now
m_time_started( t_timepoint::min() ),
m_time_stopped( t_timepoint::min() )
{
m_destroy_timeout=std::chrono::seconds(0);
_note("Created thread: " << this->info());
}
c_simulation::c_simulation (t_drawtarget_type drawtarget_type)
:
m_goodbye(false), m_frame_number(0),
m_drawtarget_type( drawtarget_type ),
m_frame(nullptr),
m_screen( m_drawtarget_type == e_drawtarget_type_allegro ? screen : nullptr),
smallWindow(nullptr),
m_drawtarget(nullptr)
{
_note("Creating simulation, mode: " << t_drawtarget_type_to_string( m_drawtarget_type ) << ". The allegro screen is at " << (void*)m_screen );
}
c_udp_wrapper_linux::c_udp_wrapper_linux(const int listen_port)
:
m_socket(socket(AF_INET, SOCK_DGRAM, 0))
{
_note("Creating udp wrapper (old-style)");
_assert(m_socket >= 0);
c_ip46_addr address_for_sock = c_ip46_addr::any_on_port(listen_port);
int bind_result = -1;
if (address_for_sock.get_ip_type() == c_ip46_addr::t_tag::tag_ipv4) {
sockaddr_in addr4 = address_for_sock.get_ip4();
_note("Binding");
bind_result = bind(m_socket, reinterpret_cast<sockaddr*>(&addr4), sizeof(addr4)); // reinterpret allowed by Linux specs
}
else if(address_for_sock.get_ip_type() == c_ip46_addr::t_tag::tag_ipv6) {
sockaddr_in6 addr6 = address_for_sock.get_ip6();
_note("Binding");
bind_result = bind(m_socket, reinterpret_cast<sockaddr*>(&addr6), sizeof(addr6)); // reinterpret allowed by Linux specs
}
_assert( bind_result >= 0 ); // TODO change to except
_assert(address_for_sock.get_ip_type() != c_ip46_addr::t_tag::tag_none);
}
void c_the_program::options_done() {
// === argm now can contain options added/modified by developer mode ===
namespace po = boost::program_options;
po::notify(m_argm); // !
_note("After BoostPO notify");
for (const auto & opt : m_argm) {
ostringstream oss ; oss << "commandline option (parsed by boost PO): " << opt.first << " = ";
bool converted=false;
#define try_convert_as(TYPE) \
try { ostringstream oss2; oss2 << "(" << #TYPE << ") " << opt.second.as<TYPE>(); \
converted=1; oss<<oss2.str(); } \
catch(const boost::bad_any_cast &) {}
try_convert_as(string);
try_convert_as(int);
try_convert_as(bool);
#undef try_convert_as
if (!converted) oss << "(other type)";
oss << " ;";
_note(oss.str());
}
}
// methods:
connection_basic::connection_basic(boost::asio::io_service& io_service, std::atomic<long> &ref_sock_count, std::atomic<long> &sock_number)
:
mI( new connection_basic_pimpl("peer") ),
strand_(io_service),
socket_(io_service),
m_want_close_connection(false),
m_was_shutdown(false),
m_ref_sock_count(ref_sock_count)
{
++ref_sock_count; // increase the global counter
mI->m_peer_number = sock_number.fetch_add(1); // use, and increase the generated number
std::string remote_addr_str = "?";
try { boost::system::error_code e; remote_addr_str = socket_.remote_endpoint(e).address().to_string(); } catch(...){} ;
_note("Spawned connection p2p#"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_ref_sock_count);
//boost::filesystem::create_directories("log/dr-monero/net/");
}
void c_tun_device_linux::set_ipv6_address
(const std::array<uint8_t, 16> &binary_address, int prefixLen)
{
as_zerofill< ifreq > ifr; // the if request
ifr.ifr_flags = IFF_TUN; // || IFF_MULTI_QUEUE; TODO
strncpy(ifr.ifr_name, "galaxy%d", IFNAMSIZ);
auto errcode_ioctl = ioctl(m_tun_fd, TUNSETIFF, static_cast<void *>(&ifr));
int err = errno;
if (errcode_ioctl < 0) _throw_error_sub( tuntap_error_ip , NetPlatform_syserr_to_string({e_netplatform_err_ioctl, err}) );
assert(binary_address[0] == 0xFD);
// assert(binary_address[1] == 0x42);
_fact("Setting IP address");
Wrap_NetPlatform_addAddress(ifr.ifr_name, binary_address, prefixLen, Sockaddr_AF_INET6);
m_ifr_name = std::string(ifr.ifr_name);
_note("Configured network IP for " << ifr.ifr_name);
m_ip6_ok=true;
_goal("IP address is fully configured");
}
// methods:
connection_basic::connection_basic(boost::asio::ip::tcp::socket&& socket, boost::shared_ptr<socket_stats> stats)
:
m_stats(std::move(stats)),
mI( new connection_basic_pimpl("peer") ),
strand_(socket.get_io_service()),
socket_(std::move(socket)),
m_want_close_connection(false),
m_was_shutdown(false)
{
// add nullptr checks if removed
CHECK_AND_ASSERT_THROW_MES(bool(m_stats), "stats shared_ptr cannot be null");
++(m_stats->sock_count); // increase the global counter
mI->m_peer_number = m_stats->sock_number.fetch_add(1); // use, and increase the generated number
std::string remote_addr_str = "?";
try { boost::system::error_code e; remote_addr_str = socket_.remote_endpoint(e).address().to_string(); } catch(...){} ;
_note("Spawned connection p2p#"<<mI->m_peer_number<<" to " << remote_addr_str << " currently we have sockets count:" << m_stats->sock_count);
}
std::wstring c_tun_device_windows::get_human_name(const std::wstring &guid) {
assert(!guid.empty());
std::wstring connectionKey = L"SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\";
connectionKey += guid;
connectionKey += L"\\Connection";
_note("connectionKey " << to_string(connectionKey));
LONG status = 1;
HKEY key_tmp = nullptr;
DWORD size = 256;
std::wstring name(size, '\0');
status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, connectionKey.c_str(), 0, KEY_QUERY_VALUE, &key_tmp);
if (status != ERROR_SUCCESS) throw std::runtime_error("get_human_name: RegOpenKeyExW error");
hkey_wrapper hkey_wrapped(key_tmp);
// this reinterpret_cast is not UB(3.10.10) because LPBYTE == unsigned char *
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
status = RegQueryValueExW(hkey_wrapped.get(), L"Name", nullptr, nullptr, reinterpret_cast<LPBYTE>(&name[0]), &size);
if (status != ERROR_SUCCESS) throw std::runtime_error("get_human_name: RegQueryValueExW error");
name.erase(size / sizeof(wchar_t) - 1); // remove '\0'
hkey_wrapped.close();
return name;
}
void c_simulation::main_loop () {
// PALETTE palette;
//BITMAP *img_bgr = load_bitmap("dat/bgr-bright.tga", NULL); // TODO:
s_font_allegl.reset (allegro_gl_convert_allegro_font(font,AGL_FONT_TYPE_TEXTURED,500.0), [](FONT *f){allegro_gl_destroy_font(f);});
for(auto &obj : m_world->m_objects) {
obj->set_font(s_font_allegl);
}
int viewport_x = 0, viewport_y = 0;
//show_mouse(m_screen);
set_close_button_callback(c_close_button_handler);
bool print_connect_line = false;
bool start_simulation = false;
bool simulation_pause = true;
shared_ptr<c_cjddev> connect_node;
std::chrono::steady_clock::time_point last_click_time =
std::chrono::steady_clock::now() - std::chrono::milliseconds(1000);
m_gui = make_shared<c_gui>();
// prepare drawtarget surface to draw to
switch (m_drawtarget_type) {
case e_drawtarget_type_allegro:
m_drawtarget = make_shared<c_drawtarget_allegro>(m_frame);
break;
case e_drawtarget_type_opengl:
m_drawtarget = make_shared<c_drawtarget_opengl>();
break;
default:
_erro("Warning: unsupported drawtarget");
}
m_drawtarget->m_gui = m_gui;
// bool allegro_keys_any_was=false; // is any key pressed right now (for key press/release)
long loop_miliseconds = 0;
long unsigned int frame_checkpoint = 0; /// needed for speed control (without world_draw manipulate in spacetime!)
_UNUSED(frame_checkpoint);
bool use_input_allegro = true; // always for now. input from Allegro
bool use_draw_allegro = m_drawtarget_type == e_drawtarget_type_allegro; // draw in allegro
bool use_draw_opengl = m_drawtarget_type == e_drawtarget_type_opengl; // draw in opengl
_note("Entering main simulation loop");
// The main drawing is done inside this loop.
///@see rendering.txt/[[drawing_main]]
float view_angle = 0.0;
//float camera_offset = 1.0;
float zoom = 1.0;
float camera_step_z=-11.0;
// === main loop ===
while (!m_goodbye && !close_button_pressed) {
auto start_time = std::chrono::high_resolution_clock::now();
// --- process the keyboard/inputs ---
if (use_input_allegro) {
// TODO move this code here, but leave the variables in higher scope
}
poll_keyboard();
auto allegro_keys = key;
auto allegro_shifts = key_shifts;
// bool allegro_keys_any_is=false;
// for (size_t i=0; i<sizeof(allegro_keys)/sizeof(allegro_keys[0]); ++i) allegro_keys_any_is=true;
// the direct raw position
const int allegro_mouse_x = mouse_x;
const int allegro_mouse_y = mouse_y;
const int allegro_mouse_b = mouse_b; // buttons
// the position in display port GUI
const int gui_mouse_x = allegro_mouse_x;
const int gui_mouse_y = allegro_mouse_y;
const int gui_mouse_b = allegro_mouse_b; // buttons
// the position in the world coordinates
const int gui_cursor_x = m_gui->view_x_rev(gui_mouse_x);
const int gui_cursor_y = m_gui->view_y_rev(gui_mouse_y);
const int gui_cursor_z = 0; // m_gui->view_z_rev(gui_mouse_z);
_UNUSED(gui_mouse_b);
_UNUSED(gui_cursor_x);
_UNUSED(gui_cursor_y);
_UNUSED(gui_cursor_z);
//_dbg1("mouse_x mouse_y: " << gui_mouse_x << " " << gui_mouse_y);
int allegro_char = 0;
if (keypressed()) {
allegro_char = readkey();
}
// end of input
// draw background of frame
if (use_draw_allegro) {
clear_to_color(m_frame, makecol(0, 128, 0));
blit(c_bitmaps::get_instance().m_background, m_frame, 0, 0, viewport_x, viewport_y, c_bitmaps::get_instance().m_background->w, c_bitmaps::get_instance().m_background->h);
}
if (use_draw_opengl) {
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
//glDisable(GL_DEPTH_TEST); // ??? Enables Depth Testing
//glEnable(GL_DEPTH_TEST);
//glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
//glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
//glLoadIdentity();
// glTranslatef(m_gui->camera_x, m_gui->camera_y,camera_offset);
// minimum and maximum value for zoom in/out and rotate the scene
// if (camera_offset >= 10.0) camera_offset = 10.0;
// if (camera_offset <= 0.5) camera_offset = 0.5;
if (view_angle >= 70) view_angle = 70;
if(view_angle <= 0) view_angle = 0;
if( zoom <= 0.1 ) zoom = 0.1; //because of glFrustum -> when left=right, or bottom=top there's error GL_INVALID_VALUE, so we can't multiply e.g left,right by 0
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0*zoom, 1.0*zoom, -1.0*zoom, 1.0*zoom, 1.0,60.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glTranslatef(0.0f,0.0f,-11.0);
glTranslatef(0.0f,0.0f,camera_step_z);
glRotatef(-view_angle, 1,0,0);
glScalef(10,10,10);
// drawing backgound
glPushMatrix();
//glScalef(1,1,1);
glBindTexture(GL_TEXTURE_2D,c_bitmaps::get_instance().m_background_opengl);
glEnable(GL_BLEND);
//float q=1.0/zoom;
float q=1.0;
glBegin(GL_QUADS);
glTexCoord2f(0,q); glVertex3f(-1.0f,1.0f, 0.0f);
glTexCoord2f(q,q); glVertex3f(1.0f,1.0f, 0.0f);
glTexCoord2f(q,0); glVertex3f(1.0f,-1.0f,0.0f);
glTexCoord2f(0,0); glVertex3f(-1.0f,-1.0f,0.0f);
glEnd();
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, 0); // texture
glPopMatrix();
}
// clear additional things
if (use_draw_allegro) {
clear_to_color(smallWindow, makecol(128, 128, 128));
}
// main controll keys
if (allegro_keys[KEY_ESC]) {
_note("User exits the simulation from user interface");
m_goodbye = true;
}
if ((allegro_char & 0xff) == 'n' && !start_simulation) {
std::cout << "ADD " << std::endl;
_warn("THIS CODE IS NOT IMPLEMENTED NOW");
/*
m_world->m_objects.push_back(
make_shared<c_cjddev>(
cjddev_detail_random_name(),
// gui_mouse_x, gui_mouse_y,
gui_cursor_x, gui_cursor_y,
cjddev_detail_random_addr()));
*/
}
if(allegro_keys[KEY_F1]){
//auto ptr = get_move_object(gui_mouse_x,gui_mouse_y);
// TODO -in allegro? -not entire screen?
/*
try{
if(ptr != NULL){
int col_num =0;
textout_ex(smallWindow, font, ptr->get_name().c_str(), 0, 0, makecol(0, 0, 255), -1);
if(c_cjddev* tmp = dynamic_cast<c_cjddev *>(ptr.get()) ){
char* addr =(char *) malloc(45);
sprintf(addr,"address: %ld",tmp->get_address());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
sprintf(addr,"neighbors: %d",(int)tmp->get_neighbors().size());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
sprintf(addr,"waitng: %d",(int)tmp->num_of_wating());
textout_ex(smallWindow, font,addr , 10, col_num+=10, makecol(0, 0, 255), -1);
// textout_ex(smallWindow, font, ptr->get_name().c_str(), 0, 0, makecol(0, 0, 255), -1);{
free (addr);
}
if (use_draw_allegro) {
// draw the information window
blit (smallWindow,m_frame,0,0,m_frame->w-200,m_frame->h-200,screen->w/8, screen->h/4);
}
}
}
catch(...) {}
*/
// std::cout<<ptr->get_name().c_str()<<std::endl;
}
if(allegro_keys[KEY_F2]){
// BITMAP* screen = gui_get_screen();
int m_x =0;
int m_y =0;
static unsigned int num =0;
if(num>=m_world->m_objects.size()){
num=0;
}
try{
// auto obj = m_world->m_objects.at(0);
// m_x = m_world->m_objects.at(num)->get_x() - (screen->w/2);
// m_y = m_world->m_objects.at(num)->get_y() - (screen->h/2);
m_x = m_world->m_objects.at(num)->get_x()*m_gui->camera_zoom - (allegro_mouse_x);
m_y = m_world->m_objects.at(num)->get_y()*m_gui->camera_zoom - (allegro_mouse_y);
// std::cout<< screen->w<<" "<<screen->h<<" "<<screen->x_ofs<<" "<<screen->y_ofs<<std::endl;
m_gui->camera_x = m_x ;
m_gui->camera_y = m_y;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
num++;
}catch(...)
{
}
}
// animation & tick
if (m_frame_number % g_max_anim_frame == 0 && !simulation_pause) {
frame_checkpoint = m_frame_number;
m_world->tick(); // <===
}
// === main user interface ===
// the mode
typedef enum { e_mode_node, e_mode_camera } t_mode;
t_mode mode;
mode = e_mode_node; // by default we will move/edit etc the node (or entityt)
if (allegro_shifts & KB_SHIFT_FLAG) mode = e_mode_camera; // with key SHIFT we move camera instea
// mode: camera movement etc
if (mode == e_mode_camera) {
if (allegro_keys[KEY_LEFT]) m_gui->camera_x -= 10;
if (allegro_keys[KEY_RIGHT]) m_gui->camera_x += 10;
if (allegro_keys[KEY_UP]) m_gui->camera_y -= 10;
if (allegro_keys[KEY_DOWN]) m_gui->camera_y += 10;
const double zoom_speed = 1.1;
if (allegro_keys[KEY_PGUP]) m_gui->camera_zoom *= zoom_speed;
if (allegro_keys[KEY_PGDN]) m_gui->camera_zoom /= zoom_speed;
}
// rotate and zoom in/out the scene
if(allegro_keys[KEY_Z]) {
//camera_offset+=0.1;
zoom+=0.1;
_dbg1("zoom: " << zoom);
}
if(allegro_keys[KEY_X]) {
//camera_offset-=0.1;
zoom-=0.1;
_dbg1("zoom: " << zoom);
}
if(allegro_keys[KEY_C]) {
view_angle+=1.0;
//farVal+=10;
_dbg1("view_angle: " << view_angle);
}
if(allegro_keys[KEY_V]) {
view_angle-=1.0;
_dbg1("view_angle: " << view_angle);
}
if(allegro_keys[KEY_Q]) {
camera_step_z+=0.1;
}
if(allegro_keys[KEY_W]) {
camera_step_z -= 0.1;
if(camera_step_z <= -11.0) camera_step_z=-11.0;
}
// === text debug on screen ===
string mouse_pos_str = std::to_string(gui_mouse_x) + " " + std::to_string(gui_mouse_y);
string fps_str = "fps ???";
if (loop_miliseconds != 0) {
fps_str = "fps: " + std::to_string(1000 / loop_miliseconds);
}
const int txt_h = 12; // line height (separation between lines)
int txt_x = 10, txt_y = 10; // starting position of text
if (use_draw_allegro) {
string pck_speed_str = "sending packets speed - " + std::to_string(450 - g_max_anim_frame);
textout_ex(m_frame, font, mouse_pos_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, fps_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, ("Frame nr.: " +
std::to_string(m_frame_number)).c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, pck_speed_str.c_str(), 100, 10, makecol(0, 0, 255), -1);
if(allegro_keys[KEY_H])
{
int tex_y = 10;
int lineh = 10;
textout_ex(m_frame, font, "s - start", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "p - pause", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "f - send FTP", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "t - select target", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "r - select source", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "d - remove node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "n - add node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "enter/esc - exit", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "Arrows: move selected node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "SHIFT-Arrows: move the camera", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "SHIFT-PageUp/Down: zimm in/out", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "F1: info about node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
textout_ex(m_frame, font, "F2: next node", 1140, tex_y+=lineh, makecol(0, 0, 255), -1);
} else{
textout_ex(m_frame, font, "h - help", 1140, 30, makecol(0, 0, 255), -1);
}
}
if (use_draw_opengl) {
// TODO @opengl
//textout_ex(m_frame, font, mouse_pos_str.c_str(), txt_x, txt_y += txt_h, makecol(0, 0, 255), -1);
float offset = 0.03;
float tex_y = 0.9;
float tex_x = 0.7;
string pck_speed_str = "sending packets speed - " + std::to_string(450 - g_max_anim_frame);
glColor4f(0.0,0.0,1.0,0.0);
//glScalef(0.2f,0.2f,0.2f);
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y, 0.0, mouse_pos_str.c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y-=offset, 0.0, fps_str.c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.9, tex_y-=offset, 0.0, ("Frame nr.: " + std::to_string(m_frame_number)).c_str());
allegro_gl_printf_ex(s_font_allegl.get(), -0.7, 0.97, 0.0, pck_speed_str.c_str());
glDisable(GL_BLEND);
glPopMatrix();
if(allegro_keys[KEY_H]) {
_dbg1("KEY_H - opengl");
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y, 0.0,"s - start");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"p - pause");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"f - send FTP");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"t - select target");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"r - select source");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"d - remove node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"n - add node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"enter/esc - exit");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"Arrows: move selected node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"SHIFT-Arrows: move the camera");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"SHIFT-PageUp/Down: zoom in/out");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"F1: info about node");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y-=offset, 0.0,"F2: next node");
glDisable(GL_BLEND);
glPopMatrix();
} else {
//glLoadIdentity();
glPushMatrix();
glEnable(GL_BLEND);
//allegro_gl_printf(s_font_allegl.get(), 0.8, 0.9, 0.0,0xFF0000,"h - help");
allegro_gl_printf_ex(s_font_allegl.get(), tex_x, tex_y, 0.0,"h - help");
//glBlendFunc(GL_ONE, GL_ZERO);
glDisable(GL_BLEND);
glPopMatrix();
}
}
//_dbg3("m_world->m_objects.size(): " << m_world->m_objects.size());
//_dbg3("get_move_object ret: " << get_move_object(gui_mouse_x, gui_mouse_y));
int move_object_index = get_move_object(gui_mouse_x, gui_mouse_y); ///< -1 if 'empty'
if (move_object_index != -1) { // working with selected object
m_gui->m_selected_object = m_world->m_objects.begin();
std::advance(m_gui->m_selected_object, move_object_index);
auto selected_object = m_gui->m_selected_object;
(*selected_object)->m_selected = true;
c_entity *selected_object_raw = dynamic_cast<c_entity *>((*selected_object).get());
c_osi2_switch *selected_switch = dynamic_cast<c_osi2_switch *>((*selected_object).get());
// selected_switch->send_hello_to_neighbors(); // TODO
//shared_ptr<c_cjddev> selected_device = std::dynamic_pointer_cast<c_cjddev>(selected_object);
if (selected_object != m_world->m_objects.end()) { // editing the selected object
// TODO: add connect
/*if (gui_mouse_b == 1 && !print_connect_line) {
print_connect_line = true;
connect_node = std::dynamic_pointer_cast<c_cjddev>(selected_object);
last_click_time = std::chrono::steady_clock::now();
}
if (gui_mouse_b == 1 && print_connect_line &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(500)) {
// assert( connect_node && selected_object );
connect_node->add_neighbor(std::dynamic_pointer_cast<c_cjddev>(selected_object));
(std::dynamic_pointer_cast<c_cjddev>(selected_object))->add_neighbor(std::dynamic_pointer_cast<c_cjddev>(connect_node));
print_connect_line = false;
}*/
if (mode == e_mode_node) { // working with selected object - moving
if (!print_connect_line) {
int speed = 5;
if (allegro_keys[KEY_LEFT])
selected_object_raw->m_x += -speed;
if (allegro_keys[KEY_RIGHT])
selected_object_raw->m_x += speed;
if (allegro_keys[KEY_DOWN])
selected_object_raw->m_y += speed;
if (allegro_keys[KEY_UP])
selected_object_raw->m_y += -speed;
}
} // moving selected object
}
/*
if ((allegro_char & 0xff) == 's' && !start_simulation) {
if (!m_gui->m_source || !m_gui->m_target) {
std::cout << "please choose target and source node\n";
} else {
m_gui->m_source->buy_net(m_gui->m_target->get_address());
start_simulation = true;
simulation_pause = false;
}
}
if ((allegro_char & 0xff) == 'd' && selected_device && !start_simulation) {
for (shared_ptr<c_cjddev> &it : selected_device->get_neighbors()) {
selected_device->remove_neighbor(it);
it->remove_neighbor(selected_device);
}
for (auto it = m_world->m_objects.begin(); it != m_world->m_objects.end(); ++it) {
if (it->get() == selected_device.get()) {
m_world->m_objects.erase(it);
break;
}
}
}
if ((allegro_char & 0xff) == 't' && selected_device && !start_simulation) {
m_gui->m_target = selected_device;
}
if ((allegro_char & 0xff) == 'r' && selected_device && !start_simulation) {
m_gui->m_source = selected_device;
}
if ((allegro_char & 0xff) == 'f') {
if (!m_gui->m_source || !m_gui->m_target)
std::cout << "please choose target and source node\n";
else {
m_gui->m_source->send_ftp_packet(m_gui->m_target->get_address(), "FTP data");
last_click_time = std::chrono::steady_clock::now();
}
}
*/
// === animation clock controll ===
if ((allegro_char & 0xff) == 'p') {
simulation_pause = !simulation_pause;
last_click_time = std::chrono::steady_clock::now();
}
if (allegro_keys[KEY_MINUS_PAD] && g_max_anim_frame < 400 &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(loop_miliseconds)) {
//std::cout << m_frame_number-frame_checkpoint << " - " << g_max_anim_frame << " mod: " << (m_frame_number-frame_checkpoint) % g_max_anim_frame << std::endl;
g_max_anim_frame += 1;
last_click_time = std::chrono::steady_clock::now();
}
if (allegro_keys[KEY_PLUS_PAD] && g_max_anim_frame > 10 &&
std::chrono::steady_clock::now() - last_click_time > std::chrono::milliseconds(loop_miliseconds)) {
//std::cout << m_frame_number-frame_checkpoint << " + " << g_max_anim_frame << " mod: " << (m_frame_number-frame_checkpoint) % g_max_anim_frame << std::endl;
g_max_anim_frame -= 1;
last_click_time = std::chrono::steady_clock::now();
}
}
// === animation clock operations ===
m_world->draw(*m_drawtarget.get()); // <===== DRAW THE WORLD
/*
if ((m_frame_number - frame_checkpoint) < g_max_anim_frame) {
m_world->draw(*m_drawtarget.get(), (m_frame_number - frame_checkpoint) % g_max_anim_frame); // <==
} else {
m_world->draw(*m_drawtarget.get(), g_max_anim_frame);
}
*/
if (print_connect_line) { // the line the creates new connections
if (use_draw_allegro) {
line(m_frame, connect_node->m_x, connect_node->m_y, allegro_mouse_x, allegro_mouse_y, makecol(0, 255, 255));
}
// TODO @opengl
if (use_draw_opengl) {
glColor3f(0.0f,1.0f,1.0f);
glLineWidth(1.0);
glScalef(1.0f,1.0f,1.0f);
const int vx = m_gui->view_x(connect_node->m_x), vy = m_gui->view_y(connect_node->m_y); // position in viewport - because camera position
//float start_line_x = ((connect_node->m_x)-0.5*SCREEN_W)/(0.5*SCREEN_W);
//float start_line_y = -((connect_node->m_y)-0.5*SCREEN_H)/(0.5*SCREEN_H);
float start_line_x = (vx-0.5*SCREEN_W)/(0.5*SCREEN_W);
float start_line_y = -(vy-0.5*SCREEN_H)/(0.5*SCREEN_H);
float end_line_x = (allegro_mouse_x-0.5*SCREEN_W)/(0.5*SCREEN_W);
float end_line_y = -(allegro_mouse_y-0.5*SCREEN_H)/(0.5*SCREEN_H);
//_dbg1("connect_node: " << connect_node->m_x << " " << connect_node->m_y);
//_dbg1("allegro_mouse: " << allegro_mouse_x << " " << allegro_mouse_y);
//_dbg1("start_line: " << start_line_x << " " << start_line_y);
//_dbg1("end_line: " << end_line_x << " " << end_line_y);
//glLoadIdentity();
glPushMatrix();
glBegin(GL_LINES);
glVertex3f(start_line_x,start_line_y,0.0f);
glVertex3f(end_line_x,end_line_y,0.0f);
glEnd();
glPopMatrix();
}
}
if (allegro_mouse_b == 2) { // end/stop the line that creates new connections
print_connect_line = false;
}
{
auto x = allegro_mouse_x, y = allegro_mouse_y;
int r = 5, rr = 4;
if (use_draw_allegro) {
line(m_frame, x - rr, y, x + rr, y, makecol(0, 0, 0));
line(m_frame, x, y - rr, x, y + rr, makecol(0, 0, 0));
circle(m_frame, x, y, r, makecol(255, 255, 255));
}
// TODO @opengl
if(use_draw_opengl) {
float opengl_mouse_x = (x-SCREEN_W*0.5)/(0.5*SCREEN_W);
float opengl_mouse_y = -(y-SCREEN_H*0.5)/(0.5*SCREEN_H);
float cursor_size=0.01;
//_dbg1("mouse_x mouse_y: " << mouse_x << " " << mouse_y);
//_dbg1("screenW screenH: " << SCREEN_W << " " << SCREEN_H);
//glLoadIdentity();
//glScalef(1/camera_offset, 1/camera_offset, 1.0);
//glScalef(1.0*zoom, 1.0*zoom, 1.0*zoom);
glPushMatrix();
glScalef(1.0f,1.0f,1.0f);
glTranslatef(opengl_mouse_x,opengl_mouse_y,0.0f);
//glTranslatef(m_gui->view_x_rev(mouse_x),m_gui->view_y_rev(mouse_y),0.0f);
glColor3f(0.0, 0.0, 0.0);
// draw cursor
glBegin(GL_LINES);
glVertex2f(-1.0f*cursor_size,0.0f);
glVertex2f(1.0f*cursor_size,0.0f);
glVertex2f(0.0f,-1.0f*cursor_size);
glVertex2f(0.0f,1.0f*cursor_size);
glEnd();
glPopMatrix();
}
}
// === show frame ===
if (use_draw_allegro) {
//_dbg1("Allegro: frame done. fps = " << fps_str);
scare_mouse();
blit(m_frame, m_screen, 0, 0, 0, 0, m_frame->w, m_frame->h);
unscare_mouse();
if (!simulation_pause) {
++m_frame_number;
}
}
if (use_draw_opengl) {
//_dbg1("OpenGL: frame flip. fps = " << fps_str);
allegro_gl_flip();
}
for (auto &object : m_world->m_objects) {
object->m_selected = false;
}
// std::this_thread::sleep_for(std::chrono::milliseconds(10));
auto stop_time = std::chrono::high_resolution_clock::now();
auto diff = stop_time - start_time;
loop_miliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(diff).count();
}
std::ofstream out_file("../layout/current/out.map.txt");
out_file << *m_world << std::endl;
}
c_tun_device_linux::c_tun_device_linux()
:
m_tun_fd(-1)
{
_note("Creating new linu TUN device class");
}
std::wstring c_tun_device_windows::get_device_guid() {
const std::wstring adapterKey = L"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}";
_fact("Looking for device guid" << to_string(adapterKey));
LONG status = 1;
HKEY key = nullptr;
status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, adapterKey.c_str(), 0, KEY_READ, &key);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegOpenKeyEx error, error code " + std::to_string(status));
hkey_wrapper key_wrapped(key);
std::vector<std::wstring> subkeys_vector;
try {
subkeys_vector = get_subkeys(key_wrapped.get());
} catch (const std::exception &e) {
key_wrapped.close();
throw e;
}
_dbg1("found " << subkeys_vector.size() << " reg keys");
key_wrapped.close();
for (const auto & subkey : subkeys_vector) { // foreach sub key
if (subkey == L"Properties") continue;
std::wstring subkey_reg_path = adapterKey + L"\\" + subkey;
_fact(to_string(subkey_reg_path));
status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, subkey_reg_path.c_str(), 0, KEY_QUERY_VALUE, &key);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegOpenKeyEx error, error code " + std::to_string(status));
// get ComponentId field
DWORD size = 256;
std::wstring componentId(size, '\0');
// this reinterpret_cast is not UB(3.10.10) because LPBYTE == unsigned char *
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
status = RegQueryValueExW(key, L"ComponentId", nullptr, nullptr, reinterpret_cast<LPBYTE>(&componentId[0]), &size);
if (status != ERROR_SUCCESS) {
RegCloseKey(key);
continue;
}
key_wrapped.set(key);
std::wstring netCfgInstanceId;
try {
if (componentId.substr(0, 8) == L"root\\tap" || componentId.substr(0, 3) == L"tap") { // found TAP
_note(to_string(subkey_reg_path));
size = 256;
netCfgInstanceId.resize(size, '\0');
// this reinterpret_cast is not UB(3.10.10) because LPBYTE == unsigned char *
// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
status = RegQueryValueExW(key_wrapped.get(), L"NetCfgInstanceId", nullptr, nullptr, reinterpret_cast<LPBYTE>(&netCfgInstanceId[0]), &size);
if (status != ERROR_SUCCESS) throw std::runtime_error("RegQueryValueEx error, error code " + std::to_string(GetLastError()));
netCfgInstanceId.erase(size / sizeof(wchar_t) - 1); // remove '\0'
_note(to_string(netCfgInstanceId));
key_wrapped.close();
HANDLE handle = open_tun_device(netCfgInstanceId);
if (handle == INVALID_HANDLE_VALUE) continue;
else {
BOOL ret = CloseHandle(handle);
if (ret == 0) throw std::runtime_error("CloseHandle error, " + std::to_string(GetLastError()));
}
return netCfgInstanceId;
}
} catch (const std::out_of_range &e) {
_warn(std::string("register value processing error ") + e.what());
_note("componentId = " + to_string(componentId));
_note("netCfgInstanceId " + to_string(netCfgInstanceId));
}
key_wrapped.close();
}
_erro("Can not find device in windows registry");
throw std::runtime_error("Device not found");
}
c_galaxysrv_peers::t_peering_reference_parse c_galaxysrv_peers::parse_peer_reference(const string & simple) const{
// @TODO not using std::regex since it had compatibility problems. Consider using when possible (bug#J446).
const char separator='@', group_open='(', group_close=')';
const string literal_anyone = "anyone";
reasonable_size(simple);
_note("Parsing: "<<simple);
_check_input(simple.size()>=3); // some reasonable sized not-empty string
size_t pos1 = simple.find(separator); // was there any "@"
if (pos1 == string::npos) { // must be one-part format "VIRTUAL" (only contains the ID/ipv6, no cables)
vector<string> ret_id( { simple } ); // e.g. "fd42:f6c4:9d19:f128:30df:b289:aef0:25f5,score=-300"
vector<string> ret_cable{ };
// make sure this part does not contain ( or ) etc
_check_input( string::npos == simple.find(group_open) );
_check_input( string::npos == simple.find(group_close) );
_check_input( simple.size()>0 );
return std::make_pair(std::move(ret_id), std::move(ret_cable));
}
else { // format "VIRTUAL@(CABLE)" possibly with more "@(CABLE)"
string part1 = simple.substr(0,pos1); // the VIRTUAL
// make sure this part does not contain ( or )
_check_input( string::npos == part1.find(group_open) );
_check_input( string::npos == part1.find(group_close) );
_check_input( part1.size()>0 );
vector<string> ret_id;
if (part1 != literal_anyone) {
ret_id.push_back( part1 ); // e.g. "fd42:f6c4:9d19:f128:30df:b289:aef0:25f5,score=-300"
} // else, it is 'anyone' VIRTUAL - so it is reported by empty string
// fd42::25f5@(udp:p.meshnet.pl:9042,cost=500)@(shm:test)@(tcp:[fe80::d44e]:9042)
// B
// B.............................X
// X@(B
// B.......X@
// X@(B
// B.....................end
vector<string> ret_cable;
// will parse additional groups "@(....)" selecting their index posB...posX
const size_t size = simple.size(), size_before=size-1; _check(size_before < size);
_check_input(pos1+2 < size);
_check_input(simple.at(pos1+0)==separator); // theck the '@' out of "@(" that we just found
_check_input(simple.at(pos1+1)==group_open); // theck the '(' out of "@(" that we just found
size_t posB = pos1+2; // begin, poiting after "@("
_info(join_string_sep(posB," < ",size));
while (posB < size_before) {
auto posX = simple.find(group_close,posB); // find ")"
_dbg3("posX=" << posX << " posB="<<posB);
if (posX == string::npos) {
_info("Hit end because posX="<<posX);
posX = size_before;
}
string partX = simple.substr(posB, posX-posB);
_dbg3("posX=" << posX << " posB="<<posB<<" given " <<partX);
// make sure this part does not contain ( or ), e.g. "CABLE(" as result of parsing "VIRTUAL@(CABLE(CABLE)"
_check_input( string::npos == partX.find(group_open) );
_check_input( string::npos == partX.find(group_close) );
_check_input( partX.size()>0 );
ret_cable.push_back( std::move(partX) );
posB=posX;
_check_input(simple.at(posB)==group_close); // ")"
++posB;
if (!(posB<size)) break; // end is possible after last "....@(...)"
// otherwise we open new group:
_check_input(simple.at(posB)==separator); // ")@"
++posB;
_check_input(simple.at(posB)==group_open); // ")@(" after this
++posB;
}
return std::make_pair(std::move(ret_id), std::move(ret_cable));
} // other format
}
void c_network::send_message (t_nym_id addr,std::string &&message) {
_note("c_network::send_message()");
_note("message size: " << message.size());
m_message_vector.emplace_back(std::make_pair( addr,message) );
}
