int main(int argc, char *argv[])
{
std::string app_name(argv[0]);
// Get a hostname and uri from the user (assume default http port)
if (argc != 3)
{
std::cout << "Usage: " << app_name << " [host] [uri]\n"
<< "E.g. " << app_name << " localhost /hello"
<< std::endl;
return 1;
}
std::string host_name(argv[1]);
uri = argv[2];
std::cout << app_name <<" host: " << host_name
<< " uri: " << uri << std::endl;
try
{
// The asio io_service.
boost::asio::io_service io_service;
// Create an http_client and attach the response & chunk handlers
http_client =
https_client_type::create(io_service, response_handler, chunk_handler);
// attach optional handlers
http_client->connected_event(connected_handler);
http_client->disconnected_event(disconnected_handler);
// Set up SSL
std::string certificate_file = "cacert.pem";
boost::asio::ssl::context& ssl_context
(https_client_type::connection_type::ssl_context());
ssl_context.load_verify_file(certificate_file);
// attempt to connect to the host on the standard https port (443)
if (!http_client->connect(host_name, "https"))
{
std::cout << "Error, could not resolve host: " << host_name << std::endl;
return 1;
}
// run the io_service to start communications
io_service.run();
std::cout << "io_service.run complete, shutdown successful" << std::endl;
}
catch (std::exception& e)
{
std::cerr << "Exception:" << e.what() << std::endl;
}
return 0;
}
void encryption::init(encryption_method method)
{
_last_error.clear();
_method = method;
_ca_filename.clear();
_cert_filename.clear();
_private_key_filename.clear();
_verify_mode = ssl_verify_none;
_verify_callback = verify_callback();
_context = std::move(ssl_context(static_cast<ssl_context::method>(_method)));
}
bool network_client::connect(const char* ip, int port) {
if (connected_) {
last_error_ = boost::system::errc::make_error_code(boost::system::errc::already_connected);
return false;
}
if (io_service_ == nullptr) {
io_service_ = io_service_pt(new asio_io_service_t());
}
if (strand_ == nullptr) {
strand_ = strand_pt(new asio_strand_t(*io_service_));
}
boost::container::vector<unsigned char> cert_buff, key_buff;
if (!make_certificate(cert_buff, key_buff)) {
// @todo: make custom errors
last_error_ = boost::system::errc::make_error_code(boost::system::errc::not_supported);
return false;
}
asio_ssl_context_t ssl_context(*io_service_, asio_ssl_context_t::tlsv1);
ssl_context.set_verify_mode(asio_ssl_context_t::verify_none);
ssl_context.use_certificate(boost::asio::const_buffer(cert_buff.data(), cert_buff.size()), asio_ssl_context_t::asn1);
ssl_context.use_private_key(boost::asio::const_buffer(key_buff.data(), key_buff.size()), asio_ssl_context_t::asn1);
ssl_socket_ = ssl_socket_pt(new asio_ssl_socket_t(*io_service_, ssl_context));
auto endpoint = boost::asio::ip::tcp::endpoint(
boost::asio::ip::address::from_string(ip), port);
ssl_socket_->next_layer().async_connect(endpoint, strand_->wrap(boost::bind(&network_client::handle_connect, this, boost::asio::placeholders::error)));
t_ = boost::thread(boost::bind(static_cast<size_t (boost::asio::io_service::*)()>(&boost::asio::io_service::run), io_service_));
return true;
}
/// The ssl_tcp_adaptor constructor.
/// @param io_service the asio io_service associted with this connection
explicit ssl_tcp_adaptor(ASIO::io_service& io_service) :
io_service_(io_service),
socket_(io_service_, ssl_context()),
host_iterator_()
{}
int main(int argc, char* argv[]) {
#if _WIN32
linear::log::SetLevel(linear::log::LOG_DEBUG);
linear::log::EnableStderr();
std::string host = (argc > 1) ? std::string(argv[1]) : "127.0.0.1";
int port = (argc > 2) ? atoi(argv[2]) : 37800;
#else
bool show_log = false;
linear::log::Level level = linear::log::LOG_OFF;
int ch, lv;
extern char* optarg;
extern int optind;
while ((ch = getopt(argc, argv, "hl:")) != -1) {
switch(ch) {
case 'h':
usage(argv[0]);
return 0;
case 'l':
show_log = true;
lv = atoi(optarg);
lv = (lv < 0) ? 0 : ((lv > 4) ? 4 : lv);
level = static_cast<linear::log::Level>(lv);
break;
default:
break;
}
}
argc -= optind;
argv += optind;
if (show_log) {
linear::log::SetLevel(level);
linear::log::EnableStderr();
}
std::string host = (argc >= 1) ? std::string(argv[0]) : "127.0.0.1";
int port = (argc >= 2) ? atoi(argv[1]) : 37800;
#endif
linear::shared_ptr<ApplicationHandler> handler = linear::shared_ptr<ApplicationHandler>(new ApplicationHandler());
linear::WSSClient client = linear::WSSClient(handler);
linear::SSLContext ssl_context(linear::SSLContext::TLSv1_1_client);
ssl_context.SetVerifyMode(linear::SSLContext::VERIFY_NONE);
linear::WSRequestContext ws_context;
ws_context.path = "linear";
ws_context.query = "?hoge=foo&alice=bob";
linear::WSSSocket socket= client.CreateSocket(host, port, ws_context, ssl_context);;
std::string cmd;
std::cout << "Commands: connect, disconnect, echo, notify, exit" << std::endl;
std::getline(std::cin, cmd);
while (true) {
if (cmd == "connect") {
handler->SetNumOfRetry(3);
linear::Error err = socket.Connect();
if (err.Code() != linear::LNR_OK) {
std::cout << err.Message() << std::endl;
}
} else if (cmd == "disconnect") {
handler->SetNumOfRetry(0);
linear::Error err = socket.Disconnect();
if (err.Code() != linear::LNR_OK) {
std::cout << err.Message() << std::endl;
}
} else if (cmd == "echo") {
std::string data;
std::cout << "A Response will be received by ApplicationHandler::OnMessage asynchronously" << std::endl;
std::cout << "Input some words: " << std::endl;
std::getline(std::cin, data);
linear::Request req(cmd, data);
std::cout << "msgid: " << req.msgid << std::endl;
linear::Error err = req.Send(socket, 3000);
if (err.Code() != linear::LNR_OK) {
std::cout << err.Message() << std::endl;
}
} else if (cmd == "notify") {
linear::Notify notify("from client", Derived());
linear::Error err = notify.Send(socket);
if (err.Code() != linear::LNR_OK) {
std::cout << err.Message() << std::endl;
}
} else if (cmd == "exit") {
break;
}
std::getline(std::cin, cmd);
}
return 0;
}
