Free rpc stub software for linux

CamRPC is a simple client/server solution to update/manage several webcams using a PHP enabled Web server and any client with XML-RPC capabilities.
Enhancements:
Server
- A web server (Apache tested, http://httpd.apache.org/)
- PHP 4 >= 4.1.0 with XML module
- php XML-RPC (http://xmlrpc.usefulinc.com/, included 1.1.1 in the package)
- A directory with write enabled for the httpd daemon
Client
- Your image grabber of choice
- Python client: python 2 >= 2.2
- Perl client: Frontier::RPC, MIME::Base64 and MIME::Types
Enhancements:
- updated included xml-rpc lib due SA15852: http://secunia.com/advisories/15852/
- Now camrpc is distributed with xml-rpc 1.1.1.

RPC::XML is a set of classes for core data, message and XML handling.

SYNOPSIS

use RPC::XML;

$req = RPC::XML::request->new(fetch_prime_factors,
RPC::XML::int->new(985120528));
...
$resp = RPC::XML::Parser->new()->parse(STREAM);
if (ref($resp))
{
return $resp->value->value;
}
else
{
die $resp;
}

The RPC::XML package is an implementation of the XML-RPC standard.

The package provides a set of classes for creating values to pass to the constructors for requests and responses. These are lightweight objects, most of which are implemented as tied scalars so as to associate specific type information with the value. Classes are also provided for requests, responses, faults (errors) and a parser based on the XML::Parser package from CPAN.

This module does not actually provide any transport implementation or server basis. For these, see RPC::XML::Client and RPC::XML::Server, respectively.

libfirerpc is a library that provides an easy interface for C programs to make remote function queries via the XML RPC protocol.

It supports SSL/TLS, HTTP authentication, HTTP 1.1 persistent connections and pipelining. It also supports POST data compression via bzip2 and response compression via bzip2, gzip, deflate and compress.

Event::RPC is a event based transparent Client/Server RPC framework.

SYNOPSIS

#-- Server Code
use Event::RPC::Server;
use My::TestModule;
my $server = Event::RPC::Server->new (
port => 5555,
classes => { "My::TestModule" => { ... } },
);
$server->start;

----------------------------------------------------------

#-- Client Code
use Event::RPC::Client;
my $client = Event::RPC::Client->new (
server => "localhost",
port => 5555,
);
$client->connect;

#-- Call methods of My::TestModule on the server
my $obj = My::TestModule->new ( foo => "bar" );
my $foo = $obj->get_foo;

ABSTRACT

Event::RPC supports you in developing Event based networking client/server applications with transparent object/method access from the client to the server. Network communication is optionally encrypted using IO::Socket::SSL. Several event loop managers are supported due to an extensible API. Currently Event and Glib are implemented.

XML-RPC is a C library for remote procerure call. It converts the procedure call into XML document, sends it to a remote server using HTTP, and gets back the response as XML.
This library provides a new and modular implementation of XML-RPC for C and C++.
XML-RPC For C and C++ is designed for Unix and is most tested on unix. As far as we know, it works on any reasonably standard unix.
There is also lots of code to make it work on Windows, but the fact is that it probably wont work out-of-the-box on your Windows system. Here is the Windows story.
To build a useful Xmlrpc-c client library, youll need to have at least one HTTP library. Xmlrpc-c knows how to use W3C Libwww (Version 5.3.2 or newer), Curl, and Wininet. The configurator gives you the option of building libraries that use any or all of these, and
defaults to every one you appear to have installed. If you dont appear to have any installed, the configurator causes the build to omit client facilities altogether.
Information about W3C Libwww, including how to get it are at .
For Curl, see .
Wininet comes with Windows, and isnt available for any other platform.
You also need an XML parser/builder library. An old version of Expat is included in the package and used by default, so theres no actual prerequisite here. But if you separately obtain Libxml2, you can configure the build to use that instead. Theres no really pressing reason to do that, though.
In the simplest case, the installation its just a conventional:
./configure
make
make install
Enhancements:
- Curl client XML transport: Use Curl multi-manager for synchronous RPCs to make them properly interruptible by signals. (Requires March 2007 update to libcurl to avoid delay of up to a second).
- Abyss: Fix per-HTTP-request memory leak.
- Abyss: Fix infinite loop reading headers when buffer contains data right up to the newline at the end of a header.
- Build: works on a system with no pselect(). (emulates with select()).
- Fix compilation failure in thread_fork.c when you configure with --disable-abyss-threads.

PyOPC is a Python library implementing the OPC XML Data Access Protocol Version 1.01 (OPC XML-DA 1.01).

PyOPC supports the easy creation of XMLDA-compliant clients and servers without having to deal with the SOAP protocol and server issues.

The Open Linking and Embedding for Process Control (OPC) consortium released several open standards, which address interfaces for vertical integration in industrial automation.

Historically, OPC used the Distributed Component Object Model (DCOM) for the underlying communication technology. DCOM has the disadvantage of being platform specific: it is only available for Microsoft Windows based systems. Other platforms, such as Linux, can therefore not retrieve fieldbus data from DCOM based servers.

Another disadvantage of DCOM is that it can not easily bypass firewalls, hence access will often be limited to certain segments of a corporate network.
In the last years, a new technology, called SOAP Web services, emerged. [LIV02] defines a Web Service as: ``a method or function that is available for other applications to access over the Internet.. Web services enable Remote Procedure Calls (RPC) and have the following key features:

High level of interoperability:

Web services technologies are all based on strictly defined open standards1.

High networking abilities:

As an underlying communication protocol, Web services utilize Internet protocols such as the Hyper Text Transfer Protocol (HTTP) or the Simple Mail Transfer Protocol (SMTP). These protocols have high networking abilities and may moreover penetrate firewalls.

Protocol legible by humans:

The Simple Object Access Protocol (SOAP)2 is based on the Extended Markup Language (XML), which is legible to humans. This way, testing and debugging of Web services is far easier than with binary protocols.

Documentation:

Another underlying technology of SOAP is the ``Web Service Definition Language (WSDL) which may be used to define the service, especially by constraining the format of the SOAP protocol. WSDL utilizes the XML Schema language for defining these SOAP messages3. These WSDL documents can be utilized by frameworks to generate stubs that provide a base for accessing a Web service.

Validation:

WSDL in combination with a validating XML parser enable the validation of SOAP messages. This way, custom code will never receive syntactically or semantically erroneous data, which should improve the stability of the service.

SOAP Web services are seen as a successor to several alternative technologies such as DCOM and are already broadly accepted by the industry. More information about the SOAP protocol can be found in [SEE02] and [LIV02].

The OPC consortium reacted on this technological evolution by adopting SOAP Web services for their standards. One recent addition of OPC is the "XML Data Access Version 1.0" (XML-DA 1.0) standard. This standard deals with access of underlying fieldbus technologies and covers the following aspects:

Information model:

The specification provides a simple information model, based on ``OPC Items which represent a piece of information, similar to fieldbus data points. These items can be arranged hierarchically.

Data types:

OPC XML-DA adopts several XML-Schema based data types, such as integer, float, date/time specific types. Moreover it defines arrays which are based on these basic types.

Operations:

The standard specifies 8 operations such as reading/writing and browsing which can be used to access the underlying fieldbus.

Subscription:

The specification further introduces a mechanism to retrieve only changed items, called ``Subscription. Clients may thus subscribe to items and use a dedicated polling operation to retrieve changed data.

Major Features:

1. Simple, pythonic API.
2. Support for Django authentication.
3. Mostly supports JSON-RPC 1.1 spec.
4. Proxy to test your JSON Service.

Requirements:

• Python

xmlrpcserver provides a simple to use and complete XML-RPC server.
xmlrpcserver is a simple to use but fairly complete XML-RPC server module for Python, implemented on top of the standard module xmlrpclib.
This module may, for example, be used in CGIs, inside application servers or within an application, or even standalone as an HTTP server waiting for XML-RPC requests.
xmlrpcserver is completely written in Python and has no dependencies other than standard modules.
Enhancements:
- This version added system.listMethods() and system.methodHelp() introspection methods
- introduced a return value to execute()
- featured a small security improvement by not allowing methods starting with _ to be available in registered classes.