Free remote software for linux

rmRemote project lets you remote control xmms with a REALmagic Remote. In the future it may be used to control everything in your house if you add the functionality.

Kxremote is an application to integrate protocols of remote connection made with perlqt.
Supports:
- xdmcp
- vnc
- rdp

Remote Nmap (Rnmap) package contains both client and server programs. Actual idea for this sofware is that various clients can connect to one centralized Rnmap server and do their portscannings. Server does user authentication and uses excellent Nmap scanner to do actual scanning. Rnmap is written entirely in Python and is released under the terms of the GNU General Public License.

Version 0.10 of server is tested mainly on Linux, NetBSD and OpenBSD. Generally it should run on any *nix platform as long Nmap and Python are available for them. Console client is known to work with same platforms as server. Gui client will run on any python (with threads) supported platform.

File::Remote is a Perl module to read/write/edit remote files transparently.

SYNOPSIS

#
# Two ways to use File::Remote
#
# First, the function-based style. Here, we can use the
# special :replace tag to overload Perl builtins!
#
use File::Remote qw(:replace); # special :replace tag

# read from a remote file
open(REMOTE, "host:/remote/file") or die $!;
print while (< REMOTE >);
close(REMOTE);

# writing a local file still works!
open(LOCAL, ">>/local/file");
print LOCAL "This is a new line.n";
close(LOCAL);

mkdir("host:/remote/dir", 0755);
unlink("host:/remote/file");
unlink("/local/file"); # still works too!
symlink("host:/remote/src", "host:/remote/dest");

chown("root", "other", "host:/remote/dir/file");
chmod(0600, "host:/remote/dir/file");

#
# Next, the object-oriented style, if you dont want to
# mess with the builtins.
#
use File::Remote;
my $remote = new File::Remote;

# Standard filehandles
$remote->open(FILE, ">>host:/remote/file") or die $!;
print FILE "Heres a line thats added.n";
$remote->close(FILE);

# Create a new file and change its permissions
$remote->mkdir("host:/remote/dir");
$remote->touch("host:/remote/dir/file");

# Move files around
$remote->copy("/local/file", "host:/remote/file") or warn $!;
$remote->move("host:/remote/file", "/local/file");

# Read and write whole files
my @file = $remote->readfile("host:/remote/file");
$remote->writefile("/local/file", @file);

# Backup a file with a suffix
$remote->backup("host:/remote/oldfile", "save");

# Use secure connection methods
my $secure = new File::Remote (rsh => "/usr/local/bin/ssh",
rcp => "/usr/local/bin/scp");
$secure->unlink("/local/file");
$secure->rmdir("host:/remote/dir");

This module takes care of dealing with files regardless of whether theyre local or remote. It allows you to create and edit files without having to worry about their physical location on the network. If a file passed into a function is of the form host:/path/to/file, then File::Remote uses rsh/rcp (or ssh/scp, depending on how you configure it) to edit the file remotely. Otherwise, it assumes the file is local and passes calls directly through to Perls core functions.

The nice thing about this module is that you can use it for all your file calls, since it handles both remote and local files transparently. This means you dont have to put a whole bunch of checks for remote files in your code. Plus, if you use the function-oriented interface along with the :replace tag, you can actually redefine the Perl builtin file functions. This means that your existing Perl scripts can automatically handle remote files with no re-engineering(!).

Remote File Index is an add-on for Plone which keeps track of a document only by its url.
Did you ever find a huge pdf file that youd like to keep track of but wouldnt like to copy it entirely on your server ?
Now RemoteFileIndex indexes the content in the portal Catalog and only keeps the url of that document.
Works with:
- Plone 2.5.2
- Plone 2.5.1
- Plone 2.5
Enhancements:
- better integration with ATContentType

RPyC stands for Remote Python Call, a pun over remote procedure call. It is completely transparent and symmetrical. It is inspired by the work of eyal lotem (pybuild.sf.net) on pyinvoke, and was made for two purposes:
Learning the lowlevel of the python language attempting to improve pyinvoke by making the entire protocol symmetrical. This means the client can make requests to the server, and the server can reply with requests of its own (the client is also a server on its own). This typically means using callback functions.
The RPyC package comes with a full demo, showing (or showing-off) many of its features. As i said, its completely transparent and symmetrical, so you can write code just as you would write in the case of normal python programs.
demo 1 -- a simple client demo
# import the client
from Rpyc.Client import RpycSocketClient
# `hostname` is the name of the host running an Rpyc server
# the port parameter is optional
c = RpycSocketClient("hostname")
# now we are connected and can start messing around with stuff on the server
for filename in c.modules.os.listdir("/tmp"):
print "found file", filename
Enhancements:
- This release adds DeliveringNamespace, LoginError (instead of tlslites internal errors), __version__, deliver (the counterpart of obtain, which can now deliver and obtain functions as well), and isproxy (to test whether an object is a proxy).
- It improves memory consumption with __slots__ and the isinstance/issubclass mechanism.