#ifndef __NETWORK_PROTOCOL_HTTP_CLIENT_20080923_1_HPP__

#define__NETWORK_PROTOCOL_HTTP_CLIENT_20080923_1_HPP__

#ifndef BOOST_NETLIB_VERSION

#defineBOOST_NETLIB_VERSION"0.3"

#endif

#include<boost/network/protocol/http/tags.hpp>

namespaceboost {namespacenetwork {namespacehttp {

template<classtag,unsigned version_major,unsigned version_minor>

classbasic_client;

typedef basic_client<http::message_tag,1,0> client;

}// namespace http

}// namespace network

}// namespace boost

#endif// __NETWORK_PROTOCOL_HTTP_CLIENT_20080923_1_HPP__

fusion::pair<typename tags::query,typename string_traits<tag>::type>,

fusion::pair<typename tags::anchor,typename string_traits<tag>::type>

> uri_parts_type;

mutable uri_parts_type uri_parts;

explicitbasic_request(typename string_traits<tag>::typeconst & uri) {

explicitbasic_request(typename string_traits<tag>::typeconst & uri_) {

uri(uri_);

}

voiduri(typename string_traits<tag>::typeconst & uri_) {

usingnamespaceboost::spirit;

fusion::at_key<typename tags::port>(uri_parts) =80u;

parse(

uri.begin(),uri.end(),

uri_.begin(),uri_.end(),

str_p("http")[

var(fusion::at_key<typename tags::protocol>(uri_parts))

= construct_<typename string_traits<tag>::type>(arg1, arg2)

]

>>str_p("://")

!(

str_p("http")[

var(fusion::at_key<typename tags::protocol>(uri_parts))

= construct_<typename string_traits<tag>::type>(arg1, arg2)

]

>>str_p("://")

)

>> (+(alnum_p |'.' |'-' |'_'))[

var(fusion::at_key<typename tags::host>(uri_parts))

= construct_<typename string_traits<tag>::type>(arg1, arg2)

= arg1

]

>> !ch_p('/')

)

)

>> (+(alnum_p |'/' |'%' |'_' |'-' |'.'))[

var(fusion::at_key<typename tags::path>(uri_parts))

= construct_<typename string_traits<tag>::type>(arg1, arg2)

basic_message<tag>(), uri_parts()

{ }

basic_request(basic_requestconst & other) :

basic_request(basic_requestconst & other) :

basic_message<tag>(other), uri_parts(other.uri_parts)

{ }

template<classTag>

structbasic_response :publicmessage_impl<Tag> {

typedef message_impl<Tag> base_type;

typedeftypename string<Tag>::type string_type;

string_type version_;

typedef Tag tag;

basic_response()

: version_(), status_(0u), status_message_()

: base_type(), version_(), status_(0u), status_message_()

{ };

basic_response(basic_responseconst & other)

: base_type(other), version_(other.version_), status_(other.status_), status_message_(other.status_message_)

{ };

string_type &version() {

}// namespace http

}// namespace network

}// namespace network

}// namespace boost

#ifndef __NETWORK_PROTOCOL_MIME__

#define__NETWORK_PROTOCOL_MIME__

#include<string>

#include<boost/network/message/tags.hpp>

#include<boost/network/message/traits.hpp>

namespaceboost {namespacenetwork {namespacemime {

template<typename Tag>

classmime {

friendtypename ostringstream<Tag> &

operator << (typename ostringstream<Tag> & out,consttypename mime<Tag> & m);

typedeftypename headers_container<Tag>::type parameter_map;

typedeftypename string<Tag>::type string_type;

std::stringtype() {return _type; }

string_typebody() {return _body; }

std::stringencoding() {return _encoding; }

std::stringboundary() {return _boundary; }

std::stringdisposition() {return _disposition; }

const parameter_map &type_parameters() {return _type_params; }

const parameter_map &disposition_parameters() {return _disposition_params; }

voidset_disposition(std::string d) { _disposition = d; }

voidset_disposition_parameter(std::string param, std::string value) { _disposition_params[param] = value; }

voidset_type(std::string t) { _type = t; }

voidset_type_parameter(std::string param, std::string value) { _type_params[param] = value; }

voidset_body(std::string b) { _body = b; }

voidset_encoding(encoding_type e) { _encoding = e; }

voidset_boundary(std::string b) { _boundary = b; }

std::string _disposition;

parameter_map _disposition_params;

std::string _type;

parameter_map _type_params

string_type _body;

std::string _boundary;

std::string _encoding;

};

template<classTag>

ostringstream<Tag> &operator << (ostringstream<Tag> & out,const mime & m)

{

std::string CRLF ="\r\n";

out <<"--" << m._boundary << CRLF << CRLF;

if (m._type.size() >0)

out <<"Content-Type:" << m._type;

out <<"Content-Type: text/plain";

typedeftypename headers_container<Tag>::typemap_t;

typedeftypenamemap_t::const_iteratoriter_t;

if (m._type_params.empty())

out <<"; charset=us-ascii" << CRLF;

else {

for (iter_t i = m._type_params.begin(); i != m._type_params.end(); ++i)

{

out <<";" << i->first <<"=" << i->second;

}

out << CRLF;

}

if (m._encoding.size() >0)

out <<"Content-Type-Encoding:" << m._encoding << CRLF;

out <<"Content-Type-Encoding: 7bit";

if (m._disposition.size() >0) {

out <<"Content-Disposition:" << m._disposition;

for (iter_t i = m._disposition_params.begin(); i != m._disposition_params.end(); ++i)

{

out <<";" << i->first <<"=" << i->second;

}

out << CRLF;

}

out << CRLF;

out << m._body;

out << CRLF;

out <<"--" << m._boundary << CRLF << CRLF;

}

}// namespace mime

}// namespace network

}// namespace boost

