Free archive software for linux

Simple utility that turns your monitor into a configurable strobe light.

Source code is included alongside the executable "strobelight" in the archive.

Archive Search is an extension which displays an archived versions of the webpage.

Displays an archived versions of the webpage.

First click: Internet Archive
Second click: Google cache
Third click: Yahoo
Fourth click: MSN

Archive::Tyd is a Perl extension for simple file archiving.

SYNOPSIS

use Archive::Tyd;

my $tyd = new Archive::Tyd (password => secret password);

# Load an archive.
$tyd->openArchive ("./archive.tyd");

# Add a file.
$tyd->addFile ("./secret image.jpg");

# Write the archive.
$tyd->writeArchive ("./archive.tyd");

# Read the secret rules.
my $rules = $tyd->readFile ("rules.txt");

Tyd is a simple archiving algorith for merging multiple files together and encrypting the results, hence a password-protected archive.

Tyd Does: Reading and writing of encrypted Tyd archives and file operations within.

Tyd Does: Load all files into memory. Tyd is not good as a storage device for a large quanitity of large files. Tyd is best for keeping small text files and graphics together (maybe to keep a spriteset and definitions for a game?)

Tyd Does Not: support directories within the archive, compression of files, and many other things that WinZip and GZip support.

Archive::TarGzip is a Perl module to save and restore files to and from compressed tape archives (tar).

SYNOPSIS

######
# Subroutine Interface
#
use Archive::TarGzip qw(parse_header tar untar);

$tar_file = tar(@file, @options);
$tar_file = tar(@file);

$success = untar(@file);
$success = untar(@file, @options);

%tar_header = parse_header($buffer);

######
# File subroutines
#
use Archive::TarGzip;

tie *TAR_FILEHANDLE, Tie::Layers
tie *TAR_FILEHANDLE, Tie::Layers, @options

$success = open(TAR_FILEHANDLE, $tar_file);
$success = open(TAR_FILEHANDLE, $mode, $tar_file);

$success = print TAR_FILEHANDLE $file_name;
$success = print TAR_FILEHANDLE $file_name, $file_contents;

%tar_header = ;

$success = close(TAR_FILEHANDLE);

######
# Object
#
tie *TAR_FILEHANDLE, Tie::Layers;
tie *TAR_FILEHANDLE, Tie::Layers, @options;

$tar = tied *TAR_FILEHANDLE;
$tar = new Archive::TarGzip( );
$tar = new Archive::TarGzip(@options);

$success = $tar->OPEN( $tar_file, @options);
$success = $tar->OPEN( $mode, $tar_file, @options);

$success = $tar->PRINT($file_name);
$success = $tar->PRINT($file_name, $file_contents);

%tar_header = $tar->READLINE(@options);
%tar_header = $tar->READLINE(@file, @options);

$status = $tar->target( $buffer, $size);
$success = $tar->CLOSE();

The Archive::TarGzip module provides tar subroutine to archive a list of files in an archive file in the tar format. The archive file may be optionally compressed using the gzip compression routines. The Archive::TarGzip module also provides a untar subroutine that can extract the files from the tar or tar/gzip archive files. The tar and untar top level subroutines use methods from the Archive::TarGzip class.

The Archive::TarGzip class has many similarities to the very mature Archive::Tar class being at least three years older. The newer Archive::TarGzip relied very heavy on the work of the author of the Archive::Tar and in many instance the Archive::Tar is a better solution.

Altough the underlying tar file format is the same and similar code is used to access the data in the underlying tar files, the interace bewteen the two are completely different. The Archive::TarGzip is built on a Tie File Handle type interface. The nthe Archive::TarGzip provide means to access individual files within the archive file without bringing the entire archive file into memory. When the gzip compression option is active, the compression is performed on the fly without creating an intermediate uncompressed tar file.

Archive::Ar is a Perl interface for manipulating ar archives.

SYNOPSIS

use Archive::Ar;

my $ar = new Archive::Ar("./foo.ar");

$ar->add_data("newfile.txt","Some contents", $properties);

$ar->add_files("./bar.tar.gz", "bat.pl")
$ar->add_files(["./again.gz"]);

