Free fifo software for linux

Network FIFO project is a network object that provides data transfering tunnel across network in first in/first out manner.

Simply put,

fifo server file is: monotech_fifo.pl
This script require Net::Server::NonBlocking at least 4.1(you can grab from CPAN)

% perl monotech_fifo.pl < address > < port >

and itll show up like this:

[root@WongWai monotech_fifo]# perl monotech_fifo.pl 192.168.3.52 12000
Listen on 192.168.3.52:20005
Listen on 192.168.3.52:12000

12000 is the port in which the fifo resides.
20005 is the port in which backoffice management resides.

--------------------------------------------------

port 20005 in which the management control resides can be accessed by "admin.pl"

% perl admin.pl < address >

for example

perl admin.pl 192.168.3.52

itll show something like this:

message>

where you can type some commands and press enter

the commands are:

message>readers
message>flush

(flush is the command that read all socket buffer of the admin client socket)

to show all reader in the fifo, it is very useful when some reader is connection disconnected by his ISP or readers machine hangs, the fifo will hold his connection forever (It is because the monotech_fifo.pl doesnt set SO_KEEPALIVE and TCP_KEEPALIVE which will be fixed in the future)

and

message>kill_reader[tab]< fifo name >

to kill any connection of < fifo name >

This package is heavily used by my company, so it is likely reliable.

ShmFIFO library provides an easy-to-use interface to shared memory for programs where one process needs to send blocks of data to other processes.

It was developed because pipe(2) and mkfifo(3) have a very small buffer size (4k) and are unsuitable for many applications. Shmfifo allows you to put a block of data in shared memory, get the oldest block of data from shared memory.

ShmFIFO library also has the feature to share one instance of a private data structure among all processes which use the library.

How to use shmfifo

Before using, shared memory should be created. After creating shared memory, process which wants to use it, should attach to memory. Then it can put and get blocks to FIFO. After process is finished working with FIFO, it calls shfifo_detach. When no processes will use FIFO, shared memory should be deallocated.

Usally, lifecycle of shmfifo-based program is following:

[parent] shmfifo_create
[parent] fork(2)
[both] shmfifo_attach
[both] shmfifo_put, shmfifo_get (many times)
[both] shmfifo_detach
[parent] wait(2) or waitpid(2)
[child] exit
[parent] shmfifo_dealloc

shmfifo comes with test.c program, which is good sample of how to write programs with shmfifo. It forks into 2 processes, parent generated variable-length blocks, writes checksum into each block and put it into FIFO. Child gets blocks from fifo, check if checksum is valid (its always valid if there is no bug in program) and prints debug info. after large number of blocks gets transferred, both processes are exit.

Additionally, shmfifo allows processes to share one private structure. test.c uses this structure to store counter, which is increased each time when parent cannot put block to FIFO because its already full and has to wait until child will get block. If small amount of memory allocated for FIFO, then parent will wait more often.

Installation:

make
make test
su -
make install

test.c is sample test program which is builts into test binary. You can run it to test if library is working

Authfail is a program that goes with real time updating on FIFO file and adds IP into netfilter with DROP/REJECT policy in real time. The FIFO file is /dev/authfail. The rejected hosts database is located in /var/log/authfail.
Each time a given host will do an "authentication failure" via syslog, authfail will count it. If this occure more than the parameters given to authfail, the given host will be REJECTED/DROPPED via Netfilter. Whois notification is possible.
authfail may be configured using the /etc/authfail.conf file.
The program is written under the GNU GPL Public License.
Enhancements:
- The Setup.pl file was modified to not notify private RFC 1918 networks during the setup process.

Syslog is a almost standard UN*X daemon which gathers all the info, errors or critical messages from the local computer or other hosts on the network. For more info about syslog itself, see the corresponding syslog manpages.
Before using Interceptor, you must create 8 fifo files in /var/run/interceptor, (debug, info, notice, warning, err, crit, alert, emerg) and modify the /etc/syslog.conf so that syslog sends its messages in the corresponding fifo for a given level, e.g.
*.debug |/var/run/interceptor/debug
The mkintfifos included script will update /etc/rc.d/rc.sysinit and /etc/syslog.conf for you. When done, restart your computer, install the interceptor applet and load it on the taskbar.
A button appears, which will flash green when a debug, info or notice message occurs, orange when a warning or error message occurs and red when crit, alert or emerg.
If you click on this button, a list of received messages will be displayed.
Interceptor can react to some messages according to a pattern->action scheme with up to 2 argument strings. The available actions are the following ones:
- Beep: Simply issues a beep.
- Message: Displays a dialog box with first arg string as the wanted message and optionnaly executes a shell command when the yes button is clicked. The command itself is contained in the second arg string.
- Redirect: Redirects the current message towards a specific log view.
- Run: Silently runs a shell command contained in arg string 2 and appends arg string 1 at the end of the system messages list.
Remark: if the first argument of a Run alert is null, the first line of the shell command stdout is appended to the messages list, with Info as the level and Interceptor as the source.
The pattern rules obey to the QRegExp syntax. See QRegExp in the Qt documentation for more details. In addition to the standard QRegExp syntax, Interceptor uses pattern groups, i.e. it can retrieve substring enclosed in group parenthesis. Example:
abc(.+)def
This group contains any string enclosed within abc and def. A substitution is made whenever a message matches with a given regexp. The variables $1, $2, $3 and $4 will be replaced with the corresponding pattern group in both arg 1 and arg 2 strings.
the variables $D and $T will be substituted with the current date and time
The patterns are tried against the
level##source!!host%%text
string, where level is debug, info etc..., source is the info source, i.e. kernel, the daemon name, lpr etc..., host is the hostname and text, the text of the message.
You can also choose a better suited icon, such as floppy, network or CDROM icons, for your dialog boxes.
When you select the preferences kicker applet menu, a tab widget will appears, which will allow you to edit the pattern->action rules, and some default options, such as the level colors and number of lines on the messages list box.
Enhancements:
- Aspects Scan list.
- A few bugs fixed.