#endif// __NETWORK_PROTOCOL_MIME__

[section:architecture Architecture]

__cnl__ is built upon the __boost_asio__, for reasons of portability.

The architecture is driven by the requirement to separate requests from the transport mechanism. Additionally, its possible to utilise templates and static mechanisms to make decisions at compile-time, resulting in more efficient and stable client code.

The architecture is driven by the requirement to separate requests from the transport mechanism. Additionally, it's possible to utilise templates and static mechanisms to make decisions at compile-time, resulting in more efficient and stable client code.

There are two main features of the architecture which use modern C++ techniques to allow extensibility without comprimising efficiency: tags and directives. These underly the design of the message.

[include message.qbk]

[include tags_and_directives.qbk]

[endsect]

[section:http HTTP]

__cnl__ provides direct support for HTTP. A motivating example will show how it's intended to work:

The__cnl__ provides direct support for HTTP. A motivating example will show how it's intended to work:

#include <boost/network/protocol/http.hpp>

#include <iostream>

headers_range<http::response>::type hdrs = headers(response);

boost::range_iterator<headers_range<http::response>::type>::type

it = boost::begin(hdrs), end = boost::end(hdrs);

for (; it != end; ++it)

std::cout << it->first << ": " << it->second << std::endl;

for (; it != end; ++it){

std::cout << it->first << ": " << it->second << std::endl;

}

// print response body

http::request request("http://www.boost.org/");

This line frames the request for the resource __boost_org__. This is slightly different to what one would normally expect from a request type, but there are good reasons for this.Its useful to consider a [^request] object as the base unit of data used to instruct the client what to do.

This line frames the request for the resource __boost_org__. This is slightly different to what one would normally expect from a request type, but there are good reasons for this.Consider a [^request] object as the base unit of data used to instruct the client what to do.

http::client client;

Once the request has been made, and the [^client] returns a [^response] object, the rest is simple. This example outputs all the response headers and body, in this case just the Boost homepage.

[endsect]

[heading Using [^http::client]]

The [^http::client] supports the following operations:

* [^http::client::head]

* [^http::client::get]

* [^http::client::post]

* [^http::client::put]

* [^http::client::delete_]

HTTP features can be enabled by using constructor arguments:

* [^http::client(http::client::cache_resolved)]

* [^http::client(http::client::follow_redirect)]

[h5 [^http::client::cache_resolved]]

This argument enables the caching of resolved endpoints and prevents the client from resolving IP addresses of previously resolved hostnames.

[h5 [^http::client::follow_redirect(s)]]

[^http::client::follow_redirects] / [^http::client::follow_redirect] follow HTTP redirect(s) (300..307) by looking at the "Location" header provided by the response(s); headers present in the original request are preserved in the subsequent request(s).

[endsect]

The message template interface is presented below:

namespace boost { namespace network {

template <class Tag>

template <

class Tag

>

class basic_message {

public:

typedefimplementation_defined headers_container_type;

typedefimplementation_defined string_type;

typedeftypename headers_container<Tag>::type headers_container_type;

typedeftypename string<Tag>::type string_type;

basic_message(const basic_message &);

basic_message &operator = (const basic_message &);

typedef basic_message<tags::default_> message; // default message type

}}

The __message__ template has a single argument (Tag). Tags are useful because:

# It's possible to specialize the message for different storage requirements;

# It's possible to extend the message to support different network protocols.

The use of tags is discussed in further detail in the next section.

[h4 Concepts]

=basic_message= supports the CopyConstructible, Assignable and Swappable concepts, as do all itsderivates.

__message__ supports the CopyConstructible, Assignable and Swappable concepts, as do all itsderivatives.

[endsect]

[def __boost_org__ [@http://www.boost.org/]]

[def __boost_asio__ [@http://www.boost.org/libs/asio/index.html Boost.Asio]]

[def __boost_system__ [@http://www.boost.org/libs/system/index.html Boost.System]]

[def __boost_type_traits__ [@http://www.boost.org/libs/type_traits/index.html Boost.TypeTraits]]

[def __pion__ [@http://www.pion.org/projects/pion-network-library the Pion Network Library]]

[def __cnl__ C++ Network Library]

[def __message__ [^basic_message]]

[def __python__ [@http://www.python.org Python]]

[include motivation.qbk]

[include using.qbk]

[include architecture.qbk]

[section:protocol Application Layer Protocols]

[include http.qbk]

[endsect]

[include protocol.qbk]

[include examples.qbk]

[include reference.qbk]

[include acknowledgements.qbk]

[/

(C) Copyright 2008 Glyn Matthews.

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).

]

[section:protocol Application Layer Protocols]

[include http.qbk]

The message alone isn't any use. This section describes some of the common network protocols that are implemented in the __cnl__.

[endsect]