Click here to Skip to main content
15,897,704 members
Search within:


Articles / Programming Languages / C++
 

RCF - Interprocess Communication for C++

Rate me:
Please Sign up or sign in to vote.
4.94/5 (147 votes)
25 Oct 2011CPOL20 min read 4.7M   8.4K   331  
A server/client IPC framework, using the C++ preprocessor as an IDL compiler.
 
#include <vector>

#include <boost/config.hpp>
#include <boost/test/minimal.hpp>

#include <RCF/Idl.hpp>
#include <RCF/RcfServer.hpp>
#include <RCF/FilterService.hpp>
#include <RCF/OpenSslEncryptionFilter.hpp>
#include <RCF/TcpEndpoint.hpp>
#include <RCF/UdpEndpoint.hpp>
#include <RCF/ZlibCompressionFilter.hpp>

#include <RCF/util/CommandLine.hpp>
#include <RCF/util/PortNumbers.hpp>
#include <RCF/util/Platform/OS/Sleep.hpp>

#include <RCF/test/TransportFactories.hpp>

RCF_BEGIN(X, "X")
    RCF_METHOD_R0(int, func)
RCF_END(X)

class ServerImpl
{
public:
    ServerImpl() : ret(1)
    {}

    int func()
    {
        return ret++;
    }

private:
    int ret;
};

void testTransportFilters(
    const std::vector< RCF::FilterFactoryPtr > &filterFactories, 
    const std::vector< std::vector<RCF::FilterPtr> > &filterChains,
    RCF::ServerTransportPtr serverTransportPtr,
    RCF::ClientTransportAutoPtr clientTransportAutoPtr,
    bool removable = true)
{

    RCF::RcfServer server(serverTransportPtr);
    
    RCF::FilterServicePtr filterServicePtr(new RCF::FilterService);
    for (unsigned int i=0; i<filterFactories.size(); ++i)
    {
        filterServicePtr->addFilterFactory(filterFactories[i]);
    }
    server.addService( RCF::ServicePtr(filterServicePtr) );

    ServerImpl serverImpl;
    server.bind<X, ServerImpl>(serverImpl);

    server.start();

    int ret = 0;

    for (unsigned int i=0; i<filterChains.size(); ++i)
    {
        RcfClient<X> client(clientTransportAutoPtr->clone());

        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+1 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+2 );

        client.getClientStub().setTransportFilters(filterChains[i]);

        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+3 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+4 );

        if (removable)
        {
            client.getClientStub().setTransportFilters(std::vector<RCF::FilterPtr>());
        }

        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+5 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+6 );
    }
    
}

void testTransportFilters(
    const std::vector< RCF::FilterFactoryPtr > &filterFactories, 
    const std::vector< std::vector<RCF::FilterPtr> > &filterChains,
    bool removable = true)
{
    std::string ip = "localhost";
    int port = util::Ports::getNext();

    testTransportFilters(
        filterFactories, 
        filterChains,
        RCF::ServerTransportPtr( RCF::TcpEndpoint(port).createServerTransport().release() ), 
        RCF::ClientTransportAutoPtr( RCF::TcpEndpoint(ip, port).createClientTransport()),
        removable);
}


void testStatefulPayloadFilters(
    const std::vector< RCF::FilterFactoryPtr > &filterFactories, 
    const std::vector< std::vector<RCF::FilterPtr> > &filterChains)
{

    std::string ip = "localhost";
    int port = util::Ports::getNext();

    RCF::TcpEndpoint serverEndpoint(port);
    RCF::TcpEndpoint clientEndpoint(ip, port);

    RCF::RcfServer server(serverEndpoint);

    RCF::FilterServicePtr filterServicePtr(new RCF::FilterService);
    for (unsigned int i=0; i<filterFactories.size(); ++i)
    {
        filterServicePtr->addFilterFactory(filterFactories[i]);
    }
    server.addService( RCF::ServicePtr(filterServicePtr) );

    ServerImpl serverImpl;
    server.bind<X>(serverImpl);

    server.start();

    int ret = 0;

    for (unsigned int i=0; i<filterChains.size(); ++i)
    {
        const std::vector<RCF::FilterPtr> &filterChain = filterChains[i];

        RcfClient<X> client(clientEndpoint);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+1 );

        client.getClientStub().setPayloadFilters(filterChain);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+2 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+3 );

        client.getClientStub().setPayloadFilters(std::vector<RCF::FilterPtr>());
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+4 );

        client.getClientStub().setPayloadFilters(filterChain);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+5 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+6 );
    }

}

