Free fast fingers software for linux

Fast Date Picker project is a calendar which is easy to integrate into pages that require the users to select a date like on travel sites.
Written in ECMAScript, it responds faster to the users clicks than most of the server-side-based or Java-applet-based date pickers often found on travel sites today.
The calendar can be added to your page any way you want (e.g. as a pop-up window or an expandable

Fast Secure File System exports existing directories securely over the network, letting users store and retrieve encrypted data in a scalable and transparent way. FSFS is written in C and works on GNU/Linux systems on x86 and PPC architectures, with help from FUSE and OpenSSL.
File systems are easily the most evident, from the point of view of users, component of an operating system. Through file systems it is possible to organize data in a wide variety of ways, and access resources through a common interface.
Users can nowadays not only store and retrieve documents, but also find information on running processes and system settings (through ProcFS), access and manipulate e-mail (for example with GmailFS), or perform several other operations.
In several circumstances and scenarios it is desirable to protect stored files and directories from manipulation by unknown or malicious users: financial or health-related data, confidential documents, or any kind of personal or sensitive data may need to be stored securely, in such a way that it can not be examined or modified freely by third parties.
Most file systems do not take action in this sense, and external cryptographic utilities are sometimes employed to secure data before storage. While this can be a perfectly secure solution, it is not transparent to users.
Distributed file systems propose efficient ways of accessing data remotely as if it resided on the local machine; when it comes to dealing with securely stored data as in the examples above, care must be taken to preserve confidentiality and integrity also during network transfer.
Not all distributed file systems accomplish this task, weakening the overall security of the system, or do so inefficiently, making it inconvenient for users.
FSFS is a secure, distributed file system in users space, written in C with much help from FUSE and OpenSSL. It lets users store and retrieve data securely and transparently, knowing that it is protected both on permanent storage devices and while in transit over the network.
It is also concerned with scalability, therefore separates data cryptography from the server, leaving it to the clients; this approach is similar to the one used in CFS, and opposite to those taken on by other secure file system solutions (like NFS on top of IPsec).
FSFS is written as a pair of user space daemons that act as client and server. Because of this, it needs no kernel support (unlike NFS over IPsec), save the FUSE loadable kernel module on clients, included in Linux since 2.6.14; servers dont use FUSE and depend only on user space OpenSSL libraries.
Servers export an existing file system (of virtually any kind) to clients over the network through two separate channels: a TLS connection set up with OpenSSL, and a clear channel. Requests from the clients to the servers are sent via the TLS socket, thus they are encrypted and authenticated, according to TLS v1 specifications, by the channel itself and decrypted on receipt, as they are usually very short and the relevant cryptography does not constitute a great overhead; simple server replies undergo the same process.
Cryptography in this case happens at both ends of the transmission.
In a distributed file system, large amounts of data may be transferred between clients and servers, thus encrypting and decrypting everything may become too cumbersome for both parties, and as more clients are added to the system the server may severely lose performance; moreover, file data should be stored encrypted anyway, so the cryptography could be moved to the clients, in such a way that each encrypts data before a write operation sends it over the network to the server, and decrypts it after a read retrieves it.
This way servers only deal with TLS details and can concentrate on serving client requests by doing the relevant I/O on the underlying, "physical" file system. As the data is already encrypted, it does not need to go through the TLS channel and the corresponding overhead, but can be sent via the clear channel, provided the messages are authenticated.
Enhancements:
- This release fixes two bugs. One bug related to socket creation and would cause problems on some systems (namely OpenSUSE 10.2). The other bug related to server configuration creation when using the Python configuration utilities. Users dont need to upgrade to this release if theyre not experiencing problems or are not using the Python configuration utilities.

Fast Logging Project for Snort is designed to gather alerts with payload from distributed snort sensors on a central server and to store them in a database (MySQL and PostgreSQL are supported).
On the sensor, the output is written to a process called sockserv. This process is threaded; one thread receives and buffers the alert packets, and the other thread forwards them to a central server.
The output is decoupled from snort, which can proceed in sniffing instead of waiting for the output plugins. At the central server, a process called servsock gathers all alerts from the remote sensors and feeds them to the database.
A short description of alerts with high priority together with the database ID can be sent via email to a list of recipients.
Main features:
- Decoupling of the output from snort. Snort can work on new packets instead of processing the output.
- Buffering of alerts on the sensor. This is useful if you have a shortage on your network to the central server or the servsock process on the central server is not running (maybe it will be restarted due to a change to a newer version...)
- Buffering of alerts on the central server. It is not uncommon that the database (especially MySQL) is hanging during a high input rate or the rate is faster than the database is able to store.
- Fast writing to the database via an unix domain socket.
- E-Mail alerting on high priority alerts.
- Drop feature for the worst case. At least the basic alert informations are still available either via E-Mail or on stdout/syslog.
- Since version 1.0.6 the alerts which should be dropped on the central server if servsock exits are written to a swap file. So this data is still availabe.
- If alerts have to been dropped because the high water mark was reached then these data are not written to the swap file.
Enhancements:
- Several checks were added, the alert data from Snort got a tag, and a restart of Snort is now checked.
- getpacket now has base 64 support.
- The statistics are now generated via the control thread so some signals are no longer necessary.
- The exit handler was rewritten and a cache for signatures was added.
- This cache can accelerate the insert rate by up to a factor of two and is implemented as a red black tree.
- During runtime, the only SELECT statement is for the signature ID, and all other operations are INSERT statements.
- The idea is to cache all signatures that caused an alert.

Fast Messaging Peer to Peer (FM P2P) is a simple P2P program that forms a TCP-based overlay network by which a user may chat or share files.

Why name this FastMessaging when its anything but fast? Simply put, it is a reference to the underlying functioning of the application. TCUP, the protocol used to do the overlay network (the network we build ontop of an existing TCP/IP network) is message based.

We think it is Fast because there is no queueing or long searches. FastMessaging is built to construct moderately sized networks which have reasonably high responsiveness at the cost of global information sharing.

Perhaps thats not the best reasoning, but it works. Its just a name and the application needs a better name anyway. For now I just refer to it as FM.

ROX Filer is a fast and powerful graphical file manager.

It has full drag-and-drop support and background file operations, and is highly configurable.

FAPG is a tool to generate list of audio files (WAV, MP3, Ogg, etc.) in various formats (M3U, PLS, HTML, etc). It is very useful for quickly creating a playlist of a large number of audio files.

It is coded in C to be as fast as possible, and does not use any specific audio library (like ID3Lib).
This allow you to deploy it faster and easier, and to have better performances since the less informations are loaded.
In the other hand, this tool is not (yet) compatible with all the known formats.

Here are some examples for usage :

Generate a PLS playlist for an album :
fapg --format=pls --output=~/path/to/album/list.pls ~/path/to/album

You have a file server using Samba which shares a large amount of audio files for Windows powered computers using Winamp.
The directory on the server containing the files is "/samba/mp3" and is visible on the Windows network as "serveurmp3" :
fapg --backslash --output=/samba/mp3/list.m3u --prefix=servermp3 --recursive --windows /samba/mp3

An HTML playlist for an album :
fapg --output=fapg.html ~/path/to/album
Here is the result : fapg.html