Free file shrinker software for linux

File Lister provides a Web interface for listing files and directories.

FileLister is meant to be an open source alternative for listing files/directories with an easy navigateable (web-)interface.

lxDVDshrink let you squeeze and backup your original DVDs to cheap one-layer DVD medium.

lxDVDshrink is fastnsimple DVD shrinker. It supports multi-title processing, arbitrary audio and subtitle tracks selection and, most of all, its a CONSOLE application! The recent gDVDshrink will become part of this package soon...

File::Searcher is a searches for files and performs search/replacements on matching files.

SYNOPSIS

use File::Searcher;
my $search = File::Searcher->new(*.cgi);
$search->add_expression(name=>street,
search=>1234 Easy St.,
replace=>456 Hard Way,
options=>i);
$search->add_expression(name=>department,
search=>(Dept.|Department)(s+)(d+),
replace=>$1$2$3,
options=>im);
$search->add_expression(name=>place,
search=>Portland, OR(.*?)97212,
replace=>Vicksburg, MI${1}49097,
options=>is);
$search->start;
# $search->interactive; SEE File::Searcher::Interactive
@files_matched = $search->files_matched;
print "Files Matchedn";
print "t" . join("nt", @files_matched) . "n";
print "Total Files:t" . $search->file_cnt . "n";
print "Directories:t" . $search->dir_cnt . "n";
my @files_replaced = $search->expression(street)->files_replaced;
my @files_replaced = $search->expression($expression)->files_replaced;
my %matches = $search->expression(street)->matches;
my %replacements = $search->expression(street)->replacements;

File::Searcher allows for the traversing of a directory tree for files matching a Perl regular expression. When a match is found, the statistics are stored and if the file is a text file a series of searches and replacements can be performed. File::Searcher has options that allow for backing-up / archiving files and has OO access to reporting and statistics of matches and replacements.

jsp File Browser is an easy to use and easy to install file browser java server page. This JSP program allows remote web-based file access and manipulation.
Main features:
- Create, copy, move, rename and delete files and directories
- View Files (pictures, movies, pdf, html,...)
- Edit textfiles
- Upload files to the server (Status via Upload monitor)
- Download files from the server
- Download groups of files and folders as a single zip file that is created on the fly
- Execute native commands on the server (e.g ls, tar, chmod,...)
- View entries and unpack zip, jar, war and gz files on the server
- Just one file, very easy to install (in fact, just copy it to the server)
- Customizable layout via css file
- Restrict file access via black or whitelist
It should work with any JSP1.1 compatible server(e.g. Tomcat>=3.0), I tested it on Tomcat 4.0, Resin 2.1.7 and Jetty.
Enhancements:
- A read-only version was added.
- It is now also usable as an upload-center.
- Some UI enhancements were made, like shortkeys and a better layout.
- It should also load a bit faster.

File::Where is a Perl module to find the absolute file for a program module; absolute dir for a repository.

SYNOPSIS

#######
# Subroutine interface
#
use File::Where qw(pm2require where where_dir where_file where_pm where_repository);

$program_module = is_module(@program_modules);
@program_modules = dir_pms( $dir );
@program_modules = program_modules( $dir, file_flag, @dirs);
$file = pm2require($pm);
@program_modules = repository_pms($repository);

$abs_file = where($relative_file);
$abs_file = where($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where($relative_file)
($abs_file, $inc_path, $rel_fle) = where($relative_file, @path);

$abs_dir = where($relative_dir, , nofile);
$abs_dir = where($relative_dir, @path, nofile);

($abs_dir, $inc_path, $rel_dir) = where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = where($relative_dir, @path, nofile);

$abs_dir = where_dir($relative_dir);
$abs_dir = where_dir($relative_dir, @path;
$abs_dir = where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);

$abs_file = where_file($relative_file);
$abs_file = where_file($relative_file, @path);
$abs_file = where_file($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where_file($relative_file)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)

$abs_file = where_pm($pm);
$abs_file = where_pm($pm, @path);
$abs_file = where_pm($pm, @path);

($abs_file, $inc_path, $require) = where_pm($pm);
($abs_file, $inc_path, $require) = where_pm($pm, @path);
($abs_file, $inc_path, $require) = where_pm($pm, @path);

$abs_dir = where_repository($repository);
$abs_dir = where_repository($repository, @path);
$abs_dir = where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);

#######
# Class interface
#
$program_module = File::Where->is_module(@program_modules);
@program_modules = File::Where->dir_pms( $dir );
@program_modules = File::Where->program_modules( $dir, file_flag, @dirs);
$file = File::Where->pm2require($pm);
@program_modules = File::Where->repository_pms($repository);


$abs_file = File::Where->where($relative_file);
$abs_file = File::Where->where($relative_file, @path);
$abs_dir = File::Where->where($relative_dir, , nofile);
$abs_dir = File::Where->where($relative_dir, @path, nofile);

