Free files software for linux

Enterprise File Exchange (EFX) slots in where email file attachment limits stop your users from sending those important files to a contact.

In the EFX world, the user visits the EFX site, uploads the file, enters the receivers email address and lets the system notify the receiver that theres a file waiting for them, via a simple email message.

Senders need to sign up, and the EFX system only allows transfers between internal users (those with addresses in an approved list) and external users, never external to external.

It is written in Python, using the Pylons framework.

This project is licensed under the GNU GPL version 3.

File::DirCompare is a Perl module to compare two directories using callbacks.

SYNOPSIS

use File::DirCompare;

# Simple diff -r --brief replacement
use File::Basename;
File::DirCompare->compare($dir1, $dir2, sub {
my ($a, $b) = @_;
if (! $b) {
printf "Only in %s: %sn", dirname($a), basename($a);
} elsif (! $a) {
printf "Only in %s: %sn", dirname($b), basename($b);
} else {
print "Files $a and $b differn";
}
});

# Version-control like Deleted/Added/Modified listing
my (@listing, @modified); # use closure to collect results
File::DirCompare->compare(old_tree, new_tree), sub {
my ($a, $b) = @_;
if (! $b) {
push @listing, "D $a";
} elsif (! $a) {
push @listing, "A $b";
} else {
if (-f $a && -f $b) {
push @listing, "M $b";
push @modified, $b;
} else {
# One file, one directory - treat as delete + add
push @listing, "D $a";
push @listing, "A $b";
}
}
});

File::DirCompare is a perl module to compare two directories using a callback, invoked for all files that are different between the two directories, and for any files that exist only in one or other directory (unique files).
File::DirCompare has a single public compare() method, with the following signature:

File::DirCompare->compare($dir1, $dir2, $sub, $opts);

The first three arguments are required - $dir1 and $dir2 are paths to the two directories to be compared, and $sub is the subroutine reference called for all unique or different files. $opts is an optional hashref of options - see OPTIONS below.

The provided subroutine is called for all unique files, and for every pair of different files encountered, with the following signature:

$sub->($file1, $file2)

where $file1 and $file2 are the paths to the two files. For unique files i.e. where a file exists in only one directory, the subroutine is called with the other argument undef i.e. for:

$sub->($file1, undef)
$sub->(undef, $file2)

the first indicates $file1 exists only in the first directory given ($dir1), and the second indicates $file2 exists only in the second directory given ($dir2).

File::Comments is a Perl module that ecognizes file formats and extracts format-specific comments.

SYNOPSIS

use File::Comments;

my $snoop = File::Comments->new();

# *----------------
# | program.c:
# | /* comment */
# | main () {}
# *----------------
my $comments = $snoop->comments("program.c");
# => [" comment "]

# *----------------
# | script.pl:
# | # comment
# | print "howdy!n"; # another comment
# *----------------
my $comments = $snoop->comments("script.pl");
# => [" comment", " another comment"]

# or strip comments from a file:
my $stripped = $snoop->stripped("script.pl");
# => "print "howdy!n";"

# or just guess a files type:
my $type = $snoop->guess_type("program.c");
# => "c"

File::Comments guesses the type of a given file, determines the format used for comments, extracts all comments, and returns them as a reference to an array of chunks. Alternatively, it strips all comments from a file.

Currently supported are Perl scripts, C/C++ programs, Java, makefiles, JavaScript, Python and PHP.

The plugin architecture used by File::Comments makes it easy to add new formats. To support a new format, a new plugin module has to be installed. No modifications to the File::Comments codebase are necessary, new plugins will be picked up automatically.

File::Comments can also be used to simply guess a files type. It it somewhat more flexible than File::MMagic and File::Type. File types in File::Comments are typically based on file name suffixes (*.c, *.pl, etc.). If no suffix is available, or a given suffix is ambiguous (e.g. if several plugins have registered a handler for the same suffix), then the files content is used to narrow down the possibilities and arrive at a decision.

WARNING: THIS MODULE IS UNDER DEVELOPMENT, QUALITY IS ALPHA. IF YOU FIND BUGS, OR WANT TO CONTRIBUTE PLUGINS, PLEASE SEND THEM MY WAY.

File::PathList is a Perl module that can find a file within a set of paths (like @INC or Java classpaths).

SYNOPSIS

# Create a basic pathset
my $inc = File::PathList->new( @INC );

# Again, but with more explicit params
my $inc2 = File::PathList->new(
paths => @INC,
cache => 1,
);

# Get the full (localised) path for a unix-style relative path
my $file = "foo/bar/baz.txt";
my $path = $inc->find_file( $file );

if ( $path ) {
print "Found $file at $pathn";
} else {
print "Failed to find $filen";
}

Many systems that map generic relative paths to absolute paths do so with a set of base paths.

For example, perl itself when loading classes first turn a Class::Name into a path like Class/Name.pm, and thens looks through each element of @INC to find the actual file.

To aid in portability, all relative paths are provided as unix-style relative paths, and converted to the localised version in the process of looking up the path.

File is the open source implementation of the file command used on almost every free operating system (OpenBSD, Linux, FreeBSD, NetBSD) and also on systems that use free software (including OS/2, DOS, MS Windows, etc.).

The file command, if youre not familiar with it, is a command-line tool that tells you in words what kind of data a file contains. Unlike MS-Windows, UNIX and other systems dont rely on filename extentions to tell you the type of a file, but look at the files actual contents. This is, of course, more reliable, but requires a bit of I/O.

The original file command shipped with Bell Labs UNIX but was unavailable in source form to the masses before Ians reimplementation.

This file command (and magic file) was originally written by Ian Darwin (who still contributes occasionally) and is now maintained by a group of developers lead by Christos Zoulas.

Whos using it?

Every known BSD distribution (FreeBSD, NetBSD, OpenBSD, Darwin/Mac OS X, etc)
Every known Linux distribution
The Apache httpd server mod_mime_magic module uses the file commands innards to make file type guessing more reliable under Apache HTTPD.

File-center is a simple Web application to download and upload files. Its interface is very simple, and the scripts to download and upload are simple too.

File-center uses the PATH_INFO to pass the name of the directory or of the file in the URL.