Free newspaper archives software for linux

Extract archive is a service menu that allows you to extract any archive file that ark is capable to read + ACE files.
You can chose to extract here, or in a subdirectory. In that case, it asks you the name of the subdirectory where you want to extract, and suggests you the archive name by default.
To install, simply extract, and move the 2 files in ~/.kde/share/apps/konqueror/servicemenus
Its highly recommended to download the latest version of unace on www.winace.com and to run this command line in the unace directory location : sudo cp unace /usr/bin/unace
You should desactivate ark integration into kde by going into the configuration menu of ark.
If you want translation to be added, post me comments.
Enhancements:
- thanks to shirka, extract archive path is now "test" for an "test.tar.bz2" file
- Name that appears in the menu is now "Extract archive" as suggested by dovidhalevi to differentiate with ark

LinPHA is an easy to use, multilingual, flexible photo/image archive/album/gallery written in PHP. It uses a SQL database to store information about your pictures.

It comes with a HTML based installer, so you dont need experience in setting up SQL DB.

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

XArchive is a generic front end for archives that uses external wrappers around the command line tools. XArchive checks its wrapper directory when it starts, consulting each wrapper found to see what file types are supported.
Thus, a new archive format can easily be supported by just writing a wrapper for it and dropping it in the wrappers directory.
Currently there are bash shell wrappers for: rar, tar, zip, and ace
(ace supported using unace, so only reading and extracting available).
These can easily be copied and modified to have xarchive support other command line tools and file types without having to touch xarchive at all.
Enhancements:
- This version supports adding files to an archive using Drag n Drog, and has a few GUI clean ups.

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::Zip is a Perl module which provides an interface to ZIP archive files.

SYNOPSIS

# Create a Zip file
use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
my $zip = Archive::Zip->new();

# Add a directory
my $dir_member = $zip->addDirectory( dirname/ );

# Add a file from a string with compression
my $string_member = $zip->addString( This is a test, stringMember.txt );
$string_member->desiredCompressionMethod( COMPRESSION_DEFLATED );

# Add a file from disk
my $file_member = $zip->addFile( xyz.pl, AnotherName.pl );

# Save the Zip file
unless ( $zip->writeToFileNamed(someZip.zip) == AZ_OK ) {
die write error;
}

# Read a Zip file
my $somezip = Archive::Zip->new();
unless ( $somezip->read( someZip.zip ) == AZ_OK ) {
die read error;
}

# Change the compression type for a file in the Zip
my $member = $somezip->memberNamed( stringMember.txt );
$member->desiredCompressionMethod( COMPRESSION_STORED );
unless ( $zip->writeToFileNamed( someOtherZip.zip ) == AZ_OK ) {
die write error;
}

The Archive::Zip module allows a Perl program to create, manipulate, read, and write Zip archive files.

Zip archives can be created, or you can read from existing zip files.
Once created, they can be written to files, streams, or strings. Members can be added, removed, extracted, replaced, rearranged, and enumerated. They can also be renamed or have their dates, comments, or other attributes queried or modified. Their data can be compressed or uncompressed as needed.
Members can be created from members in existing Zip files, or from existing directories, files, or strings.

This module uses the Compress::Zlib library to read and write the compressed streams inside the files.

Archive::SelfExtract is a Perl module to bundle compressed archives with Perl code.

SYNOPSIS

use Archive::SelfExtract;

# writes output script to STDOUT
Archive::SelfExtract::createExtractor( "perlcode.pl", "somefiles.zip" );

# with various options:
Archive::SelfExtract::createExtractor( "perlcode.pl", "somefiles.zip",
perlbin => "/opt/perl58/bin/perl",
output_fh => $someFileHandle,
);
See also the command line tool, mkselfextract.

Archive::SelfExtract allows you create Perl programs out of compressed zip archives. Given a piece of code and an archive, it creates a single file which, when run, unpacks the archive and then runs the code.

This module provides a function for creating a self-extractor script, a function to unpack the archive, and utility functions for wrapped programs