($abs_file, $inc_path, $require) = File::Where->where($relative_file)
($abs_file, $inc_path, $require) = File::Where->where($relative_file, @path)
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, @path, nofile);

$abs_dir = File::Where->where_dir($relative_dir);
$abs_dir = File::Where->where_dir($relative_dir, @path;
$abs_dir = File::Where->where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);

$abs_file = File::Where->where_file($relative_file);
$abs_file = File::Where->where_file($relative_file, @path);
$abs_file = File::Where->where_file($relative_file, @path);

($abs_file, $inc_path, $require) = File::Where->where_file($relative_file)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)

$abs_file = File::Where->where_pm($pm);
$abs_file = File::Where->where_pm($pm, @path);
$abs_file = File::Where->where_pm($pm, @path);

($abs_file, $inc_path, $require) = File::Where->where_pm($pm);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);

$abs_dir = File::Where->where_repository($repository);
$abs_dir = File::Where->where_repository($repository, @path);
$abs_dir = File::Where->where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);

From time to time, an program needs to know the abolute file for a program module that has not been loaded. The File::Where module provides methods to find this information. For loaded files, using the hash %INC may perform better than using the methods in this module.

File::Signature is a Perl module to detect changes to a files content or attributes.

SYNOPSIS

use File::Signature;
my $sig = File::Signature->new(/some/file);

# If you have a stringified signature stored in $string
# you can create a File::Signature object from it.
my $sig = File::Signature->new_from_string($string);

if (my $err = $sig->error) {
warn $err, "n";
}
# You can use a signature object to re-check the same file.
if ( $sig->is_same() ) { print "Ok. The signature is the same.n" }
if ( $sig->changed() ) { print "Uh Oh! The signature has changed.n" }

my @digests = $sig->old_and_new(digest);
my @inodes = $sig->old_and_new(ino);
my @modes = $sig->old_and_new(mode);
my @uid = $sig->old_and_new(uid);
my @gid = $sig->old_and_new(gid);
my @mtime = $sig->old_and_new(mtime);

# A slightly more worthwhile use...
my @fields = $sig->changed();
for my $field (@fields) {
printf "$field was: %s but changed to %s.n",
$sig->old_and_new($field);
}

ABSTRACT

This perl library uses perl5 objects to assist in determining whether a files contents or attributes have changed. It maintains several pieces of information about the file: a digest (currently only MD5 is supported), its inode number, its mode, the uid of its owner, the gid of its group owner, and its last modification time. A File::Signature object is closely associated with a single pathname. It provides a way to compare the state of a file over different points in time; it isnt useful for comparing different files.

This module provides a way to monitor files for changes. It implements an object oriented interface to file "signatures." In the case of this module, a signature includes an MD5 digest (other digests may be added later), the files size, its inode number, its mode, its owners uid, its groups gid, and its mtime. This information is associated with a file by the files "pathname." The pathname is considered to be the files unique identifier. In reality, a file may have more than one pathname, but this module doesnt recognize that.

It will simply treat two differing pathnames as two different files, even if they refer to the same file. As this module checks whether a file changes over time, a minimal use of it would include the time when the signature was created and a different time when the signature is regenerated and compared with the previous one. The amount of time between these checks is arbitrary. This module makes it easy to save a signature object and then load it and check for consistency at a later time, whether seconds or years have passed.

VFU is console (text mode) file manager for UNIX/Linux.

During the years I tried to make short attractive list of features which VFU has. Attractive as Advertising above :) and it does not seem to work... at least it didnt for me and I never liked it.

I made all possible to make VFU cover all file managing needs and offer large set of behaviour options. If I succeeded or not, you can decide for yourself but without trying I believe noone can say for sure.

Installation:

1. how to compile vfu

run `make from vfu base directory

this should compile everything

to compile each part of vfu manually do this:

-- go to `vslib directory
-- run `make
-- go to `vfu directory
-- run `make

if something goes wrong, check these:

-- if your `curses.h file locations is not `/usr/include/ncurses
you have to change this in the Makefile.

-- if vslib library is not in the `../vslib directory you also
have to change this in the Makefile.

2. how to install vfu

run `install script from vfu base directory

install script checks if all required files are available/built and then does this:

cp vfu/vfu rx/rx_* /usr/local/bin
cp vfu.1 /usr/local/man/man1
cp vfu.conf /usr/local/etc

3. how to install vfu manually

-- you have to copy `vfu in the `/usr/local/bin or
`/usr/bin directory and set mode to 755 `rwxr-xr-x
the owner is not significant ( root is also possible ).

-- there is preliminary man page ( vfu.1 ) which could be
copied to /usr/man/man1.

-- copy all `rx/rx_* tools to /usr/local/bin
-- install Net::FTP perl module if needed.
(this is used for FTP support)

WARNING: make sure to remove all old personal cache files!