Free rpc 2008 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.

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.

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.

SYNOPSIS

use DCE::RPC; use Authen::Perl::NTLM qw(lm_hash nt_hash);
use constant DCOM_IREMOTEACTIVATION => pack("H32", "B84A9F4D1C7DCF11861E0020AF6E7C57");
use constant DCOM_IF_VERSION => 0x00;
use constant DCOM_XFER_SYNTAX => pack("H32", "045D888AEB1CC9119FE808002B104860");
use constant DCOM_XFER_SYNTAX_VERSION => 0x02;

$passwd = "passwd";
$lm_hpw = lm_hash($passwd);
$nt_hpw = nt_hash($passwd);
$ntlm = new_client Authen::Perl::NTLM($lm_hpw, nt_hpw);
$rpc_host = "www.rpc.com";
$rpc_port = 135;
$rpc = new DCE::RPC($rpc_host, $rpc_port, $ntlm);
$bind_msg = $rpc->rpc_bind_ack_resp(1, DCOM_IREMOTEACTIVATION, DCOM_IF_VERSION,
({interface => DCOM_XFER_SYNTAX, version => DCOM_XFER_SYNTAX_VERSION}));
$request_msg = $rpc->rpc_co_request("Hi, there! This is Stub!", 1, 0x0e, DCOM_IREMOTEACTIVATION, "Authentication Credentials");
$response_msg = $rpc->rpc_request_response($request_msg);
$alt_ctx_msg = $rpc->rpc_alt_ctx(1, DCOM_IREMOTEACTIVATION . DCOM_IF_VERSION
,
({interface => DCOM_XFER_SYNTAX, version => DCOM_XFER_SYNTAX_VERSION}));

The DCE RPC protocol is an application level protocol from OpenGroup that allows applications to do Remote Procedure Calls. It is the underlying wire protocol for DCOM (Distributed Common Object Model) by Microsoft.
This module was motivated by an reverse-engineering effort on a DCOM client. Therefore, functions that are implemented gear more toward client side implementation. Also, the initial version only supports Connection Oriented version of DCE RPC. It also assumes NTLMSSP as the underlying authentication protocol. This can change based on the input of the users of this modules.

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

perlrpcgen is a Perl module that can generate Perl interfaces from ONC RPC interface definitions.

SYNOPSIS

perlrpcgen [--makefile] [--all] [--client] [--server] [--data] [--constants] [--module module] [--typemap typemap] [--fork] [--perl perl] [--cc cc] [--rpclibs rpclibs] rpcfile.x

perlrpcgen builds a set of Perl extensions and a server shell from an ONC RPC interface definition. For an interface Foo, perlrpcgen creates modules Foo::Client, Foo::Data, and Foo::Constants. Foo::Client contains routines for creating a Foo client and making remote procedure calls via the client. Foo::Data contains routines for creating and manipulating the data structures defined in the Foo interface. Foo::Constants contains functions to retrieve the constants defined in the Foo interface.

OPTIONS

The option parsing uses Getopt::Long, so you can abbreviate option names.

--makefile

Generates a top-level Makefile which will build all the pieces. Include all the other options you want so theyll be propagated to the Makefile.

--all

Implies --client, --server, --data, and --constants. This is usually what you want.

--client

Generates Foo::Client module.

--server

Generates Foo/server/foo_svc.

--data

Generates Foo::Data module.

--constants

Generates Foo::Constants module.

--module module

Sets the basename of the modules. If not given, the name defaults to the basename of the interface file.

--typemap typemap

Uses the given typemap during stub generation. This option can be specified many times. perlrpcgen generates a typemap for the data structures in the interface, but you also need the main Perl typemap.

--fork

Munges the server shell code so that it forks for each request. You probably dont want to do this (its better to prefork several processes when you start the server and let them fight over accept() calls).

--perl perl

Sets the Perl binary against which extensions should be built. Defaults to the Perl you used to install perlrpcgen.

--cc cc

Sets the C compiler to use. Defaults to the compiler used when building Perl.

--rpclibs rpclibs

Sets the RPC libraries to link against. Defaults to -lnsl -lrpcsvc.

Apache2::JSONRPC is a mod_perl handler for JSONRPC.

SYNOPSIS

< Location /json-rpc >
SetHandler perl-script
PerlOptions +GlobalRequest
PerlResponseHandler Apache2::JSONRPC->handler
JSONRPC_Class CGI::JSONRPC::Dispatcher
< /Location >

Apache2::JSONRPC is a subclass of CGI::JSONRPC that provides some extra bells and whistles in a mod_perl2 environment.
Currently, the main feature is the "JSONRPC_Class" apache2 config directive, which allows you to define what class to use for invoking JSONRPC methods. The default is the same as CGI::JSONRPC uses, CGI::JSONRPC::Dispatcher.

JSON-RPC-Java provides an RPC implementation that allows JavaScript DHTML Web applications to call remote methods in a Java Application Server (AJAX functionality) without the need for page reloading.
JSON-RPC-Java library is an enabler for the next generation of fast and highly dynamic enterprise Java Web applications. Minimal changes (if any) are necessary to existing server-side Java code to allow calling from JavaScript (such as the marshalling and unmarshalling of special types), as JSON-RPC-Java dynamically maps JavaScript objects to and from Java objects using Java reflection.
Enhancements:
- The license has changed from the LGPL to the Apache License, Version 2.0.
- New object registration, lookup, and unregister APIs have been added to JSONRPCBridge.