Free rpc software for linux

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.

Wily::RPC is a Perl extension for the Wily RPC interface.

SYNOPSIS

use Wily::RPC;
use Wily::Message;

# opens a file in wily and exits when the window is destroyed

my $wily = Wily::RPC->new();
my $win = $wily->win(/tmp/file_to_edit, 1);
$wily->attach($win, Wily::Message::WEdestroy);
while (my $event = $wily->event()) {
if ($event->{type} == Wily::Message::WEdestroy and
$event->{window_id} == $win) {
last;
}
}

Provides an interface to the Wily, using the lower level Wily::Message and Wily::Connect packages (which can also be used without this wrapper).

Most of the methods of the Wily::RPC may block for a short time, they write a message to wily over a unix domain socket and then wait for wily to write a response message. Wily responds quickly, but if such things matter you will have to use the lower level packages instead.

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.

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

RPC::pClient is a Perl extension for writing pRPC clients.

SYNOPSIS

use RPC::pClient;

$sock = IO::Socket::INET->new(PeerAddr => joes.host.de,
PeerPort => 2570,
Proto => tcp);

$connection = new RPC::pClient(sock => $sock,
application => My App,
version => 1.0,
user => joe,
password => hello!);

pRPC (Perl RPC) is a package that simplifies the writing of Perl based client/server applications. RPC::pServer is the package used on the server side, and you guess what RPC::pClient is for. See RPC::pClient(3) for this part.
pRPC works by defining a set of of functions that may be executed by the client. For example, the server might offer a function "multiply" to the client. Now a function call

@result = $con->Call(multiply, $a, $b);

on the client will be mapped to a corresponding call

multiply($con, $data, $a, $b);

on the server. (See the funcTable description below for $data.) The function calls result will be returned to the client and stored in the array @result. Simple, eh?

Client methods

new

The client constructor. Returns a client object or an error string, thus you typically use it like this:

$client = RPC::pClient->new ( ... );
if (!ref($client)) {
print STDERR "Error while creating client object: $clientn";
} else {
# Do real stuff
...
}

Call

calls a function on the server; the arguments are a function name, followed by function arguments. It returns the function results, if successfull. After executing Call() you should always check the error attribute: An empty string indicates success. Thus the equivalent to

$c = Add($a, $b)
# Use $c
...

is

$c = $client->Call("Add", $a, $b);
if ($client->error) {
# Do something in case of error
...
} else {
# Use $c
...
}

CallInt

Similar to and internally used by Call. Receives the same arguments, but the result is prepended by a status value: If this status value is TRUE, then all went fine and the following result array is valid. Otherwise an error occurred and the error message follows immediately after the status code. Example:

my($status, @result) = $client->CallInt("Add", $a, $b);
if (!$status) {
# Do something in case of error
my $errmsg = shift @result || "Unknown error";
...
} else {
...
}

Encrypt

This method can be used to get or set the cipher attribute, thus the encryption mode. If the method is passed an argument, the argument will be used as the new encryption mode. (undef for no encryption.) In either case the current encryption mode will be returned. Example:

# Get the current encryption mode
$mode = $server->Encrypt();

# Currently disable encryption
$server->Encrypt(undef);

# Switch back to the old mode
$server->Encrypt($mode);

RPC::XML::Procedure is an object encapsulation of server-side RPC procedures.

SYNOPSIS

require RPC::XML::Procedure;

...
$method_1 = RPC::XML::Procedure->new({ name => system.identity,
code => sub { ... },
signature => [ string ] });
$method_2 = RPC::XML::Procedure->new(/path/to/status.xpl);

IMPORTANT NOTE

This package is comprised of the code that was formerly RPC::XML::Method. The package was renamed when the decision was made to support procedures and methods as functionally different entities. It is not necessary to include both this module and RPC::XML::Method -- this module provides the latter as an empty subclass. In time, RPC::XML::Method will be removed from the distribution entirely.

The RPC::XML::Procedure package is designed primarily for behind-the-scenes use by the RPC::XML::Server class and any subclasses of it. It is documented here in case a project chooses to sub-class it for their purposes (which would require setting the method_class attribute when creating server objects, see RPC::XML::Server).

This package grew out of the increasing need to abstract the operations that related to the methods a given server instance was providing. Previously, methods were passed around simply as hash references. It was a small step then to move them into a package and allow for operations directly on the objects themselves. In the spirit of the original hashes, all the key data is kept in clear, intuitive hash keys (rather than obfuscated as the other classes do). Thus it is important to be clear on the interface here before sub-classing this package.

mod_xmlrpc_auth is an Apache module for XML-RPC Authentication.

mod_xmlrpc_auth is an Apache module which performs authentication and authorization using an XML-RPC call.

Installation:

To build mod_xmlrpc_auth, you should be able to simply run these commands:

./configure
make
make install

Encap Package Support

To build this software as an Encap package, you can pass the --enable-encap option to configure. This will be automatically enabled if the epkg or mkencap programs are detected on the system, but can be overridden by the --disable-encap option.

When building an Encap package, the configure script will automatically adjust the installation prefix to use an appropriate Encap package directory. It does this using a heuristic algorithm which examines the values of the ${ENCAP_SOURCE} and ${ENCAP_TARGET} environment variables and the argument to configures --prefix option.

If mkencap was detected on the system, it will be automatically run during "make install". By default, epkg will also be run, but this can be inhibited with the --disable-epkg-install configure option.

For information on the Encap package management system, see the WSG Encap Archive:

http://www.encap.org/

Configuration

For configuration information, please see the mod_xmlrpc_auth.conf file.