3 replies to this topic

[poter]

Hi! I am asked to code an asynchronous non-blocking echo server in C++ that compiles in both Windows and Unix platforms. Having no background in networking, I don't know where to start. Any help would be appreciated. Thank you.

[LogicKills]

Beej's Guide to Network Programming

^^ Start there ^^

It will be challenging at first, but you can make some fun programs with sockets.


If you have any other specific questions feel free to ask.
Also, when writing C++ 'sockets' you usually have to implement some sort of wrapper class.

Further research into that would be a good idea once you get the basics down.

Good luck.

[gamzi]

Hi! I found this code under the boost c++ libraries. I also read that it is platform independent. Here's the code:

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

class session
{
public:
session(boost::asio::io_service& io_service)
: socket_(io_service)
{
}

tcp::socket& socket()
{
return socket_;
}

void start()
{
socket_.async_read_some(boost::asio::buffer(data_, max_length),
boost::bind(&session::handle_read, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}

void handle_read(const boost::system::error_code& error,
size_t bytes_transferred)
{
if (!error)
{
boost::asio::async_write(socket_,
boost::asio::buffer(data_, bytes_transferred),
boost::bind(&session::handle_write, this,
boost::asio::placeholders::error));
}
else
{
delete this;
}
}

void handle_write(const boost::system::error_code& error)
{
if (!error)
{
socket_.async_read_some(boost::asio::buffer(data_, max_length),
boost::bind(&session::handle_read, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
else
{
delete this;
}
}

private:
tcp::socket socket_;
enum { max_length = 1024 };
char data_[max_length];
};

class server
{
public:
server(boost::asio::io_service& io_service, short port)
: io_service_(io_service),
acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
{
session* new_session = new session(io_service_);
acceptor_.async_accept(new_session->socket(),
boost::bind(&server::handle_accept, this, new_session,
boost::asio::placeholders::error));
}

void handle_accept(session* new_session,
const boost::system::error_code& error)
{
if (!error)
{
new_session->start();
new_session = new session(io_service_);
acceptor_.async_accept(new_session->socket(),
boost::bind(&server::handle_accept, this, new_session,
boost::asio::placeholders::error));
}
else
{
delete new_session;
}
}

private:
boost::asio::io_service& io_service_;
tcp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
try
{
if (argc != 2)
{
std::cerr << "Usage: async_tcp_echo_server <port>\n";
return 1;
}

boost::asio::io_service io_service;

using namespace std; // For atoi.
server s(io_service, atoi(argv[1]));

io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}

return 0;
}


I'm having a hard time understanding this code. Can someone familiar with this code help me out in understanding how the code works? Really sorry because I'm not really familiar with network programming. Thank you.

[gamzi]

Hi! I am not clear as to whether you always need to declare a session class to be able to use asynchronous read and write functions? And also I'm not really that clear about the flow of the program. Thank you and any help would be appreciated.