Free ctable 1.03 software for linux

Data::CTable is a Perl module that helps you read, write, manipulate tabular data.

SYNOPSIS

## Read some data files in various tabular formats
use Data::CTable;
my $People = Data::CTable->new("people.merge.mac.txt");
my $Stats = Data::CTable->new("stats.tabs.unix.txt");

## Clean stray whitespace in fields
$People->clean_ws();
$Stats ->clean_ws();

## Retrieve columns
my $First = $People->col(FirstName);
my $Last = $People->col(LastName );

## Calculate a new column based on two others
my $Full = [map {"$First->[$_] $Last->[$_]"} @{$People->all()}];

## Add new column to the table
$People->col(FullName => $Full);

## Another way to calculate a new column
$People->col(Key);
$People->calc(sub {no strict vars; $Key = "$Last,$First";});

## "Left join" records matching Stats:PersonID to People:Key
$Stats->join($People, PersonID => Key);

## Find certain records
$Stats->select_all();
$Stats->select(Department => sub {/Sale/i }); ## Sales depts
$Stats->omit (Department => sub {/Resale/i}); ## not Resales
$Stats->select(UsageIndex => sub {$_ > 20.0}); ## high usage

## Sort the found records
$Stats->sortspec(DeptNum , {SortType => Integer});
$Stats->sortspec(UsageIndex, {SortType => Number });
$Stats->sort([qw(DeptNum UsageIndex Last First)]);

## Make copy of table with only found/sorted data, in order
my $Report = $Stats->snapshot();

## Write an output file
$Report->write(_FileName => "Rept.txt", _LineEnding => "mac");

## Print a final progress message.
$Stats->progress("Done!");

## Dozens more methods and parameters available...

OVERVIEW

Data::CTable is a comprehensive utility for reading, writing, manipulating, cleaning and otherwise transforming tabular data. The distribution includes several illustrative subclasses and utility scripts.

A Columnar Table represents a table as a hash of data columns, making it easy to do data cleanup, formatting, searching, calculations, joins, or other complex operations.

The objects hash keys are the field names and the hash values hold the data columns (as array references).

Tables also store a "selection" -- a list of selected / sorted record numbers, and a "field list" -- an ordered list of all or some fields to be operated on. Select() and sort() methods manipulate the selection list. Later, you can optionally rewrite the table in memory or on disk to reflect changes in the selection list or field list.
Data::CTable reads and writes any tabular text file format including Merge, CSV, Tab-delimited, and variants. It transparently detects, reads, and preserves Unix, Mac, and/or DOS line endings and tab or comma field delimiters -- regardless of the runtime platform.

In addition to reading data files, CTable is a good way to gather, store, and operate on tabular data in memory, and to export data to delimited text files to be read by other programs or interactive productivity applications.

To achieve extremely fast data loading, CTable caches data file contents using the Storable module. This can be helpful in CGI environments or when operating on very large data files. CTable can read an entire cached table of about 120 megabytes into memory in about 10 seconds on an average mid-range computer.

For simple data-driven applications needing to store and quickly retrieve simple tabular data sets, CTable provides a credible alternative to DBM files or SQL.
For data hygiene applications, CTable forms the foundation for writing utility scripts or compilers to transfer data from external sources, such as FileMaker, Excel, Access, personal organizers, etc. into compiled or validated formats -- or even as a gateway to loading data into SQL databases or other destinations. You can easily write short, repeatable scripts in Perl to do reporting, error checking, analysis, or validation that would be hard to duplicate in less-flexible application environments.

The data representation is simple and open so you can directly access the data in the object if you feel like it -- or you can use accessors to request "clean" structures containing only the data or copies of it. Or you can build your own columns in memory and then when youre ready, turn them into a table object using the very flexible new() method.

The highly factored interface and implementation allow fine-grained subclassing so you can easily create useful lightweight subclasses. Several subclasses are included with the distribution.

Most defaults and parameters can be customized by subclassing, overridden at the instance level (avoiding the need to subclass too often), and further overridden via optional named-parameter arguments to most major method calls.

