Free 255 software for linux

AudioCD::Mac is a MacPerl extension for controlling Audio CDs.

SYNOPSIS

#!perl -w
use AudioCD;
use strict;
my $cd = new AudioCD;

$cd->volume(255);
$cd->play(2);
print "Now playingn" if $cd->status == CD_PLAY;
printf "Volume is %dn", $cd->volume;
sleep(5);

$cd->pause;
print "Now pausedn" if $cd->status == CD_PAUSE;
sleep(5);

$cd->volume(100);
$cd->continue;
print "Now playingn" if $cd->status == CD_PLAY;
printf "Volume is %dn", $cd->volume;
sleep(5);

my @info = $cd->info;
printf "Currently at track %d, %.2d:%.2dn", @info[0..2];

$cd->stop;
my $status = $cd->status;
print "Now stoppedn" if
($status == CD_FINISH || $status == CD_STOP);

if (do CDDB.pm) { # sold separately
my $cddb = new CDDB;
my @cddb_info = $cddb->calculate_id( $cd->cddb_toc );
my @discs = $cddb->get_discs(@cddb_info[0, 3, 4]);
print "You were probably listening to $discs[0]->[2]n";
}

$cd->eject;

This is the MacPerl module to be used by the AudioCD module. Other modules can be written for other platforms, but this one is Mac specific, calling Mac OS APIs to control the CD player.

cexec is a software for building ad-hoc clusters.
To install cexec, you need to first build it (type make) then copy the executables into /usr/local/bin or someplace in your path. Youll probably want to copy the manual pages (*.1) someplace in your $MANPATH.
Note that the cexec on-wire protocol is still evolving in incompatible ways; Its not wise to try and use the cluster tools across administrative domains.
A cexec "cluster" consists of:
- One or more applications
- An announcement address. This can be a broadcast address, or a multicast address. It could also be a unicast address, but then that wouldnt allow for other servers. The default is probably fine for most people (255.255.255.255) - this value should be stored in the $GROUP environment variable.
- A bunch of general-purpose unix-like machines
- A keypair that identifies applications, and mutually authenticates clients/servers
To build a cexec cluster, you need to decide on your applications, announcement address, and have computers to run it. As an example, well build a cluster-enabled version of "oggenc". This example assumes youve already got oggenc installed, and you already got your machines together:
0. Build the keypair using "ckeygen" ckeygen distributed_ogg distributed_ogg.pub
1. Distribute the "distributed_ogg" key to all of your "worker machines"
2. Distribute the "distributed_ogg.pub" key to all of your "client machines"
3. Start the service on all your workers: cservice distributed_ogg oggenc -o- -
4. Start a logger service on any worker or client: crat
5. Encode something, cexec distributed_ogg.pub < input.wav > output.ogg
You couldve used any application- not just "oggenc"- with this cluster. You could make this cluster as big as you want (with multicast tunnels) and cross as many networks as you want (with cproxy).
When "cexec" starts up, it locates the "best" copy of cservice on the network. It does this by broadcasting announcements. One of the cservice machines will attempt to "connect back" to the cexec after a delay thats proportional to the systems load. The first machine to "reach back" and perform the various challenges regarding the keypair is the winner.
At this point, cexec multiplexes the local file descriptors over the work-channel and cservice does the reverse on the other side. cservice uses pipes where possible, but will use socketpair() to emulate readwrite devices like terminals and sockets.
When "cservice" is done, it sends its exit code back to "cexec". If "cexec" didnt like any part of the protocol exchange, it "complains". If everything went okay, it announces the exit code in the same way. These "alerts" are received by a "crat" running on the network.
Enhancements:
- This release doesnt regenerate parity, which should help acquire loaded hosts (above runq length 10.0) faster.

ID3edit is a command line based ID3v1.1 tag editor for unix like systems. If you dont know what an ID3 tag is, let me fill you in. An ID3 tag is a descriptive tag placed in the last 128 bytes of an mp3 file. The information that is placed in this tag shows as follows:

Song Name (30 Characters Max)
Artist Name (30 Characters Max)
Album Name (30 Characters Max)
Year (4 Characters Max)
Comment (28 Characters Max)
Track (Number Between 0-255)
Genre (Number Between 0-255)

To install id3edit, simply gunzip the archive file like so...
$gunzip id3edit.tar.gz

Next, unpack the tar file like so...
$tar -xvf id3edit.tar

Now, you should have a new directory called id3edit. Next you change to the id3edit directory and type...
$make

This will compile program. To install id3edit into /usr/local/bin, as root type...
$make install

Whatmask provides a subnet info utility.
Whatmask is a small C program that helps with network settings. Notations supported are CIDR (e.g. /24), Netmask (e.g. 255.255.255.0), and Wilcard Bits (e.g. 0.0.0.255).
These notations are all identical. CIDR notation commonly has a "/" in front of the number (representing the number of bits). Whatmask can accept these notations with or without a slash.
It can take any IP in the subnet along with the netmask in any format, and it will echo back the netmask in three formats, the network address, the broadcast address, the number of useable IPs, and the range of IPs in the subnet.
Binaries for Linux, Win32, and MacOS 9/X are available.
Enhancements:
- Added support for hex netmasks
- Minor bugfixes / cleanup