void testStatelessPayloadFilters(
    const std::vector< RCF::FilterFactoryPtr > &filterFactories, 
    const std::vector< std::vector<RCF::FilterPtr> > &filterChains)
{

    std::string ip = "127.0.0.1";
    int port = util::Ports::getNext();

//#ifndef RCF_TEST_NO_UDP
    RCF::UdpEndpoint serverEndpoint(port);
    RCF::UdpEndpoint clientEndpoint(ip, port);
//#else
//    RCF::TcpEndpoint serverEndpoint(port);
//    RCF::TcpEndpoint clientEndpoint(ip, port);
//#endif

    RCF::RcfServer server(serverEndpoint);

    RCF::FilterServicePtr filterServicePtr(new RCF::FilterService);
    for (unsigned int i=0; i<filterFactories.size(); ++i)
    {
        filterServicePtr->addFilterFactory(filterFactories[i]);
    }
    server.addService( RCF::ServicePtr(filterServicePtr) );

    ServerImpl serverImpl;
    server.bind<X>(serverImpl);

    server.start();

    int ret = 0;

    for (unsigned int i=0; i<filterChains.size(); ++i)
    {
        const std::vector<RCF::FilterPtr> &filterChain = filterChains[i];

        RcfClient<X> client(clientEndpoint);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+1 );

        client.getClientStub().setPayloadFilters(filterChain);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+2 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+3 );

        client.getClientStub().setPayloadFilters(std::vector<RCF::FilterPtr>());
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+4 );

        client.getClientStub().setPayloadFilters(filterChain);
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+5 );
        ret = client.func(RCF::Twoway); BOOST_CHECK( ret == 6*i+6 );
    }

}


void testOnewayFilters(const std::vector<RCF::FilterPtr> &filterChain1, const std::vector<RCF::FilterPtr> &filterChain2)
{
    std::string testData = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#�%&/()=";
    for (int i=0; i<256; ++i)
    {
        testData += char(i);
    }
    for (int i=0; i<1000; i++)
    {
        testData += rand() % 256;
    }

    std::string unfilteredData(testData);

    for (int i=0; i<10; ++i)
    {
        unfilteredData = unfilteredData + testData;
        std::string filteredData;
        std::string result;
        bool ok = false;
        ok = RCF::filterData(unfilteredData, filteredData, filterChain1); BOOST_CHECK(ok);
        ok = RCF::unfilterData(filteredData, result, static_cast<int>(unfilteredData.length()), filterChain2); BOOST_CHECK(ok);
        BOOST_CHECK( result == unfilteredData );
    }

}

void testOnewayFilters(RCF::FilterPtr filterPtr1, RCF::FilterPtr filterPtr2)
{
    std::vector<RCF::FilterPtr> filterChain1;
    filterChain1.push_back(filterPtr1);

    std::vector<RCF::FilterPtr> filterChain2;
    filterChain2.push_back(filterPtr2);

    testOnewayFilters(filterChain1, filterChain2);
}

