Free remote hosts 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.

vdr_remote is a graphical remote control for the video disk recorder vdr. vdr_remote connects over a TCP/IP network and gives you a complete remote control.

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.

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 MySQL Query is a PHP class that can easily execute queries on a remote MySQL server using only HTTP.

It works by accessing a PHP script on the remote web server that executes queries based on passed in URL parameters.

The client passes a secret key to the remote script to prevent unauthorized access.

The remote script passes back the results to the requesting client using XML to marshal the data.

The class parses the results XML data returned by the server script and returns an array.

It, also, retrieves (into class variables) the number of records returned by the query and the time the query took to execute.

The server script may be used to execute MySQL queries that can be retrieved by programs written in other languages besides PHP.

Remote Monitoring Agent (RMA in short) is an auxiliary application for HostMonitor. Enterprise license for Advanced Host Monitor already includes license for 10 installations of the agent. Holders of a Lite, Standard or Professional licenses may buy an additional license for Remote Monitoring Agent separately.
HostMonitor 4.0+ can monitor remote networks using Remote Monitoring Agents (RMA). RMA is small application that accepts requests from HostMonitor, performs test and provides information about test result back to HostMonitor.
Why you may need RMA? Here are just several reasons:
RMA increases security of the network. When you have to run the tests such as CPU Usage test or Performance Counters tests on a remote Windows system, HostMonitor must be able to log in to that system with administrators privileges. Instead you may now use an agent installed on that remote system. In this case HostMonitor will not have to log on to that system at all. HostMonitor needs just one TCP port to communicate with the RMA agent (by default it uses #1055 port, however you may set an agent to use any other port).
Remote Monitoring Agent is also a very useful tool when you have to monitor two (or many) separated networks (connected through Internet). In this case installing just one instance of RMA behind the firewall in network "A" will allow to monitor entire network "A" using the HostMonitor located in the network "B" with just one open TCP port.
RMA decreases the network traffic. E.g. frequent use of "File Integrity" or "Compare Files" tests in an array of remote systems may apply significant load on the network. The more and the bigger files you test the more traffic increase you get. RMA runs locally and sends only the test results to the HostMonitor thus decreasing the amount of network traffic.
Remote Monitoring Agent simplifies network administration. You no longer need to share local drives/folders to perform tests such as File Integrity, Folder/File Size, File Availability, Count Files, etc
RMA for Linux / BSD / Solaris allows you to perform tests that HostMonitor cannot perform. For example HostMonitor cannot monitor processes that are running on Linux systems. RMA can do that.
Main features:
- All traffic between Remote Monitoring Agents and HostMonitor is encrypted.
- It is possible to customize the list of enabled tests for each of the agents (e.g. living only Count Files and UNC tests only).
- You can restrict incoming TCP connections with the list of acceptable addresses.
- With RMA Manager you may configure, restart and even upgrade agent(s) remotely.

BlockHosts is a script to record how many times "sshd" or "proftpd" is being attacked, and when a particular IP address exceeds a configured number of failed login attempts, that IP address is added to /etc/hosts.allow (or optionally to any other file).

Requires python version 2.3 at a minimum, and runs on Unix-like machines only.

The BlockHosts script is most suitable for home Linux users, who need to keep ssh/ftp ports open.

Blocks IP addresses based on SSH or FTP incoming login failures, by looking at SSHD and ProFTPD logs, and updating hosts.allow as needed.
If you are a Linux user running SSH server, it is likely that you have been probed by script kiddies, and your daily LogWatch emails will show 100-150 login attempts in a short interval, before they go away.

There is no option in OpenSSH to make it difficult to slow down repeated login attempts coming from one IP address -- logins occur at a pretty fast clip -- one attempt every few seconds.

For a home or small business linux user at least, it does not make sense to keep the door open for logins for so long. Use this script, and see the daily LogWatch email notifications now showing only 7-9 login attempts, and remote hosts start getting "Refused incoming connection" messages.

Then, reading the daily LogWatch emails is not terrifying at all, in fact, it may be fun to see these script kiddies get blocked!

- Be sure to acquaint yourself with material available on the web, related to security, and denial-of-service. In particular, see the discussion in the OpenSSH mailing list related to SSHD blocking and FAIL_DELAY:
- Make your sshd/proftpd configurations as tight as possible. For example, for sshd - turn off root logins (PermitRootLogin), use the AllowUsers keyword to only allow one or a select usernames to be accepted. As far as possible, try to avoid common usernames, make even the user names hard to guess. For ProFTPD, use /etc/ftpusers, which contains names of users that will not be allowed to use FTP, root should be in there.
- Last, but not least - always use strong passwords! That is the only real protection.

blockhosts.py scans system logs, and looks for failed login attempts. It keeps a record of the number of times a particular IP address had a failed login. When the count exceeds a configured value, that IP address is added to /etc/hosts.allow with a deny flag, so the next time that IP address attempts to connect to that box, they will get a refused connection message.

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