C++ Network Library

Introduction

cpp-netlib is a collection of network related routines/implementations

geared towards providing a robust cross-platform networking library.

cpp-netlib offers the following implementations:

* Common Message Type -- A generic message type which can be used

to encapsulate and store message related information, used by all

network implementations as the primary means of data exchange.

* Network protocol message parsers -- A collection of parsers which

generate message objects from strings.

* Adapters and Wrappers -- A collection of Adapters and wrappers aimed

towards making the message type STL friendly.

* Network protocol client and server implementations -- A collection

of network protocol implementations that include embeddable client

and server types.

This library is released under the Boost Software License (please see

http://boost.org/LICENSE_1_0.txt or the accompanying LICENSE_1_0.txt file

for the full text.

Downloading cpp-netlib

You can find official release packages of the library at::

Building and Installing

Since cpp-netlib is a header-only library, there is nothing to build. To install

cpp-netlib, you can choose to copy the contents of the ``boost`` directory into

an existing Boost [#]_ distribution or to a different location. All that is

required is for projects that use cpp-netlib when building, have the directory

where cpp-netlib is installed as part of the include paths.

.. [#]http://www.boost.org/

The recommended installation procedure would be to follow the steps below::

Now don't forget to add ``/usr/local/include/cpp-netlib`` in your project's

compiler include directories to start using cpp-netlib in your projects.

Running Tests

If you want to run the tests that come with cpp-netlib, there are a few things

you will need. These are:

* A compiler (GCC 4.x or Clang 2.8)

* A build tool (CMake [#]_ recommended, Boost.Build also an option)

* OpenSSL headers (optional with CMake, mandatory for Boost.Build)

* Python 2.6

..note::This assumes that you have the cpp-netlib distribution package

unpacked somwhere in your home directory. This specifically assumes that you

have cpp-netlib at the toplevel of your home directory.

.. [#]http://www.cmake.org/

Building with CMake

To build and run the tests with CMake, you will need to have CMake version 2.8

or higher installed appropriately in your system.

::

Inside the cpp-netlib directory, you can issue the following statements to

configure and generate the Makefiles, and build the tests::

..note::This uses the source directory as the build directory as well. At the

time of this writing, cpp-netlib is meant to be tested in the same directory

where the source files are, because of the way the tests depend on Python

being installed and having access to Python scripts during the build.

Once CMake is done with generating the Makefiles and configuring the project,

you can now build the tests and run them::

If for some reason some of the tests fail, you can send the files in

``Testing/Temporary/`` as attachments to the cpp-netlib `developers mailing

list`_.

.. _`developers mailing list`:https://lists.sourceforge.net/lists/listinfo/cpp-netlib-devel

Building with Boost.Build

If you don't already have Boost.Build set up on your system, follow the steps

indicated in the Boost Getting Started Guide [#]_ -- you will particularly want

to copy the ``bjam`` executable to a directory that is already in your ``PATH``

so that you don't have to go hunting for it all the time. A good place to put it

is in ``/usr/local/bin``.

.. [#]http://www.boost.org/doc/libs/1_44_0/more/getting_started/index.html

Building and running the tests can be as simple as doing the following::

Doing this will already build all the tests and run them as they are built. In

case you encounter any problems and would like to report it to the developers,

please do the following::

And then attach the ``build-test.log`` file to the email you will send to the

cpp-netlib `developers mailing list`_.

.. _`developers mailing list`:https://lists.sourceforge.net/lists/listinfo/cpp-netlib-devel

Hacking on cpp-netlib

cpp-netlib is being developed with thegit_ distributed SCM system.

cpp-netlib is hosted onGitHub_ following the GitHub recommended practice of

forking the repository and submitting pull requests to the source repository.

You can read more about theforking_ process and submitting `pull requests`_ if

you're not familiar with either process yet.

.. _git:http://git-scm.com/

.. _GitHub:http://github.com/

.. _forking:http://help.github.com/forking/

.. _`pull requests`:http://help.github.com/pull-requests/

Because cpp-netlib is released under the `Boost Software License`_ it is

recommended that any file you make changes to bear your copyright notice

alongside the original authors' copyright notices on the file. Typically the

copyright notices are at the top of each file in the project.

.. _`Boost Software License`:http://www.boost.org/LICENSE_1_0.txt

At the time of writing, there are no coding conventions being followed but if

you write in the general style that is already existing in the project that

would be greatly appreciated. Copious amounts of comments will be called out,

but code that is not self-explanatory typically at least requires a rationale

documentation in comments explaining "why" the code is written that way.

The main "upstream" repository is the one hosted by the original maintainer of

the project (Dean Michael Berris) at http://github.com/mikhailberis/cpp-netlib.

The "official" release repository is maintained at

http://github.com/cpp-netlib/cpp-netlib -- which is a fork of the upstream

repository. It is recommended that forks be made against the upstream repostory

and pull requests be submitted against the upstream repository so that patches

and other implementations can be curated by the original maintainer.

Contact and Commercial Support

In case you have any questions or would like to make feature requests, you can

contact the development team through the `developers mailing list`_

or by filing issues at http://github.com/mikhailberis/cpp-netlib/issues.

.. _`developers mailing list`:

You can reach the maintainers of the project through::

At this time, paid commercial support is available for cpp-netlib being offered

by the maintainers. In case you have any questions, please feel free to contact

any one of the maintainers above or anybody on the developers mailing list.

#include<boost/network/message/directives/detail/string_directive.hpp>

#include<boost/network/message/directives/detail/string_value.hpp>

#include<boost/network/support/is_default_string.hpp>

namespaceboost {namespacenetwork {

namespaceimpl {

voidoperator()(typename detail::string_value<typename Message::tag>::typeconst & source)const {

message_.source(source);

}

template<classT>voidoperator()(Tconst &)const {

template<classT>voidoperator()(Tconst & source)const {

}

};

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

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

#include<boost/network/support/sync_only.hpp>

namespaceboost {namespacenetwork {namespacehttp {

template<classTag,unsigned version_major,unsigned version_minor>

typedef basic_client_impl<Tag,version_major,version_minor> pimpl_type;

typedef basic_client_facade<Tag, basic_client<Tag,version_major,version_minor> > base_facade_type;

typedef basic_request<Tag> request;

typedef basic_request<typename sync_only<Tag>::type> request;

typedef basic_response<Tag> response;

typedeftypename string<Tag>::type string_type;

typedef Tag tag_type;

friendstructbasic_client_facade<Tag,basic_client<Tag,version_major,version_minor> > ;

basic_response<Tag>constrequest_skeleton(basic_request<Tag>const & request_, string_type method,bool get_body) {

basic_response<Tag>constrequest_skeleton(requestconst & request_, string_type method,bool get_body) {

return pimpl->request_skeleton(request_, method, get_body);

}

#include<boost/asio/strand.hpp>

#include<boost/thread/thread.hpp>

#include<boost/bind.hpp>

#include<boost/network/support/sync_only.hpp>

namespaceboost {namespacenetwork {namespacehttp {

)));

}

~async_client()

~async_client()throw ()

{

sentinel_.reset();

lifetime_thread_->join();

lifetime_thread_.reset();

}

basic_response<Tag>constrequest_skeleton(

basic_request<Tag>const & request_,

basic_request<typename sync_only<Tag>::type>const & request_,

string_typeconst & method,

bool get_body

)

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

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

#include<boost/network/support/sync_only.hpp>

namespaceboost {namespacenetwork {namespacehttp {

structbasic_client_facade {

typedeftypename string<Tag>::type string_type;

typedef basic_request<Tag> request;

typedef basic_request<typename sync_only<Tag>::type> request;

typedef basic_response<Tag> response;

basic_client_facade()

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

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

#include<boost/network/support/sync_only.hpp>

namespaceboost {namespacenetwork {namespacehttp {

~sync_client() {}

basic_response<Tag>constrequest_skeleton(basic_request<Tag>const & request_, string_type method,bool get_body) {

basic_response<Tag>constrequest_skeleton(basic_request<typename sync_only<Tag>::type>const & request_, string_type method,bool get_body) {

typename connection_base::connection_ptr connection_;

connection_ =connection_base::get_connection(resolver_, request_);

return connection_->send_request(method, request_, get_body);

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

#include<boost/asio/streambuf.hpp>

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

#include<boost/network/support/sync_only.hpp>

namespaceboost {namespacenetwork {namespacehttp {namespacedetail {

typedeftypename string<Tag>::type string_type;

voidcreate_request(boost::asio::streambuf & request_buffer, string_typeconst & method, basic_request<Tag> request_)const {

voidcreate_request(boost::asio::streambuf & request_buffer, string_typeconst & method, basic_request<typename sync_only<Tag>::type> request_)const {

std::ostreamrequest_stream(&request_buffer);

typedeftypename resolver_base::resolver_type resolver_type;

typedeftypename resolver_base::resolve_function resolve_function;

typedeftypename string<Tag>::type string_type;

typedef basic_request<Tag> request;

typedef basic_request<typename sync_only<Tag>::type> request;

typedef basic_response<Tag> response;

static async_connection_base<Tag,version_major,version_minor>*new_connection(resolve_function resolve, boost::shared_ptr<resolver_type> resolver,bool follow_redirect,bool https) {

staticboost::shared_ptr<async_connection_base<Tag,version_major,version_minor>>new_connection(resolve_function resolve, boost::shared_ptr<resolver_type> resolver,bool follow_redirect,bool https) {

if (https) {

#ifdef BOOST_NETWORK_ENABLE_HTTPS

throwstd::runtime_error("HTTPS not supported.");

#endif

}

returndynamic_cast<async_connection_base<Tag,version_major,version_minor>*>(new http_async_connection<Tag,version_major,version_minor>(resolver, resolve, follow_redirect));

boost::shared_ptr<async_connection_base<Tag,version_major,version_minor> > temp;

temp.reset(new http_async_connection<Tag,version_major,version_minor>(resolver, resolve, follow_redirect));

assert(temp.get() !=0);

return temp;

}

virtual responsestart(requestconst & request, string_typeconst & method,bool get_body) = 0;