Free root software for linux

Root-tail is a program that allows printing of text directly to the X11 root window wherever you choose, much like running rxvt with a pixmap background but without the hassle and with more features.
Install:
xmkmf -a
make
make install
make install.man
Enhancements:
- replaced default font by "*" to "ensure" some font is found.
- accept hexadecimal window ids, as does everybody else(?).
- made it compile with ansi-89-based compilers again.
- add hack to support nautilus (not very stable, nautilus should either use extended window manager hints or __SWM_VROOT, as everybody else does).
- do not initialize the window twice (fixes problems with multiple visuals).
- new option: -minspace.
- fixed seg fault if geometry is too short to fit a single line
- fix bug which became apparent if -no-filename or null

Root Park project will build a network that will stand the test of time.
RootPark is a Civilization-like game based on the history of computers and networks. You can play it with as many other players as you want since it has full networking capabilities.
The game begins in 1960, when computers started to become very powerful. RootPark provides you the opportunity to experience these historical years, and a large range of possibilities.
This source and binaries of the game will be available soon. It will be playable on Linux, BSD (and surely other UNIX like OSF1).
Main features:
- strategy game, turn based.
- topic : history of computers and networks.
- multiplayer (using local or internet networks)
- fully playable on Linux and NetBSD(and surely some others Unix).
- programmed using C language.
- opensource game, everybody can improve it
- uses GTK X-Windows library.
- uses 16 millions colors (24 bits)
- you can change the themes of the graphical interface
- you can import your own graphisms
- communication between players during the game (like irc)
- generator of random map whatever the number of players.
- handles the visibility of units and hosts (fog of war)
- interactive help online
- complete encyclopedy on the history of computers

Root-Portal is a GNOME program that monitors files, processes etc and displays changes either directly to the desktop or in a transparent border-less window. This is useful for monitoring system logs and for providing feedback on system activities.

Root Portal is a way to do stuff on your desktop in the background. We find it useful as a monitor of system log files such as /var/log/messages and /var/log/xferlog and /var/log/httpd/access_log etc etc.

You can have as many spots, or portals of text on the screen as you want in varying size and varying font and colour and practically any other property you care to think of. They can have the added advantage of being transcient so that you can still see your background picture underneith the text.

As well as this, using the roottext module, you can run programs such as xsnow and the snow flakes will not disappear because of the text, they will pass through it. Using the module such as gnometext allows you to shade the background and put alternate images as backgrounds for your portals.

You may also shade these custom backgrounds, the only disadvantage to this system is that programs such as xsnow cannot mix their graphics with this and disappear behind them. The only other difference between the two is that the root text can handle non-fixed sized fonts with a breeze.

Because the gnome module is using zvt, it currently does no like non-fixed sized fonts too much at all. We are hoping the author of zvt will change this in later releases of his library. As well as the file tailing facility to monitor log files, there is also a loading monitor, to show you when a new process has been created and when a process has been destroyed.
Basically this is a pretty anti-paranoia program for people who sit at their desktops and wonder who is doing what to them from the outside, what is running what on their system, and why their harddisk is suddenly ticking over for no reason *aha, crond is doing something weird*

UserCHRoot project can switch root, change directory, drop privileges and exec.

When dealing with chroot environments, its sometimes useful to have a tool with which the chroot will be done, but the target executable will not be run using root privileges.

It is also sometimes useful to switch the current working directory for the target executable just before it starts. userchroot is a small program intended to be run as suid (u+s root) in these cases. It tries to be as careful as possible in order not to run the target executable as root user.

It does not support arbitrary user specification, but instead will drop back to normal user privileges of the calling user (undoing what suid-bit has done basically). If dropping root privilege fails (or actually resetting the effective credentials to the normal ones), the target executable will not be executed.

userchroot has been tested on Linux, implemented using C and licensed under GNU General Public License (v2). The tool is provided without a warranty of any kind, in the understanding that software bugs do exist and bad things can happen.

Building and installing

Using suid bits with programs that you randomly download off the Internet is not a good security practice. Because of this reason, building and installing the software is not automated at all (no autotools, no Makefile).

In order to build you will only need regular gcc and the standard C library headers. You will probably need to run chmod, chown and cp in order to install the program usefully.

The vagueness of this section is intentional.

USAGE: new-root new-cwd exec-name [exec-params]

Bio::Root::Object is a core Perl 5 object.

SYNOPSIS

# Use this module as the root of your inheritance tree.
Object Creation
require Bio::Root::Object;

$dad = new Bio::Root::Object();
$son = new Bio::Root::Object(-name => Junior,
-parent => $dad,
-make => full);
See the new() method for a complete description of parameters. See also the USAGE section .

Bio::Root::Object attempts to encapsulate the "core" Perl5 object: What are the key data and behaviors ALL (or at least most) Perl5 objects should have?
Rationale

Use of Bio::Root::Object.pm within the Bioperl framework facilitates operational consistency across the different modules defined within the Bio:: namespace. Not all objects need to derive from Bio::Root::Object.pm. However, when generating lots of different types of potentially complex objects which should all conform to a set of basic expectations, this module may be handy.

