Free winrar zip archive downloads software for linux

Top Downloads provides a script that counts how many times a file has been downloaded.

It keeps statistics of your downloads and can generate a TOP10 of your downloaded files. The administration function of this script allows you to delete, rename or change count numbers for your downloads.

It can check a directory that you specify for new files and add it to a database. Count numbers and TOP10 can be included into a HTML document.

Most web servers require SSI documents to have the extension .shtml or .shtm

For Apache web servers:
- AddType text/html .shtml
- AddHandler server-parsed .shtml

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

WormBase::Archive::Build can create archives of Wormbase releases.

SYNOPSIS

use Bio::GMOD::Admin::Archive;
my $archive = Bio::GMOD::Admin::Archive->new();

$archive->create_archive();

METHODS

Bio::GMOD::Admin::Archive->new(@options)
Create a new WormBase::Archive object for archiving WormBase releases.

The options consist largely of file system and remote paths. If none are provided, they will all be populated from the default file located on the primary WormBase server.

This is the recommended idiom as it insulates your programs from structural changes at WormBase. In this case, archives will be built in /pub/wormbase/RELEASE where RELEASE is a WSXXX release.

There are, however, at least two options that you will wish to provide:

--database_repository Full path where to store archives on your filesystem
--mysql_path Full path to the mysql data dir

See WormBase.pm for additional details on all system-dependent paths that can be overridden.

News::Archive is a Usenet news archiving package for downloading and later accessing news articles in bulk.

It can load articles laid out in INN format, retrieve them from a running news server, or just take articles one-by-one. News::Archive module is compatible with News::Web and Net::NNTP::Server, so the articles can be shared either via the Web or via NNTP.

SYNOPSIS

use News::Archive;
my $archive = new News::Archive
( basedir => /home/tskirvin/kiboze );

# Get a news article
my $article = News::Article->new(*STDIN);
my $msgid = article->header(message-id);

die "Already processed $msgidn"
if ($archive->article( $messageid ));

# Get the list of groups were supposed to be saving the article into
my @groups = split(s*,s*, $article->header(newsgroups) );
map { s/s+//g } @groups;

# Make sure were subscribed to these groups
foreach (@groups) { $archive->subscribe($_) }

# Actually save the article.
my $ret = $archive->save_article(
[ @{$article->rawheaders}, , @{$article->body} ], @groups );
$ret ? print "Accepted article $messageidn"
: print "Couldnt save article $messageidn";

News::Archive keeps several files to keep track of its archives:

active file

Keeps track of all newsgroups we are "subscribed" to and all of the information that changes regularly - the number of articles we have archived, the current first and last article numbers, etc.

Watched over with News::Active.

history database

A simple database keeping track of articles by Message-ID. Makes access by ID easy, and ensures that we dont save the same article twice. The database chosen to maintain these is user-determined.

newsgroup file

Keeps track of more static information about the newsgroups we are subscribed to - descriptions, creation dates, etc.

Watched over with News::GroupInfo.

archive directory

Directory structure of all articles, with each article saved as a single textfile within a directory structure laid out at one section of the group name per directory, such as "rec/games/mecha". Crossposts are hardlinked to other directory structures.

Articles are actually divided into sub-directories containing up to 500 articles, to avoid Unix directory size performance limitations. Individual files are thus stored in a file such as "rec/games/mecha/1.500/1".

Each newsgroup also contains overview information, watched over with
News::Overview. This overview file goes in the top of the structure,
such as "rec/games/mecha/.overview".

You may note that these files are very similar to how INN does its work. This is intentional - this package is meant to act in many ways like a lighter-weight INN.

Usage:

Global Variables

The following variables are set within News::Archive, and are global throughout all invocations.

$News::Active::DEBUG
Default value for "debug()" in new objects.

$News::Active::HOSTNAME
Default value for "hostname()" in new objects. Obtained using
"Sys::Hostname::hostname()".

$News::Active::HASH
The number of articles to keep in each directory. Default is 500;
change this at your own peril, since things may get screwed up later
if you change it after archiving any articles!

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::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.

Archive::Rar is a interface with the rar command.

SYNOPSIS

use Archive::Rar;
my $rar =new Archive::Rar();
$rar->Add(
-size => $size_of_parts,
-archive => $archive_filename,
-files => @list_of_files,
);

This is a module for the handling of rar archives.

Locates the rar command (from PATH or from regedit for Win32) and encapsulate it to create, extract and list rar archives.

At the moment these methods are implemented:

new()

Returns a new Rar object. You can pass defaults options.

Add(%options)

Add file to an archive.

Extract(%options)

Extract the contains of an archive.

List(%options)

Fill the list variable of the object whith the index of an archive.

OPTIONS

-archive

Archive filename.

-files

List of files to add. You can use a scalar value or an array reference.

-quiet

No output for the rar command if True.

-sfx

Create self-extracting archive.

-size

Size of the parts in bytes.

-verbose

Level of verbosity.

User::Identity::Archive is a base class for archiving user information.

INHERITANCE

User::Identity::Archive
is a User::Identity::Item

User::Identity::Archive is extended by
User::Identity::Archive::Plain

SYNOPSIS

use User::Identity::Archive::Plain;
my $friends = User::Identity::Archive::Plain->new(friends);
$friends->from(*FH);
$friends->from(.friends);

An archive stores collections. It depends on the type of archive how and where that is done. Some archivers may limit the kinds of selections which can be stored.