示例#1
0
void c_netuser::send_token_bynet(const std::string &ip_address, int port) {
	DBG_MTX(dbg_mtx, "START");
    boost::system::error_code ec;
    ip::address addr = ip::address::from_string(ip_address, ec);
    //if(ec) { ///< boost error - not needed
    //    throw std::runtime_error("bad ip");
    //}
    if (!addr.is_v6()) {
        std::string msg = addr.to_string();
        msg += ec.message()+" : is not valid IPv6 address";
        throw std::invalid_argument(msg);
    }
    ip::tcp::endpoint server_endpoint(addr, port);

	ip::tcp::socket socket_(m_io_service);
    socket_.connect(server_endpoint, ec);
    if (ec) {
        DBG_MTX(dbg_mtx,"EC = " << ec);
        throw std::runtime_error("send_token_bynet -- fail to connect");
    }

	DBG_MTX(dbg_mtx, "getting remote public key");
	send_public_key_req(socket_);
    ed_key remote_public_key(get_public_key_resp(socket_));
	DBG_MTX(dbg_mtx, "remote public key " << remote_public_key);

    std::string packet = get_token_packet(serialization::Json, remote_public_key);
    if (packet == "fail") {
        DBG_MTX(dbg_mtx,"stop sending token -- empty wallet");
        return;
    }

    send_coin(socket_, packet);

    socket_.close();
}
示例#2
0
//----------------------------------------------------------------------------
TEST_F(FiberTest, SSLconnectDisconnectFiberFromClient) {

  boost::log::core::get()->set_filter(boost::log::trivial::severity >=
                                      boost::log::trivial::info);

  Wait();

  typedef boost::asio::ssl::stream<fiber> ssl_fiber_t;
  boost::asio::ssl::context ctx(boost::asio::ssl::context::tlsv12);

  std::function<bool(bool, boost::asio::ssl::verify_context&)> verify_callback =
      [](bool preverified, boost::asio::ssl::verify_context& ctx) {
    BOOST_LOG_TRIVIAL(debug) << "------------------------------" << std::endl;
    X509_STORE_CTX* cts = ctx.native_handle();
    X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());

    char subject_name[256];
    auto err = X509_STORE_CTX_get_error(ctx.native_handle());
    auto depth_err = X509_STORE_CTX_get_error_depth(ctx.native_handle());

    BOOST_LOG_TRIVIAL(debug) << "Error " << X509_verify_cert_error_string(err)
                             << std::endl;
    BOOST_LOG_TRIVIAL(debug) << "Depth " << depth_err << std::endl;

    X509* issuer = cts->current_issuer;
    if (issuer) {
      X509_NAME_oneline(X509_get_subject_name(issuer), subject_name, 256);
      BOOST_LOG_TRIVIAL(debug) << "Issuer " << subject_name << "\n";
    }

    X509_NAME_oneline(X509_get_subject_name(cert), subject_name, 256);
    BOOST_LOG_TRIVIAL(debug) << "Verifying " << subject_name << "\n";

    BOOST_LOG_TRIVIAL(debug) << "------------------------------" << std::endl;

    return preverified;
  };

  ctx.set_verify_depth(100);

  // Set the mutual authentication
  ctx.set_verify_mode(boost::asio::ssl::verify_peer |
                      boost::asio::ssl::verify_fail_if_no_peer_cert);

  // Set the callback to verify the cetificate chains of the peer
  ctx.set_verify_callback(boost::bind(verify_callback, _1, _2));

  // Load the file containing the trusted certificate authorities
  SSL_CTX_load_verify_locations(ctx.native_handle(), "./certs/trusted/ca.crt",
                                NULL);

  // The certificate used by the local peer
  ctx.use_certificate_chain_file("./certs/certificate.crt");

  // The private key used by the local peer
  ctx.use_private_key_file("./certs/private.key",
                           boost::asio::ssl::context::pem);

  // The Diffie-Hellman parameter file
  ctx.use_tmp_dh_file("./certs/dh4096.pem");

  // Force a specific cipher suite
  SSL_CTX_set_cipher_list(ctx.native_handle(), "DHE-RSA-AES256-GCM-SHA384");

  fiber_acceptor fib_acceptor(io_service_server_);

  ssl_fiber_t ssl_fiber_client(io_service_client_, ctx);
  ssl_fiber_t ssl_fiber_server(io_service_server_, ctx);

  std::promise<bool> client_closed;
  std::promise<bool> server_closed;

  uint32_t buffer_s = 1;
  uint32_t buffer_c = 0;

  auto sent = [this, &server_closed, &ssl_fiber_server, &buffer_s](
      const boost::system::error_code& ec, size_t length) {
    EXPECT_EQ(ec.value(), 0) << "Sent handler should not be in error";
    BOOST_LOG_TRIVIAL(debug) << "Server sent: " << buffer_s << std::endl;
    server_closed.set_value(true);
  };

  auto async_handshaked_s = [this, &ssl_fiber_server, &buffer_s, &sent](
      const boost::system::error_code& ec) {
    EXPECT_EQ(ec.value(), 0) << "Handshaked handler should not be in error";
    buffer_s = 10;
    boost::asio::async_write(ssl_fiber_server,
                             boost::asio::buffer(&buffer_s, sizeof(buffer_s)),
                             boost::bind<void>(sent, _1, _2));
  };

  auto async_accept_s = [this, &ssl_fiber_server, &async_handshaked_s](
      const boost::system::error_code& ec) {
    EXPECT_EQ(ec.value(), 0) << "Accept handler should not be in error";
    ssl_fiber_server.async_handshake(boost::asio::ssl::stream_base::server,
                                     boost::bind<void>(async_handshaked_s, _1));
  };

  auto received = [this, &client_closed, &ssl_fiber_client, &buffer_c,
                   &buffer_s](const boost::system::error_code& ec,
                              size_t length) {
    EXPECT_EQ(ec.value(), 0) << "Received handler should not be in error " << ec.message();
    EXPECT_EQ(buffer_s, buffer_c);
    BOOST_LOG_TRIVIAL(debug) << "client received: " << buffer_c << std::endl;
    ssl_fiber_client.next_layer().close();
    client_closed.set_value(true);
  };

  auto async_handshaked_c = [this, &ssl_fiber_client, &buffer_c, &received](
      const boost::system::error_code& ec) {
    EXPECT_EQ(ec.value(), 0) << "Handshaked handler should not be in error";
    boost::asio::async_read(ssl_fiber_client,
                            boost::asio::buffer(&buffer_c, sizeof(buffer_c)),
                            boost::bind<void>(received, _1, _2));
  };

  auto async_connect_c = [this, &ssl_fiber_client, &async_handshaked_c](
      const boost::system::error_code& ec) {
    EXPECT_EQ(ec.value(), 0) << "Connect handler should not be in error";
    ssl_fiber_client.async_handshake(boost::asio::ssl::stream_base::client,
                                     boost::bind<void>(async_handshaked_c, _1));
  };

  boost::system::error_code acceptor_ec;
  fiber_endpoint server_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_server_, 1);
  fib_acceptor.open(server_endpoint.protocol(), acceptor_ec);
  fib_acceptor.bind(server_endpoint, acceptor_ec);
  fib_acceptor.listen(boost::asio::socket_base::max_connections, acceptor_ec);
  fib_acceptor.async_accept(ssl_fiber_server.next_layer(),
                            boost::bind<void>(async_accept_s, _1));

  fiber_endpoint client_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_client_, 1);
  ssl_fiber_client.next_layer().async_connect(
      client_endpoint, boost::bind<void>(async_connect_c, _1));

  client_closed.get_future().wait();
  server_closed.get_future().wait();

  boost::system::error_code ec;
  ssl_fiber_server.next_layer().close(ec);
  fib_acceptor.close(ec);
}
示例#3
0
//-----------------------------------------------------------------------------
TEST_F(FiberTest, tooSmallReceiveBuffer) {
  boost::log::core::get()->set_filter(boost::log::trivial::severity >=
                                      boost::log::trivial::info);

  Wait();

  std::array<uint8_t, 5> buffer_client;
  std::array<uint8_t, 2> buffer_server;

  boost::recursive_mutex received_mutex;
  uint8_t count = 0;
  size_t received = 0;
  size_t sent = 0;

  fiber_acceptor fib_acceptor(io_service_server_);
  fiber fib_server(io_service_server_);
  fiber fib_client(io_service_client_);

  std::promise<bool> client_closed;
  std::promise<bool> server_closed;

  auto void_handler_receive = [&](const boost::system::error_code& ec,
                                  size_t s) {
    boost::recursive_mutex::scoped_lock lock(received_mutex);
    received += s;
    ++count;

    if (count == 4) {
      ASSERT_EQ(received, 5) << "Not received all data";
      ASSERT_EQ(fib_server.is_open(), false) << "Server fiber not closed";
      server_closed.set_value(true);
    }
  };

  auto async_accept_h1 = [&, this](const boost::system::error_code& ec) {
    ASSERT_EQ(ec.value(), 0);
    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(void_handler_receive, _1, _2));
    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(void_handler_receive, _1, _2));
    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(void_handler_receive, _1, _2));
    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(void_handler_receive, _1, _2));
  };

  auto void_handler_send = [&](const boost::system::error_code& ec, size_t s) {
    EXPECT_EQ(ec.value(), 0);
    if (ec) {
        client_closed.set_value(false);
        return;
    }
    sent += s;

    fib_client.close();
    client_closed.set_value(true);
  };

  auto async_connect_h1 = [&, this](const boost::system::error_code& ec) {
    ASSERT_EQ(ec.value(), 0);
    buffer_client[0] = 'a';
    buffer_client[1] = 'b';
    buffer_client[2] = 'c';
    buffer_client[3] = 'd';
    buffer_client[4] = 'e';

    boost::asio::async_write(fib_client, boost::asio::buffer(buffer_client),
                             boost::bind<void>(void_handler_send, _1, _2));
  };

  boost::system::error_code acceptor_ec;
  fiber_endpoint server_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_server_, 1);
  fib_acceptor.open(server_endpoint.protocol(), acceptor_ec);
  fib_acceptor.bind(server_endpoint, acceptor_ec);
  fib_acceptor.listen(boost::asio::socket_base::max_connections, acceptor_ec);
  fib_acceptor.async_accept(fib_server, boost::bind<void>(async_accept_h1, _1));

  fiber_endpoint client_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_client_, 1);
  fib_client.async_connect(client_endpoint,
                           boost::bind<void>(async_connect_h1, _1));

  client_closed.get_future().wait();
  server_closed.get_future().wait();

  {
    boost::recursive_mutex::scoped_lock lock(received_mutex);
  }

  EXPECT_EQ(received, 5);
  EXPECT_EQ(sent, 5);
  boost::system::error_code close_fib_acceptor_ec;
  fib_acceptor.close(close_fib_acceptor_ec);
}
示例#4
0
////-----------------------------------------------------------------------------
TEST_F(FiberTest, exchangePacketsFiveClients) {
  boost::log::core::get()->set_filter(boost::log::trivial::severity >=
                                      boost::log::trivial::info);

  Wait();

  typedef std::array<uint8_t, 5> buffer_type;

  struct TestConnection {
    TestConnection(boost::asio::io_service& io_service_server,
                   boost::asio::io_service& io_service_client)
        : fib_server(io_service_server), fib_client(io_service_client) {}

    fiber fib_server;
    fiber fib_client;
    buffer_type buffer_server;
    buffer_type buffer_client;
    std::promise<bool> server_closed;
    std::promise<bool> client_closed;
  };

  uint32_t connection_number = 5;
  int32_t packet_number = 5 * 100;

  fiber_acceptor fib_acceptor(io_service_server_);

  std::list<TestConnection> test_connections;

  boost::recursive_mutex server_received_mutex;
  int32_t server_received = 0;

  std::atomic<bool> finished(false);

  std::function<void(const boost::system::error_code&, std::size_t,
                     std::promise<bool>&, fiber&, buffer_type&)>
      async_receive_h1;
  std::function<void(const boost::system::error_code&, std::size_t,
                     std::promise<bool>&, fiber&, buffer_type&)> async_send_h1;

  async_receive_h1 = [&](const boost::system::error_code& ec, std::size_t,
                         std::promise<bool>& closed, fiber& fib,
                         buffer_type& buffer_server) {

    if (ec) {
      boost::recursive_mutex::scoped_lock lock_server_received(
          server_received_mutex);
      ASSERT_EQ(packet_number, server_received);
      return;
    }

    ASSERT_EQ(buffer_server[0], 'a');
    ASSERT_EQ(buffer_server[1], 'b');
    ASSERT_EQ(buffer_server[2], 'c');
    ASSERT_EQ(buffer_server[3], 'd');
    ASSERT_EQ(buffer_server[4], 'e');

    buffer_server[0] = '1';
    buffer_server[1] = '2';
    buffer_server[2] = '3';
    buffer_server[3] = '4';
    buffer_server[4] = '5';

    boost::recursive_mutex::scoped_lock lock(server_received_mutex);
    if (++server_received < packet_number - 4) {
      boost::asio::async_write(
          fib, boost::asio::buffer(buffer_server),
          boost::bind<void>(async_send_h1, _1, _2, boost::ref(closed),
                            boost::ref(fib), boost::ref(buffer_server)));
    } else if (server_received < packet_number) {
      fib.close();
      closed.set_value(true);
    } else {
      finished = true;
      fib.close();
      closed.set_value(true);
    }
  };

  async_send_h1 = [&](const boost::system::error_code& ec, std::size_t,
                      std::promise<bool>& closed, fiber& fib,
                      buffer_type& buffer_server) {
    ASSERT_EQ(ec.value(), 0);
    boost::asio::async_read(
        fib, boost::asio::buffer(buffer_server),
        boost::bind<void>(async_receive_h1, _1, _2, boost::ref(closed),
                          boost::ref(fib), boost::ref(buffer_server)));
  };

  auto async_accept_h = [&, this](const boost::system::error_code& ec,
                                  std::promise<bool>& closed, fiber& fib,
                                  buffer_type& buffer_server) {
    EXPECT_EQ(ec.value(), 0);

    buffer_server[0] = '1';
    buffer_server[1] = '2';
    buffer_server[2] = '3';
    buffer_server[3] = '4';
    buffer_server[4] = '5';

    boost::asio::async_read(
        fib, boost::asio::buffer(buffer_server),
        boost::bind<void>(async_receive_h1, _1, _2, boost::ref(closed),
                          boost::ref(fib), boost::ref(buffer_server)));
  };

  std::function<void(const boost::system::error_code&, std::size_t,
                     std::promise<bool>&, fiber&, buffer_type&)>
      async_receive_h2;
  std::function<void(const boost::system::error_code&, std::size_t,
                     std::promise<bool>&, fiber&, buffer_type&)> async_send_h2;

  async_receive_h2 = [&](const boost::system::error_code& ec, std::size_t,
                         std::promise<bool>& closed, fiber& fib,
                         buffer_type& buffer_client) {
    if (!ec) {
      ASSERT_EQ(buffer_client[0], '1');
      ASSERT_EQ(buffer_client[1], '2');
      ASSERT_EQ(buffer_client[2], '3');
      ASSERT_EQ(buffer_client[3], '4');
      ASSERT_EQ(buffer_client[4], '5');
      buffer_client[0] = 'a';
      buffer_client[1] = 'b';
      buffer_client[2] = 'c';
      buffer_client[3] = 'd';
      buffer_client[4] = 'e';

      boost::asio::async_write(
          fib, boost::asio::buffer(buffer_client),
          boost::bind<void>(async_send_h2, _1, _2, boost::ref(closed),
                            boost::ref(fib), boost::ref(buffer_client)));
    } else {
      fib.close();
      closed.set_value(true);
    }
  };

  async_send_h2 = [&](const boost::system::error_code& ec, std::size_t,
                      std::promise<bool>& closed, fiber& fib,
                      buffer_type& buffer_client) {
    EXPECT_EQ(ec.value(), 0);
    boost::asio::async_read(
        fib, boost::asio::buffer(buffer_client),
        boost::bind<void>(async_receive_h2, _1, _2, boost::ref(closed),
                          boost::ref(fib), boost::ref(buffer_client)));
  };

  auto async_connect_h = [&](std::promise<bool>& closed, fiber& fib,
                             buffer_type& buffer_client,
                             const boost::system::error_code& ec) {
    ASSERT_EQ(ec.value(), 0);

    buffer_client[0] = 'a';
    buffer_client[1] = 'b';
    buffer_client[2] = 'c';
    buffer_client[3] = 'd';
    buffer_client[4] = 'e';

    boost::asio::async_write(
        fib, boost::asio::buffer(buffer_client),
        boost::bind<void>(async_send_h2, _1, _2, boost::ref(closed),
                          boost::ref(fib), boost::ref(buffer_client)));
  };

  boost::system::error_code acceptor_ec;
  fiber_endpoint server_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_server_, 1);
  fib_acceptor.open(server_endpoint.protocol(), acceptor_ec);
  fib_acceptor.bind(server_endpoint, acceptor_ec);
  fib_acceptor.listen(boost::asio::socket_base::max_connections, acceptor_ec);

  fiber_endpoint client_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_client_, 1);

  for (std::size_t i = 0; i < connection_number; ++i) {
    test_connections.emplace_front(io_service_server_, io_service_client_);
    auto& test_connection = test_connections.front();
    fib_acceptor.async_accept(
        test_connection.fib_server,
        boost::bind<void>(async_accept_h, _1,
                          boost::ref(test_connection.server_closed),
                          boost::ref(test_connection.fib_server),
                          boost::ref(test_connection.buffer_server)));
    test_connection.fib_client.async_connect(
        client_endpoint,
        boost::bind<void>(async_connect_h,
                          boost::ref(test_connection.client_closed),
                          boost::ref(test_connection.fib_client),
                          boost::ref(test_connection.buffer_client), _1));
  }

  for (auto& test_connection : test_connections) {
    test_connection.client_closed.get_future().wait();
    test_connection.server_closed.get_future().wait();
  }

  ASSERT_EQ(packet_number, server_received);
  boost::system::error_code close_fib_acceptor_ec;
  fib_acceptor.close(close_fib_acceptor_ec);

  ASSERT_EQ(finished, true) << "Test did not finish completely";
}
示例#5
0
//-----------------------------------------------------------------------------
TEST_F(FiberTest, exchangePackets) {
  boost::log::core::get()->set_filter(boost::log::trivial::severity >=
                                      boost::log::trivial::info);

  Wait();

  const int32_t packet_number = 1000;
  std::promise<bool> client_closed;
  std::promise<bool> server_closed;

  fiber_acceptor fib_acceptor(io_service_server_);
  fiber fib_server(io_service_server_);
  fiber fib_client(io_service_client_);

  uint8_t buffer_client[5] = {0};
  uint8_t buffer_server[5] = {0};
  bool result_server = true;
  int server_received = 0;

  std::function<void(const boost::system::error_code & ec, std::size_t)>
      async_receive_h1;
  std::function<void(const boost::system::error_code & ec, std::size_t)>
      async_send_h1;

  async_receive_h1 = [&, this](const boost::system::error_code& ec,
                               std::size_t) {
    ASSERT_EQ(ec.value(), 0);

    result_server &= (buffer_server[0] == 'a');
    result_server &= (buffer_server[1] == 'b');
    result_server &= (buffer_server[2] == 'c');
    result_server &= (buffer_server[3] == 'd');
    result_server &= (buffer_server[4] == 'e');

    buffer_server[0] = '1';
    buffer_server[1] = '2';
    buffer_server[2] = '3';
    buffer_server[3] = '4';
    buffer_server[4] = '5';

    if (++server_received < packet_number) {
      boost::asio::async_write(fib_server, boost::asio::buffer(buffer_server),
                               boost::bind<void>(async_send_h1, _1, _2));
    } else {
      fib_server.close();
      server_closed.set_value(true);
    }
  };

  async_send_h1 = [&, this](const boost::system::error_code& ec, std::size_t) {
    ASSERT_EQ(ec.value(), 0);

    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(async_receive_h1, _1, _2));
  };

  auto async_accept_h = [&, this](const boost::system::error_code& ec) {
    ASSERT_EQ(ec.value(), 0);

    buffer_server[0] = '1';
    buffer_server[1] = '2';
    buffer_server[2] = '3';
    buffer_server[3] = '4';
    buffer_server[4] = '5';

    boost::asio::async_read(fib_server, boost::asio::buffer(buffer_server),
                            boost::bind<void>(async_receive_h1, _1, _2));
  };

  std::function<void(const boost::system::error_code & ec, std::size_t)>
      async_receive_h2;
  std::function<void(const boost::system::error_code & ec, std::size_t)>
      async_send_h2;

  async_receive_h2 = [&, this](const boost::system::error_code& ec,
                               std::size_t) {
    if (!ec) {
      buffer_client[0] = 'a';
      buffer_client[1] = 'b';
      buffer_client[2] = 'c';
      buffer_client[3] = 'd';
      buffer_client[4] = 'e';

      boost::asio::async_write(fib_client, boost::asio::buffer(buffer_client),
                               boost::bind<void>(async_send_h2, _1, _2));
    } else {
      fib_client.close();
      client_closed.set_value(true);
    }
  };

  async_send_h2 = [&, this](const boost::system::error_code& ec, std::size_t) {
    ASSERT_EQ(ec.value(), 0);
    boost::asio::async_read(fib_client, boost::asio::buffer(buffer_client),
                            boost::bind<void>(async_receive_h2, _1, _2));
  };

  auto async_connect_h = [&, this](const boost::system::error_code& ec) {
    ASSERT_EQ(ec.value(), 0);
    buffer_client[0] = 'a';
    buffer_client[1] = 'b';
    buffer_client[2] = 'c';
    buffer_client[3] = 'd';
    buffer_client[4] = 'e';

    boost::asio::async_write(fib_client, boost::asio::buffer(buffer_client),
                             boost::bind<void>(async_send_h2, _1, _2));
  };

  boost::system::error_code acceptor_ec;
  fiber_endpoint server_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_server_, 1);
  fib_acceptor.open(server_endpoint.protocol(), acceptor_ec);
  fib_acceptor.bind(server_endpoint, acceptor_ec);
  fib_acceptor.listen(boost::asio::socket_base::max_connections, acceptor_ec);
  fib_acceptor.async_accept(fib_server, boost::bind<void>(async_accept_h, _1));

  fiber_endpoint client_endpoint(boost::asio::fiber::stream_fiber<socket>::v1(),
                                 demux_client_, 1);
  fib_client.async_connect(client_endpoint,
                           boost::bind<void>(async_connect_h, _1));

  client_closed.get_future().wait();
  server_closed.get_future().wait();

  ASSERT_EQ(true, result_server);
  ASSERT_EQ(packet_number, server_received);
  boost::system::error_code close_fib_acceptor_ec;
  fib_acceptor.close(close_fib_acceptor_ec);
}