int test_main(int argc, char **argv)
{
    util::CommandLineOption<std::string> scert("scert", TEMP_DIR "server.pem", "OpenSSL server certificate");
    util::CommandLineOption<std::string> spwd("spwd", "mt2316", "OpenSSL server certificate password");
    util::CommandLineOption<std::string> ccert("ccert", TEMP_DIR "client.pem", "OpenSSL client certificate");
    util::CommandLineOption<std::string> cpwd("cpwd", "mt2316", "OpenSSL client certificate password");

    util::CommandLine::getSingleton().parse(argc, argv);
  
    std::string clientCertificateFile = ccert;
    std::string clientCertificateFilePassword = cpwd;
    std::string serverCertificateFile = scert;
    std::string serverCertificateFilePassword = spwd;

    testOnewayFilters(RCF::FilterPtr( new RCF::IdentityFilter() ), RCF::FilterPtr( new RCF::IdentityFilter() ));
    testOnewayFilters(RCF::FilterPtr( new RCF::XorFilter() ), RCF::FilterPtr( new RCF::XorFilter() ));

    // TODO: figure out why this fails when using certain combinations of small buffer sizes for the zlib filters (<100 bytes)
    testOnewayFilters(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ), RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    testOnewayFilters(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ), RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));

    std::vector<RCF::FilterFactoryPtr> filterFactories;
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::IdentityFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::XorFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatelessCompressionFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatefulCompressionFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::OpenSslEncryptionFilterFactory(serverCertificateFile, serverCertificateFilePassword) ) );

    std::vector< std::vector<RCF::FilterPtr> > filterChains;
    std::vector<RCF::FilterPtr> filterChain;

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));

    filterChains.push_back(filterChain);

    testStatefulPayloadFilters(filterFactories, filterChains);

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));

    filterChains.push_back(filterChain);

    testStatelessPayloadFilters(filterFactories, filterChains);

    filterFactories.clear();
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::IdentityFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::XorFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatelessCompressionFilterFactory(7) ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatefulCompressionFilterFactory(7) ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::OpenSslEncryptionFilterFactory(serverCertificateFile, serverCertificateFilePassword) ) );

    // simple transport filter test over all stream oriented transports
    for (unsigned int i=0; i<RCF::getTransportFactories().size(); ++i)
    {
        RCF::TransportFactoryPtr transportFactoryPtr( RCF::getTransportFactories()[i] );
        if (transportFactoryPtr->streamOriented())
        {
            std::pair<RCF::ServerTransportPtr, RCF::ClientTransportAutoPtrPtr> transports = transportFactoryPtr->createTransports();
            RCF::ServerTransportPtr serverTransportPtr( transports.first );
            RCF::ClientTransportAutoPtr clientTransportAutoPtr( *transports.second );

            filterChains.clear();

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
            filterChains.push_back(filterChain);

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(7) ));
            filterChains.push_back(filterChain);

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
            filterChains.push_back(filterChain);

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(7) ));
            filterChains.push_back(filterChain);

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
            filterChains.push_back(filterChain);

            filterChain.clear();
            filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
            filterChains.push_back(filterChain);

            testTransportFilters(filterFactories, filterChains, serverTransportPtr, clientTransportAutoPtr);

        }
    }
    
    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(7) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(7) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterChains.clear();
    filterChain.clear();
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::XorFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::IdentityFilter() ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(4096) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(4096) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterFactories.clear();
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::IdentityFilterFactory() ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatelessCompressionFilterFactory(4096) ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::ZlibStatefulCompressionFilterFactory(4096) ) );
    filterFactories.push_back( RCF::FilterFactoryPtr( new RCF::OpenSslEncryptionFilterFactory(serverCertificateFile, serverCertificateFilePassword) ));

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(7) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter(4096) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter(4096) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    filterChains.clear();

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);

#if defined(BOOST_WINDOWS) && !defined(__BORLANDC__)
    // TODO: why does this test fail on gcc (Solaris, Linux, prob'ly Cygwin, but not mingw), and on borland ?
    std::cout << "testing ->ssl->stateful compression-> transport filter" << std::endl;
    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatefulCompressionFilter() ));
    filterChains.push_back(filterChain);
#endif

    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChains.push_back(filterChain);
    
    filterChain.clear();
    filterChain.push_back(RCF::FilterPtr( new RCF::OpenSslEncryptionFilter(RCF::SslClient, clientCertificateFile, clientCertificateFilePassword) ));
    filterChain.push_back(RCF::FilterPtr( new RCF::ZlibStatelessCompressionFilter() ));
    filterChains.push_back(filterChain);

    testTransportFilters(filterFactories, filterChains);

    return boost::exit_success;

}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Jarl Lindrud
Australia Australia
Software developer, from Sweden and now living in Canberra, Australia, working on distributed C++ applications. When he is not programming, Jarl enjoys skiing and playing table tennis. He derives immense satisfaction from referring to himself in third person.

Comments and Discussions

Permalink
Advertise
Privacy
Cookies
Terms of Use
Layout: fixed | fluid

Posted 23 Dec 2005

Article Copyright 2005 by Jarl Lindrud
Everything else Copyright © CodeProject, 1999-2024

Web04 2.8:2024-04-02:1