At the very least, this module saves you from re-writing the new() method for each module you develop. It also permits consistent and robust handling of -tag => value method arguments via the Bio::Root::RootI::_rearrange() method and provides a object-oriented way handle exceptions and warnings via the Bio::Root::Root::throw() and Bio::Root::Root::warn() methods.

See the APPENDIX section for some other handy methods.

Fault-Tolerant Objects

A major motivation for this module was to promote the creation of robust, fault-tolerant Perl5 objects. The Bio::Root::Root::throw() method relies on Perls built-in eval{}/die exception mechanism to generate fatal exceptions. The data comprising an exception is managed by the Bio::Root::Err.pm module, which essentially allows the data thrown by a die() event to be wrapped into an object that can be easily examined and possibly re-thrown.

The intent here is three-fold:

1 Detailed error reporting.
Allow objects to report detailed information about the error condition (who, what, where, why, how).
2 Handle complex errors in objects.
The goal is to make it relatively painless to detect and handle the wide variety of errors possible with a complex Perl object. Perls error handling mechanism is a might clunky when it comes to handling complex errors within complex objects, but it is improving.
3 Efficient & easy exception handling.
To enable robust exception handling without incurring a significant performance penalty in the resulting code. Ideally, exception handling code should be transparent to the cpu until and unless an exception arises.

These goals may at times be at odds and we are not claiming to have achieved the perfect balance. Ultimately, we want self- sufficient object-oriented systems able to deal with their own errors. This area should improve as the module, and Perl, evolve. One possible modification might be to utilize Graham Barrs Error.pm module or Torsten Ekedahls Experimental::Exception.pm module (see "Other Exception Modules").

Technologies such as these may eventually be incorporated into future releases of Perl. The exception handling used by Bio::Root::Object.pm can be expected to change as Perls exception handling mechanism evolves.

TERMINOLOGY NOTE: In this discussion and elsewhere in this module, the terms "Exception" and "Error" are used interchangeably to mean "something unexpected occurred" either as a result of incorrect user input or faulty internal processing.

Root Actions servicemenu is a replacement/alternate for the default Edit-as-root servicemenu.
It allows an admin user to perform several root only actions from konqueror (It of course asks for a password)
Usage:
The following actions can be performed (see the screenshot):
Edit as Text: Open file in Kate editor as root (shown with files)
Edit as Hex: Open file in KHexEdit (you may need to install khexedit package from universe) editor as root (shown with files)
Open in Konqueror: Open file/folder in root konqueror window
Change owner to root: Changes ownership to root:root
Change owner to user: Changes ownership to 1000:1000 (the default user)
The menu can be localized by editing the servicemenu .desktop files
Installation:
uncompress the two .desktop files to ~/.kde/share/apps/konqueror/servicemenus
Any comments, criticism and improvement suggestions welcomed.
Enhancements:
- As this seems to run as it should (and I havent gotten any show stopper bug reports), I feel courageous enough to remove the BETA status.
- Removed Preferred Applications section from the perl script. To change the default applications used by the menu, edit the desktop files instead. (This allows for different application preferences for different users and easy creation of custom Open with [application] entries to the menu.) See the README for customization howto.
- Fixed a bug with Rename when multiple items were chosen but the batch renamer application didnt start (the simple rename dialog was started instead).
- Added Dutch translation

rico_RADIO is a little app for X under linux to listen to the radio.
This is how to install:
type (make sure that you are root) "make install" to compile and copy rico_RADIO to "/usr/bin"
Enhancements:
- volume-control
- mute-button
- many cosmetic changes

Pogo is a Perl interface for GOODS.

SYNOPSIS

use Pogo;

$pogo = new Pogo sample.cfg; # connect to a database
$root = $pogo->root_tie; # get a reference to root hash in the database

$root->{key1} = "string"; # store a string into the database
$value = $root->{key1}; # $value is "string"

$root->{key2} = [1,2,3]; # store a array into the database
$arrayref = $root->{key1}; # get a reference to the array in the database
$value = $root->{key2}->[0]; # $value is 1

$root->{key3} = {a=>1,b=>2}; # store a hash into the database
$hashref = $root->{key3}; # get a reference to the hash in the database
$value = $root->{key3}->{b}; # $value is 2

$root->{key4} = new Pogo::Btree;# make a B-tree hash
$hashref = $root->{key5}; # B-tree is accessed as hash

$root->{key5} = new Pogo::Htree;# make a H-tree(see below) hash
$hashref = $root->{key6}; # H-tree is accessed as hash

$root->{key6} = new Aclass; # store a object into the database
$obj = $root->{key4}; # $obj is a Aclass object in the database

Pogo is a Perl interface of GOODS (Generic Object Oriented Database System). Pogo maps Perls scalars, arrays, hashes and objects directly to the database objects. Pogo has the data types as follows.

- scalar
- array
- hash
- B-tree
- H-tree (hash that hash entry table is placed as B-tree)
- N-tree (same as B-tree but key is treated as number)

The value of a scalar data or an element of a collection type data is a string or a reference to another data. Pogo uses Perls tieing mechanism and provide transparent accessibility to persistent data in the database. Each data in the database can have class name string internally, so Perl objects (i.e. reference which is blessed by a class name) can be stored in the database.