Wily::Connect is a Perl module that connects to a running Wily text editor.

SYNOPSIS

use Wily::Connect;
my $wily_socket = Wily::Connect::connect();

The connect sub connects to wily this involves creating a unix domain socket, listening on that socket, writing the name of that socket to the fifo wily is reading from (either $ENV{WILYFIFO} or if that doesnt exist /tmp/wily[login]$ENV{DISPLAY}, and then accepting the connection to the unix domain socket that wily will make.

The functions does all of that and hence may block while waiting for wily.

File::Stat::Bits - stat bit mask constants.

SYNOPSIS:

use File::stat;
use File::Stat::Bits;

my $st = stat($file) or die "Cant stat $file: $!";

if ( S_ISCHR($st->mode) ) {
my ($major, $minor) = dev_split( $st->rdev );

print "$file is character device $major:$minorn";
}

printf "Permissions are %04on", $st->mode & ALLPERMS;

(Too many S_IF* constants to example)

Lots of Perl modules use the Unix file permissions and type bits directly in binary form with risk of non-portability for some exotic bits. Note that the POSIX module does not provides all needed constants and I cant wait when the POSIX module will be updated.

This separate module provides file type/mode bit and more constants from sys/stat.ph and sys/sysmacros.ph without pollution callers namespace by other unneeded symbols from these headers. Most of these constants exported by this module are Constant Functions (see perlsub).

Since some of Perl builds does not include these converted headers, the build procedure will generate it for itself in the its own lib directory.

This module also should concentrate all portability and compatibility issues.

CONSTANTS

File type bit masks (for the st_mode field):

S_IFMT bitmask for the file type bitfields
S_IFDIR directory
S_IFCHR character device
S_IFBLK block device
S_IFREG regular file
S_IFIFO fifo (named pipe)
S_IFLNK symbolic link
S_IFSOCK socket
=cut

sub S_IFMT () { File::Stat::Bits::dirty::S_IFMT () }
sub S_IFDIR () { File::Stat::Bits::dirty::S_IFDIR () }
sub S_IFCHR () { File::Stat::Bits::dirty::S_IFCHR () }
sub S_IFBLK () { File::Stat::Bits::dirty::S_IFBLK () }
sub S_IFREG () { File::Stat::Bits::dirty::S_IFREG () }
sub S_IFIFO () { File::Stat::Bits::dirty::S_IFIFO () }
sub S_IFLNK () { File::Stat::Bits::dirty::S_IFLNK () }
sub S_IFSOCK() { File::Stat::Bits::dirty::S_IFSOCK() }


File access permission bit masks (for the st_mode field):

S_IRWXU mask for file owner permissions
S_IRUSR owner has read permission
S_IWUSR owner has write permission
S_IXUSR owner has execute permission
S_ISUID set UID bit

S_IRWXG mask for group permissions
S_IRGRP group has read permission
S_IWGRP group has write permission
S_IXGRP group has execute permission
S_ISGID set GID bit

S_IRWXO mask for permissions for others
S_IROTH others have read permission
S_IWOTH others have write permisson
S_IXOTH others have execute permission
S_ISVTX sticky bit

Common mode bit masks:

ACCESSPERMS 0777
ALLPERMS 07777
DEFFILEMODE 0666
=cut

sub S_IRWXU() { File::Stat::Bits::dirty::S_IRWXU() }
sub S_IRUSR() { File::Stat::Bits::dirty::S_IRUSR() }
sub S_IWUSR() { File::Stat::Bits::dirty::S_IWUSR() }
sub S_IXUSR() { File::Stat::Bits::dirty::S_IXUSR() }
sub S_ISUID() { File::Stat::Bits::dirty::S_ISUID() }

sub S_IRWXG() { File::Stat::Bits::dirty::S_IRWXG() }
sub S_IRGRP() { File::Stat::Bits::dirty::S_IRGRP() }
sub S_IWGRP() { File::Stat::Bits::dirty::S_IWGRP() }
sub S_IXGRP() { File::Stat::Bits::dirty::S_IXGRP() }
sub S_ISGID() { File::Stat::Bits::dirty::S_ISGID() }

sub S_IRWXO() { File::Stat::Bits::dirty::S_IRWXO() }
sub S_IROTH() { File::Stat::Bits::dirty::S_IROTH() }
sub S_IWOTH() { File::Stat::Bits::dirty::S_IWOTH() }
sub S_IXOTH() { File::Stat::Bits::dirty::S_IXOTH() }
sub S_ISVTX() { File::Stat::Bits::dirty::S_ISVTX() }

sub ACCESSPERMS() { S_IRWXU|S_IRWXG|S_IRWXO }
sub ALLPERMS() { S_ISUID|S_ISGID|S_ISVTX|ACCESSPERMS }
sub DEFFILEMODE() { S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH }

FUNCTIONS

File type test macros (for the st_mode field):

S_ISDIR ( mode ) directory?
S_ISCHR ( mode ) character device?
S_ISBLK ( mode ) block device?
S_ISREG ( mode ) regular file?
S_ISFIFO( mode ) fifo (named pipe)?
S_ISLNK ( mode ) is it a symbolic link?
S_ISSOCK( mode ) socket?

All returns boolean value.


$major = major( $st_rdev )

Returns major device number of st_rdev


$minor = minor( $st_rdev )

Returns minor device number of st_rdev


($major, $minor) = dev_split( $st_rdev )

Splits st_rdev to major and minor device numbers


$st_rdev = dev_join( $major, $minor )

Makes st_rdev from major and minor device numbers (makedev())

Licq is a multi-threaded ICQ clone written mostly in C++. Licq project uses an extensive plugin system to manage many different functions.
The main gui is written using the Qt widget set. Licq is distributed under GPL with some special QPL exceptions for Qt.
Development is very ongoing, with new features and bugs fixed frequently, so updates are available often. The current version should be very stable, but as with all software use it at your own risk.
Main features:
- Contact List - fully functionning online/offline user list with pixmaps and everything.
- Messages - send and receive messages both online and offline through the server. Send in color too.
- Chat - chat with other users in regular and multiparty mode, set/see colors/fonts and save chat session.
- File transfer - batch transfer files to and from other icq users.
- URL - send and receive URLs from other users.
- Status - set status to any of the available ones, set and retrieve away message.
- User info - retrieve and update all user and personal information.
- Whitepages - full support for General/More/Work/About info as well as searches based on this info.
- History - keeps a log of all messages to and from a user.
- Add/remove and edit user information from within the program.
- Invisible list - be invisible to some users all the time.
- Visible list - be visible to some users when you are in invisible mode.
- Online user notification - have a sound played when a specific user goes online
- Last seen online - shows the last time youve seen this user online
- Local time - displays the local time for the user
- Away-to-User - be a different status to particular users
- Accept-in-Away - automatically accept events from certain users in certain statuses
- Send contact lists - send a list of users to other users
- Search - full support for searching by email/uin/alias/whitepages
- Random chat - find random users (and be found)
- Server stored contacts - keep your groups and users stored on the server
- Typing notification - see when the remot use is typing a message to you
- Phone book - keep track of users phone numbers, and yours
- User pictures - see the picture of the user, if they have one available
- Proxy support - HTTPS proxy support to connect through a proxy server
New Features:
- User groups - organize your users into groups.
- Network monitor window - allows you to see the actual data being sent and received from mirabilis and other users.
- Themed Docking - dock Licq using one of many different icon themes
- Skin and icon pack support to make the qt-gui look like anything including transparent contact list
- Customizable - allows full customization of colors, fonts, sizes and pixmaps for the contact list.
- FIFO support for remotely controlling your licq session
- Extensive utility support to add many new features.
- Extensible OnEvent system for playing sounds or running programs when messages arrive, passing user specific information as arguments.
- Plugin system allows for multiple possible GUIs, protocols, and other things.
- International support with Unicode and translations
- Fully multi-threaded for faster response and fewer slowdowns.
- User floaty windows
- Send urgent or to contact list with a single click
- Always use the correct ip even if hostname is not set correctly
- Option to flash all or just urgent incoming events
- Accept modes for when to use OnEvents
- Auto-raise and auto-popup incoming messages
- Per-user customized auto responses
- Statistics of how many messages you have sent & received and more
- Tabbed chatting
- SSL secure client to client connections
- GPG encrypted messages

DarkSnow is a darkice GUI, it is very simple and its written using GTK2, by Rafael Diniz, under GPLv2.
Enhancements:
- This release adds an AAC format option (needs darkice 0.16).
- It changes the way that darksnow gets the darkice output (now it uses FIFO).
- A memory leak has been fixed and some minor improvements made.