Free rpc 2009 software for linux

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.

Jabber::RPC is a Jabber-RPC Implementation.

SYNOPSIS

See documentation for Jabber::RPC::Server and Jabber::RPC::Client.

Jabber::RPC is a library that implements Jabber-RPC for Perl. The library consists of two modules, Jabber::RPC::Server and Jabber::RPC::Client. Please refer to the documentation for these two modules for more information.

schily 2009-07-06 is developed to be a set of tools written or managed by Schilling. It includes programs like: cdrecord, cdda2wav, readcd, mkisofs, smake, btcflash, calc, calltree, change, compare, count, devdump, hdump, isodebug, isodump, isoinfo, isovfy, label, mt, p, sccs, scgcheck, scpio, sdd, sfind, sformat, smake, star, star_sym, suntar, gnutar, tartest, termcap, and ved.

Enhancements:

• Smake is allowed to use /bin/bosh instead of bash on Linux or ksh on HP-UX.
• Some small problems were fixed in smake.
• Cdrtools was upgraded to 2.01.01a53.
• Some extensions were made as a first step to allow compilation on the ATARI ST with MINT.

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);

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.

ypserv package contains the daemons ypserv, rpc.ypxfrd, rpc.yppasswdd and the programs yppush, ypxfr, makedbm, revnetgroup and ypinit.
The Network Information Service (NIS) provides a simple network lookup service consisting of databases and processes. It was formerly known as Sun Yellow Pages (YP).
The functionality of the two remains the same, only the name has changed. Its purpose is to provide information, that has to be known throughout the network, to all machines on the network.
Enhancements:
- This release fixes a crash in the SLP handler if the local hostname is not resolvable.