Free files without having software for linux

fileschanged is a GNU/Linux command-line utility that reports when files have been altered.

This software is a client to the FAM (File Alteration Monitor) server that is now available in some distributions. Heres how the fileschanged FAM client works: you give it some filenames on the command line and then it monitors those files for changes.

When it discovers that a file has changed (or has been altered), it displays the filename on the standard-output.

Heres what the usage looks like:

Usage: fileschanged [OPTION...] [FILE]...
Monitors FILEs for alterations. Display the filenames of FILEs that were created, changed, deleted, started execution or finished executing.

-s, --show=EVENT[,...] Display created, changed, deleted, executing, or
executed files (Default is "created,changed"
-a, --show-all Display all file events and the associated action
-f, --files-to-monitor (Default) Monitor the FILEs on the command line
-l, --filelist=FILE Monitor the list of filenames inside FILE
-r, --recursive Monitor subdirectories of directories
-t, --timeout=N Delay showing changed files for N seconds (Def=2)
-p, --display-action Display action when showing altered files
-x, --exec=PROG Run PROG when file altered (PROG action filename)
-?, --help Give this help list
--usage Give a short usage message
-V, --version Print program version

FILEs must exist when monitoring begins, or they will not be monitored.

File::Util is an easy, versatile, portable file handling module.

File::Util provides a comprehensive toolbox of utilities to automate all kinds of common tasks on file / directories. Its purpose is to do so in the most portable manner possible so that users of this module wont have to worry about whether their programs will work on other OSes and machines.

SYNOPSIS

use File::Util;
my($f) = File::Util->new();

my($content) = $f->load_file(foo.txt);

$content =~ s/this/that/g;

$f->write_file(
file => bar.txt,
content => $content,
bitmask => 0644
);

$f->write_file(
file => file.bin, content => $binary_content, --binmode
);

my(@lines) = $f->load_file(randomquote.txt, --as-lines);
my($line) = int(rand(scalar @lines));

print $lines[$line];

my(@files) = $f->list_dir(/var/tmp, qw/ --files-only --recurse /);
my(@textfiles) = $f->list_dir(/var/tmp, --pattern=.txt$);

if ($f->can_write(wibble.log)) {

my($HANDLE) = $f->open_handle(
file => wibble.log,
mode => append
);

print $HANDLE "Hello World! Its ", scalar localtime;

close $HANDLE
}

my($log_line_count) = $f->line_count(/var/log/httpd/access_log);

print "My file has a bitmask of " . $f->bitmask(my.file);

print "My file is a " . join(, , $f->file_type(my.file)) . " file."

warn This file is binary! if $f->isbin(my.file);

print "My file was last modified on " .
scalar localtime($f->last_modified(my.file));

# ...and _lots_ more

Twibright Twig is an image gallery program. You have a directory with subdirectory structure with images. Twig generates for each image 3 levels of diminished images and 3 level of thumbnails.

Twig keeps a clickable structure of HTML files, each directory has an own HTML page with listing and each file has own HTML page with links to various sizes of the images under thumbnails and with EXIF information and image comment.

Twig can work with JPG and PNG images. Maybe also with GIFs but I am not sure.

If you change anything in the gallery (add directories, files, change files, delete files), you just need to rerun the "regen" script. Twig automatically detects all changes and updated in the HTML structure. Thumbnails and scaled down images are automatically regenerated if needed. Most time-intensive work is however not done if not necessary.

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.

kfilewatcher project watches for file changes and allows you to react on them.

Example:

kfilewatcher /tmp/test 2>&1 | while read a; do echo "File has changed - doing something"; done

This command does something every time kfilewatcher detects a change. At the moment, the only action is to output "File has changed - doing something", but you can write anything there, e.g.

- backup stuff as soon as it changes
- publish files on your homepage everytime they change
- keep directories in sync

paFileDB is a script that allows webmasters to have a database of files for download on their site.
paFileDB is designed to allow webmasters have a database of files for download on their site. To add a download, all you do is upload the file using FTP or whatever method you use, log into paFileDBs admin center, and fill out a form to add a file. paFileDB lets you edit and delete the files too.
No more messing with a bunch of HTML pages for a file database on your site! Using speedy MySQL for storing data, and powerful PHP for processing everything, paFileDB is one of the best and easiest ways to manage files!
Main features:
- MySQL Backend
- Categories and Subcategories
- Password-Protected Admin Center with Multiple Admin Accounts
- Counting of Downloads
- Search Database
- Post Icons
- License Agreements Before Downloading
- Template system
- Language Files
- Custom Fields
- View All Files Option
- Rate Files Option
- File Mirrors
- Broken Link Reporting
- File Commenting System
- User Registrations
- File Tagging
- Ability to add Top Downloaded Files and New Files lists on your site (Please download the toplist plugin here to add this functionality.)

File System development is very difficult and time consuming. Even small changes to existing file systems require deep understanding of kernel internals, making the barrier to entry for new developers high.

Moreover, porting file system code from one operating system to another is almost as difficult as the first port. Past proposals to provide extensible (stackable) file system interfaces would have simplified the development of new file systems.

These proposals, however, advocated massive changes to existing operating system interfaces and existing file systems; operating system vendors and maintainers resist making any large changes to their kernels because of stability and performance concerns. As a result, file system development is still a difficult, long, and non-portable process.

The FiST (File System Translator) system combines two methods to solve the above problems in a novel way: a set of stackable file system templates for each operating system, and a high-level language that can describe stackable file systems in a cross-platform portable fashion.

Using FiST, stackable file systems need only be described once. FiSTs code generation tool, fistgen, compiles a single file system description into loadable kernel modules for several operating systems (currently Solaris, Linux, and FreeBSD).

The project demonstrates that with FiST, code size and development time are reduced significantly, while imposing a small performance overhead of only 1-2%. These benefits are achieved, as well as portability, without changing existing operating systems or file system.

sitecopy allows you to easily maintain remote Web sites.
The program will upload files to the server which have changed locally, and delete files from the server which have been removed locally, keeping the remote site synchronized. FTP and WebDAV are supported.
Enhancements:
- This release adds support for client certificates in DAV and neon 0.26.