htpasstool is a web-based management tool for Apache .htpasswd files.
Its small (just 1 php file), free as in freedom (released under the GPL) and straightforward to use.
It can protect/unprotect directories in your webspace, add users, rename users, remove users, and change passwords in the .htpasswd file. All through a friendly, simple web interface. And it is trivial to install.
Enhancements:
- This release fixes a small bug in the assignpasswordform function.

PIX::Walker is a Perl module to process Cisco PIX configs and walk access-lists.

SYNOPSIS

PIX::Walker is an object that allows you to process PIX firewall configs and walk an access-list for matches. PIX OS versions 6 and 7 are supported.

** This module is still in very early development **

Loose ACL matching performed. This means that you can specify as little as a source IP to match what line(s) that IP would match in the ACL on the firewall. Or you can provide every detail including source/dest IPs, ports, and protocol to match a specific line of an ACL. Loose matching allows you to see potential lines in a large ruleset that a single source or destination IP might match.

More than just the first line match can be returned. If your search criteria can technically match multiple lines they will all be returned. This is useful for seeing extra matches in your ACL that might also match and can help you optimize your ACL.

EXAMPLE

use PIX::Walker;

my $config = ... string of full firewall config ... ;
my $fw = new PIX::Walker($config);
my $acl = $fw->acl(outside_access) || die("ACL does not exist");

my $matched = 0;
foreach my $line ($acl->lines) {
if ($line->match(
source => 10.0.1.100,
dest => 192.168.1.3,
port => 80,
protocol => tcp)) {
print "Matched ACL $acl->name ($acl->elements ACE)n" if !$matched++;
print $line->print, "n";
}
}

METHODS

acl($name)

Returns an PIX::Accesslist object for the ACL named by $name.

acls()

Returns an array of PIX::Accesslist objects for each access-list found in the firewall configuration. Returns undef if there is no matching ACL.

alias($string)

Returns the IP of the alias given in $alias. If no alias is found than the string is returned unchanged.

findip($ip, [$trace])

Matches the IP to an existing network-group. Does not validate it within any ACL. If a single group is matched a scalar is returned with the name, otherwise an array reference is returned containing all matches.

* $ip is an IP address to look for.

* $trace is an optional reference to a trace buffer. If an IP is found in a nested group the trace will allow you to find out where it was nested. See tracedump() for more information.

findport($port, [$trace])

Matches the PORT to an existing service-group. Does not validate it within any ACL. If a single group is matched a scalar is returned with the name, otherwise an array reference is returned containing all matches.

* $port is the PORT to look for.

* $trace is an optional reference to a trace buffer. If a PORT is found in a nested group the trace will allow you to find out where it was nested. See tracedump() for more information.

obj($name)

Returns an PIX::Object object for the object-group that matches the $name given.

tracedump($trace)

Prints out the trace dump given. This will allow you to see where IPs and PORTs are being matched within their object-groups even if they are nested.

$matched = $fw->findip($ip, $trace);
$fw->tracedump($trace);

RubySlippers is a GUI frontend to the RubyGems package management system. It can view gemspec files, list installed files, install gems, query the RubyGems list, build Gems, and view documentation.
This program uses the RubyWebDialogs GUI, and is built on the rwdtinker framework, so more applets can be loaded and unloaded. Context sensitive help is included.
Installation
Using the "Install Gem" tab
You can list the Gems available in the repository
Click on the button.
It will take several seconds then should show the list.
To install a gem, enter the name into to textbox and click on the install Gem button
You should see the result of the command on the screen
You can check in the first tab if it is installed.
Enhancements:
- add in test harness
- fix gem list input
- added in dependencies to gemcommands
- added gemspec filename to editgemspec tab
- added gemwhich command

Thin SFTP Applet is a full featured Secure File Transfer Program. Thin SFTP Applet can be use for secure file transfer and management and can be easily integrated into your website or web application.
You can use our SFTP applet to carry out recursive folder uploads and downloads, with entire directory trees being transfered in a single click.
Interrupted transfers can be resumed. Unlike the FTP protocol, with SFTP all data and commands are encrypted for maximum security.
In spite of being a web client, its appearence is no different from a traditional 2-Table File Transfer Program for desktops.
Because the client is an applet it does not need to refresh itself each time a file transfer or any other operation takes place. The result is that the user experience is no different from using a desktop client.
Enhancements:
- A minor bug related to connection pooling and reuse was fixed.