I wrote this to be able to access a news server that would not allow me to connect from my machine, but would from another that I had access to.
tcpgate is a daemon that listens on a port for connections, and when the connection is made, proxies/bounces it to the host/port pair specified in the config file unmodified. Very simple, but very useful when you need to get around a bad route/firewall. Latest version has IP-based access control option.
Installation:
install libtcp++
gunzip -c tcpgate-0.0.1.tar.gz | tar xvf -
make tcpgate
Usage:
./tcpgate config_file
example of config_file
to_port 119
to_host news.mydomain.com
port 1234
log_file tcpgate.log
ip_rules_file site.rules
to_port - port to which the packets are proxied,
to_host - the host to which the packets are proxied,
port - port that tcpgate listens on
log_file - file where tcpgate writes the log :)
ip_rules_file - if present, enables IP-based access control, and must contain a set
of allow rules. Any host not matched by those rules will be denied connection.
Example
of ip_rules_file:
127.0.0.1/255.255.255.255
128.187.0.0/255.255.0.0
The above example will allow localhost to connect, as well as any machine coming from 128.187.0.0 subnet
Enhancements:
- added ip-based access control

Sort::Key is the fastest way to sort anything in Perl.

SYNOPSIS

use Sort::Key qw(keysort nkeysort ikeysort);

@by_name = keysort { "$_->{surname} $_->{name}" } @people;

# sorting by a numeric key:
@by_age = nkeysort { $_->{age} } @people;

# sorting by a numeric integer key:
@by_sons = ikeysort { $_->{sons} } @people;

Sort::Key provides a set of functions to sort lists of values by some calculated key value.

It is faster (usually much faster) and uses less memory than other alternatives implemented around perl sort function (ST, GRT, etc.).

Multikey sorting functionality is also provided via the companion modules Sort::Key::Multi, Sort::Key::Maker and Sort::Key::Register.

FUNCTIONS

This module provides a large number of sorting subroutines but they are all variations off the keysort one:

@sorted = keysort { CALC_KEY($_) } @data

that is conceptually equivalent to

@sorted = sort { CALC_KEY($a) cmp CALC_KEY($b) } @data

and where CALC_KEY($_) can be any expresion to extract the key value from $_ (not only a subroutine call).

For instance, some variations are nkeysort that performs a numeric comparison, rkeysort that orders the data in descending order, ikeysort and ukeysort that are optimized versions of nkeysort that can be used when the keys are integers or unsigned integers respectively, etc.

Also, inplace versions of the sorters are provided. For instance

keysort_inplace { CALC_KEY($_) } @data

that is equivalent to

@data = keysort { CALC_KEY($_) } @data

but being (a bit) faster and using less memory.

The full list of subroutines that can be imported from this module follows:

keysort { CALC_KEY } @array

returns the elements on @array sorted by the key calculated applying { CALC_KEY } to them.

Inside { CALC_KEY }, the object is available as $_.

For example:

@a=({name=>john, surname=>smith}, {name=>paul, surname=>belvedere});
@by_name=keysort {$_->{name}} @a;

This function honours the use locale pragma.

nkeysort { CALC_KEY } @array

similar to keysort but compares the keys numerically instead of as strings.

This function honours the use integer pragma, i.e.:

use integer;
my @s=(2.4, 2.0, 1.6, 1.2, 0.8);
my @ns = nkeysort { $_ } @s;
print "@nsn"
prints
0.8 1.6 1.2 2.4 2

rnkeysort { CALC_KEY } @array
works as nkeysort, comparing keys in reverse (or descending) numerical order.
ikeysort { CALC_KEY } @array
works as keysort but compares the keys as integers (32 bits or more, no checking is performed for overflows).
rikeysort { CALC_KEY } @array
works as ikeysort, but in reverse (or descending) order.
ukeysort { CALC_KEY } @array
works as keysort but compares the keys as unsigned integers (32 bits or more).

For instance, it can be used to efficiently sort IP4 addresses:

my @data = qw(1.2.3.4 4.3.2.1 11.1.111.1 222.12.1.34
0.0.0.0 255.255.255.0) 127.0.0.1);

my @sorted = ukeysort {
my @a = split /./;
(((($a[0] name,
$_->middlename },
qw(str str str);

Sort::Key::register_type Color =>
sub { $_->R, $_->G, $_->B },
qw(int int int);

Once a datatype has been registered it can be used in the same way as types supported natively, even for defining new types, i.e.:

Sort::Key::register_type Family =>
sub { $_->man, $_->woman },
qw(Person Person);

Gimp::PDL is a Perl module to overwrite Tile/Region functions to work with piddles. This module is obsolete, please remove any references to it.

SYNOPSIS
use Gimp;
use Gimp::PDL;
use PDL;

This module overwrites some methods of Gimp::Tile and Gimp::PixelRgn. The new functions return and accept piddles. The last argument (height) of gimp_pixel_rgn_set_rect is calculated from the piddle. There is no other way to access the raw pixeldata in Gimp.

Some exmaples:

$region = $drawable->get->pixel_rgn (0,0, 100,100, 1,0);
$pixel = $region->get_pixel (5,7); # fetches the pixel from (5|7)
print $pixel; # outputs something like
# [255, 127, 0], i.e. in
# RGB format ;)
$region->set_pixel ($pixel * 0.5, 5, 7);# darken the pixel
$rect = $region->get_rect (3,3,70,20); # get a horizontal stripe
$rect = $rect->hclip(255/5)*5; # clip and multiply by 5
$region->set_rect($rect); # and draw it!
undef $region; # and update it!