Remote Call Framework 3.0

What is Remote Call Framework?

Remote Call Framework (RCF) is a cross-platform interprocess communication framework for C++.

Unlike other communication frameworks, RCF doesn't use a separate IDL (Interface Definition Language). RCF interfaces are defined directly in C++, and serialization for user-defined data types likewise is implemented in C++. Instead of a separate IDL compiler tool, RCF uses the C++ compiler to generate client and server stubs.

RCF provides a broad range of interprocess communication features:

  • One-way and two-way messaging.
  • Batched one-way messaging.
  • Publish/subscribe style messaging.
  • Multicast and broadcast messaging over UDP.
  • Asynchronous remote calls.
  • Bidirectional connections, for server-to-client messaging.
  • Multiple transport implementations (TCP, UDP, Windows named pipes and UNIX local domain sockets).
  • Tunneling over HTTP and HTTPS.
  • Transport level compression (zlib) and encryption (Kerberos, NTLM, Schannel, and OpenSSL).
  • Support for IPv6.
  • Built in serialization framework.
  • Built in file transfer capabilities.
  • Robust versioning support.
  • Support for Protocol Buffers.
  • Portable across a wide range of compilers, platforms and operating systems.
  • Scalable acoss a wide range of applications, from simple parent-child IPC, right up to large scale distributed systems.
  • Efficient, with zero-copy and zero-heap allocations on critical paths, on both server and client.
  • No dependencies. zlib, OpenSSL and Protocol Buffers are optional.

To start learning about programming with RCF, go straight to the Tutorial.

Why should I use RCF?

You should consider using RCF if you are writing C++ components that need some form of interprocess communication. For communication between native C++ components, there is little benefit in using XML and XML schemas to describe messages, as native serialization formats are more descriptive and efficient. There are also few benefits to separately compiled IDL files. RCF's approach of describing interfaces in C++ code makes for a simpler build and more flexible development.

RCF is written in 100% standard C++, and is both portable and efficient. Basing your communication layer on RCF gives you portability across a wide range of compilers, operating systems, and platforms, and the ability to pick and choose from a wide range of transport mechanisms, threading models, and messaging paradigms.

RCF has been designed as a real world tool for real world applications. RCF has been in large-scale commercial use since 2007, and today powers networked applications around the globe. Some of the scenarios RCF has been used in include:

  • Client-server systems, across LAN's or WAN's. From industrial process control, to replacing DCOM in distributed desktop applications, to cross platform communication.
  • Back end server components, typically in a homogeneous LAN environment.
  • Communication between Windows services and their monitoring applications.
  • Parent-child process communication.
  • Generic local IPC, replacing COM.

What's new in version 3.0?

RCF 3.0 has been modernized to take advantage of the considerable number of language and library features that have made their way into the C++ standard, in the C++11, C++14, and C++17 updates.

RCF no longer has a dependency on the Boost library. All usages of Boost classes and functions, such as boost::shared_ptr<> and boost::bind(), have been replaced with standard C++ counterparts.

A consequence of this is that RCF will no longer build on older C++ compilers. A list of supported compilers is included in the section on Building RCF. Users who are unable to upgrade to a supported compiler will need to continue using RCF 2.2 .

For version 3.0, we have also overhauled all the documentation, and added reference documentation for public RCF classes.

For a detailed list of changes, see the Release Notes.