mod_become module enables the web server to take on the access rights of a user & group, so that ~users can make available files to the web without having to make them readable by the world on the local file system. This can be useful for sites with a large number of users who want to apply file access controls among themselves. This module can also be applied to virtual hosts, directories, and locations.

When the server is configured with "User root" (see Security), then this module will behave as though the directive "MaxRequestsPerChild 1" were set for the server and "KeepAlive off" were set for the server and every virtual host where a mod_become directive appears, which essentially limits the server and those virtual hosts to HTTP/1.0 behaviour.

Therefore, for each request, this module will setuid() and setgid() the process handling the request based on one of the policies outlined below. Once the request is completed, the process will terminate. The parent server will be responsible for spawning a new child process to handle any future requests.

The source can be compiled to use seteuid() and setegid() instead of setuid() and setgid() (see the top of the Makefile), but is NOT the default. Use of seteuid() and setegid() can improve preformance by avoiding the need to kill the Apache child process between requests, but it DOES have significant security issues. For example modules like mod_php or mod_perl that provide APIs to seteuid() and setegid(), could be used to become root user once again and do what ever they want.

Essentially any module that is part of the Apache process space could revert to root user if they make use of seteuid() and setegid(). It is recommended that within mod_php, mod_perl, and other language modules that these APIs be disabled. CGIs that are launched as a separate process by Apache should, in theory, be safe, since the effective user and group ID become the real user and group ID of the child process and therefore cannot revert back to root (if I understand things correctly).

Configuration

The commands below can be added to the general Apache configuration file, httpd.conf.

User id
Context: global, < VirtualHost >

This is not part of mod_become, but is used to enable or disable mod_becomes behaviour, since mod_become can only function when "User root" is specified for the main server configuration. You need to compile Apache with -DBIG_SECURITY_HOLE in order to do this.

Become user id
Become group id
Context: server, < VirtualHost >, < Directory >, < Location >

Specify the user or group to be used by default. When the BecomePolicy is user-group, then these will always be used. If the main server configuration fails to set the default user and group, then an error 503 Service Unavailable and a error log entry may occur should these values be required.

BecomePolicy policy
Context: global, < VirtualHost >, < Directory >, < Location >

Specify the policy used to set the user & group ids of the child process:
file

The user & group of the requested file are used. Not recommend.
user-group

The default user & group specified are used. This is similar in behaviour to the Apache core directives User and Group. This is the default policy.
document-root

The user & group of the servers or virtual hosts document root is used.
parent-directory

The user & group of the requests parent directory is used. When the request corresponds to a directory, then it is used instead of its parent.

BecomeRoot boolean
Context: global, < VirtualHost >, < Directory >, < Location >

When true, mod_become will allow the process to operate as root user or group; otherwise a 403 Forbidden error and a error log entry will occur if the process attempts to become root user or group. By default this is set false.

Cache::Bounded is a size-aware in-memory cache optimized for speed.

SYNOPSIS

Cache::Bounded is designed for caching items into memory in a very fast but rudimentarily size-aware fashion.

Most intelligent caches take either a size-aware or use-aware approach. They do so by either anlysing the size of all the elements in the cache or their frequency of usage before determining which elements to drop from the cache. Unfortunately, the processing overhead for this logic (usually applied on insert) will often slow these caches singnificantly when frequent insertions are needed.
This module was designed address when this speed-penalty becomes a problem. Specifically, it is a rudimentarily size-aware cache that is optimized to be very fast.

For its size analysis, this module merely checks the number of elements in the cache against a raw size limit. (The default limit is 500,000) Additionally, to aid speed, the "size" check doesnt occur on every insertion. Only after a count of a certain number of insertions (default 1,000) is the size check performed. If the size limit has been exceeded, the entire cache is purged. (Since there is no usage analysis, there is no other logical depreciation that can be applied)
This produces a very fast in-memory cache that you can tune to approximate size based upon your data elements.

USAGE

my $cache = new Cache::Bounded;

$cache->set($key,$value);
my $value = $cache->get($key);