$ar->remove("file1", "file2");
$ar->remove(["file1", "file2");

my $filedata = $ar->get_content("bar.tar.gz");

my @files = $ar->list_files();
$ar->read("foo.deb");

$ar->write("outbound.ar");

$ar->DEBUG();

Archive::Ar is a pure-perl way to handle standard ar archives.

This is useful if you have those types of old archives on the system, but it is also useful because .deb packages for the Debian GNU/Linux distribution are ar archives. This is one building block in a future chain of modules to build, manipulate, extract, and test debian modules with no platform or architecture dependence.

You may notice that the API to Archive::Ar is similar to Archive::Tar, and this was done intentionally to keep similarity between the Archive::* modules

Class Methods
new()
new($filename)
new(*GLOB,$debug)

Returns a new Archive::Ar object. Without a filename or glob, it returns an empty object. If passed a filename as a scalar or in a GLOB, it will attempt to populate from either of those sources. If it fails, you will receive undef, instead of an object reference.

This also can take a second optional debugging parameter. This acts exactly as if DEBUG() is called on the object before it is returned. If you have a new() that keeps failing, this should help.
read($filename)
read(*GLOB);

This reads a new file into the object, removing any ar archive already represented in the object. Any calls to DEBUG() are not lost by reading in a new file. Returns the number of bytes read, undef on failure.

read_memory($data)

This read information from the first parameter, and attempts to parse and treat it like an ar archive. Like read(), it will wipe out whatever you have in the object and replace it with the contents of the new archive, even if it fails. Returns the number of bytes read (processed) if successful, undef otherwise.

list_files()
This lists the files contained inside of the archive by filename, as an array.
add_files("filename1", "filename2")
add_files(["filename1", "filename2"])

Takes an array or an arrayref of filenames to add to the ar archive, in order. The filenames can be paths to files, in which case the path information is stripped off. Filenames longer than 16 characters are truncated when written to disk in the format, so keep that in mind when adding files.

Due to the nature of the ar archive format, add_files() will store the uid, gid, mode, size, and creation date of the file as returned by stat();

add_files() returns the number of files successfully added, or undef on failure.
add_data("filename", $filedata)

Takes an filename and a set of data to represent it. Unlike add_files, add_data is a virtual add, and does not require data on disk to be present. The data is a hash that looks like:

$filedata = {
"data" => $data,
"uid" => $uid, #defaults to zero
"gid" => $gid, #defaults to zero
"date" => $date, #date in epoch seconds. Defaults to now.
"mode" => $mode, #defaults to "100644";
}

You cannot add_data over another file however. This returns the file length in bytes if it is successful, undef otherwise.

write()
write("filename.ar")

This method will return the data as an .ar archive, or will write to the filename present if specified. If given a filename, write() will return the length of the file written, in bytes, or undef on failure. If the filename already exists, it will overwrite that file.
get_content("filename")

This returns a hash with the file content in it, including the data that the file would naturally contain. If the file does not exist or no filename is given, this returns undef. On success, a hash is returned with the following keys:

name - The file name
date - The file date (in epoch seconds)
uid - The uid of the file
gid - The gid of the file
mode - The mode permissions
size - The size (in bytes) of the file
data - The contained data
remove("filename1", "filename2")
remove(["filename1", "filename2"])

The remove method takes a filenames as a list or as an arrayref, and removes them, one at a time, from the Archive::Ar object. This returns the number of files successfully removed from the archive.

DEBUG()

This method turns on debugging. Optionally this can be done by passing in a value as the second parameter to new. While verbosity is enabled, Archive::Ar will toss a warn() if there is a suspicious condition or other problem while proceeding. This should help iron out any problems you have while using the module.

Archive::Builder is a file generation and archiving framework.

SYNOPSIS

# Make a builder with one section, and some files
my $Builder = Archive::Builder->new;
my $Section = $Builder->new_section( html );
$Section->add_file( one.html, string, qq~
Hello World!
~ );
$Section->add_file( two.html, file, ./source/file.html );
$Section->add_file( three.html, Custom::function, @args );

# Generate and save to disk
$Builder->save( ./somewhere );

# Create an zip file from it and save it.
my $Archive = $Builder->archive( zip ).
$Archive->save( foo.zip );

# Create a tar.gz file of just one section
my $Tar = $Section->archive( tar.gz );

Perl is often used for applications that generate large numbers of files, and Archive::Builder is designed to assist in these sorts of tasks.

It provides a framework for defining a set of files, and how they will be generated, and a series of methods for turning them into an Archive of varying types, or saving directly to disk.

xDash::Archive::Pg is a base class for Archive.

SYNOPSIS

package Archive;
use base xDash::Archive::Pg;
# Set up your own database access parameters
sub SetParameters { shift->SUPER::SetDatabaseConnection(
name => xdash, user => , password => ) }

USAGE

The module is developed in the object orientated way. It can be used as the base class for archiving based on PostgreSQL as persistence. The base class has to implement a fixed set of methods, called by the derived class Archive. Archive is hardcoded in the xDash::Archivist (driver pattern).

For more details, how to set up all the needed components, see the introduction to the deployment: Planning and deploying xDash in a sandbox at http://xdash.jabberstudio.org/deployment/perl. By deriving from the class, as the way of passing arguments, you have to implement explicit methods listed below . The synopsis above is an example of the client script generated by the xdscr.

METHODS

SetDatabaseConnection( name => $database_name, user => $database_user, password => database_password )

Passes the self explanatory parameters to the DBI module, required by xDash::Archivist.