doc/html/boost_asio/example/porthopper/protocol.hpp

//
// protocol.hpp
// ~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef PORTHOPPER_PROTOCOL_HPP
#define PORTHOPPER_PROTOCOL_HPP

#include <boost/array.hpp>
#include <boost/asio.hpp>
#include <cstring>
#include <iomanip>
#include <string>
#include <strstream>

// This request is sent by the client to the server over a TCP connection.
// The client uses it to perform three functions:
// - To request that data start being sent to a given port.
// - To request that data is no longer sent to a given port.
// - To change the target port to another.
class control_request
{
public:
	// Construct an empty request. Used when receiving.
	control_request()
	{
	}

	// Create a request to start sending data to a given port.
	static const control_request start(unsigned short port)
	{
		return control_request(0, port);
	}

	// Create a request to stop sending data to a given port.
	static const control_request stop(unsigned short port)
	{
		return control_request(port, 0);
	}

	// Create a request to change the port that data is sent to.
	static const control_request change(
		unsigned short old_port, unsigned short new_port)
	{
		return control_request(old_port, new_port);
	}

	// Get the old port. Returns 0 for start requests.
	unsigned short old_port() const
	{
		std::istrstream is(data_, encoded_port_size);
		unsigned short port = 0;
		is >> std::setw(encoded_port_size) >> std::hex >> port;
		return port;
	}

	// Get the new port. Returns 0 for stop requests.
	unsigned short new_port() const
	{
		std::istrstream is(data_ + encoded_port_size, encoded_port_size);
		unsigned short port = 0;
		is >> std::setw(encoded_port_size) >> std::hex >> port;
		return port;
	}

	// Obtain buffers for reading from or writing to a socket.
	boost::array<boost::asio::mutable_buffer, 1> to_buffers()
	{
		boost::array<boost::asio::mutable_buffer, 1> buffers
			= { { boost::asio::buffer(data_) } };
		return buffers;
	}

private:
	// Construct with specified old and new ports.
	control_request(unsigned short old_port, unsigned short new_port)
	{
		std::ostrstream os(data_, control_request_size);
		os << std::setw(encoded_port_size) << std::hex << old_port;
		os << std::setw(encoded_port_size) << std::hex << new_port;
	}

	// The length in bytes of a control_request and its components.
	enum
	{
		encoded_port_size = 4, // 16-bit port in hex.
		control_request_size = encoded_port_size * 2
	};

	// The encoded request data.
	char data_[control_request_size];
};

// This frame is sent from the server to subscribed clients over UDP.
class frame
{
public:
	// The maximum allowable length of the payload.
	enum { payload_size = 32 };

	// Construct an empty frame. Used when receiving.
	frame()
	{
	}

	// Construct a frame with specified frame number and payload.
	frame(unsigned long number, const std::string& payload)
	{
		std::ostrstream os(data_, frame_size);
		os << std::setw(encoded_number_size) << std::hex << number;
		os << std::setw(payload_size)
			<< std::setfill(' ') << payload.substr(0, payload_size);
	}

	// Get the frame number.
	unsigned long number() const
	{
		std::istrstream is(data_, encoded_number_size);
		unsigned long number = 0;
		is >> std::setw(encoded_number_size) >> std::hex >> number;
		return number;
	}

	// Get the payload data.
	const std::string payload() const
	{
		return std::string(data_ + encoded_number_size, payload_size);
	}

	// Obtain buffers for reading from or writing to a socket.
	boost::array<boost::asio::mutable_buffer, 1> to_buffers()
	{
		boost::array<boost::asio::mutable_buffer, 1> buffers
			= { { boost::asio::buffer(data_) } };
		return buffers;
	}

private:
	// The length in bytes of a frame and its components.
	enum
	{
		encoded_number_size = 8, // Frame number in hex.
		frame_size = encoded_number_size + payload_size
	};

	// The encoded frame data.
	char data_[frame_size];
};

#endif // PORTHOPPER_PROTOCOL_HPP