pipe
Zip 2.32
Zip is a compression and file packaging utility for Unix, VMS, DOS, OS/2, Windows 9x/NT, Amiga, Atari, Macintosh. more>>
Zip is analogous to a combination of the Unix commands tar(1) and compress(1) and is compatible with PKWAREs PKZIP and Nico Maks WinZip. Its part of the Info-ZIP project.
Main features:
- creating zipfiles in a pipe or on a device
- VMS and OS/2 extended file attributes
- conversion between Unix, MS-DOS and Macintosh text file formats
- the ability to run on most of your favorite operating systems.
Enhancements:
- fixed -R operation to match the supplied file patterns in all recursed subdirectories, like PKZIP 2.04 "-p -r" (or PKZIPC 4+ "-recurse")
- handle cases where -x, -R, and -i patterns are mixed
- new example C-Sharp code for using DLLs
- added some directory-search speedups
- fixed bug when encrypting large uncompressible files
- fixed Windows NTFS time problem
- fixed VMS logical name parse problem
- added VMS DEBUG option
- updated VMS help
- fixed selection of files to delete by date
- added -MM option where each input file pattern must match at least one file and all input files must be readable
- added check for when Zip tries to exceed seek limit in output file
- minor changes to compile with Visual C++ 2005
- added support for Unix FIFOs (named pipes)
- other minor fixes
Pipe Viewer 1.0.1
Pipe Viewer is a pipeline data transfer meter. more>>
It can be inserted into any normal pipeline between two processes to give a visual indication of how quickly data is passing through, how long it has taken, how near to completion it is, and an estimate of how long it will be until completion.
pv is now considered to be stable code: it appears to work reliably on systems it has been tested on.
Pipe-Sem 1.0
This is a pipe based semaphore implementation for developing ASYNC applications. more>>
Pipe-Sem 1.0 is a good utility which might help you a lot in developing ASYNC applications. Many synchronization primitives are available for Unix systems, but any of them expose a pollable interface to the user. In these cases, if the caller execute a down operation on a blocking semaphore, the application will sleep and whole ASYNC loop will starve because of the wait.
To cope with this problem in ASYNC software, the publisher developed a pipe based semaphore implementation, called Pipe-Sem. The implementation is trivially simple and it uses the pipe internal mechanisms to expose a pollable wait interface.
Besides the standard semaphore operations, the function psem_down_fd() can be used to retrieve a files descriptor that can be dropped inside a Unix pollable API like select(2), poll(2) or epoll(2). The caller will have to wait for input events (POLLIN), and when receiving the event itself, the caller should invoke the psem_try_down() function to try to acquire the semaphore.
Please note that receiving an event from the pollable interface, does not mean that we acquired to semaphore, and the function psem_try_down() will have to be called (and tested for zero return code) to correctly complete the down operation.
<<lessIO::Pipe::Producer 1.5
IO::Pipe::Producer is a Perl module that provides two modules getSubroutineProducer and getSystemProducer. more>>
SYNOPSIS
# Module which provides 2 methods: getSubroutineProducer
# and getSystemProducer. They take a subroutine reference
# (with associated arguments) and a system call
# respectively and return (blessed) handles on their
# streaming standard output and standard error output.
# EXAMPLES of usage
use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
$stdout_fh =
$obj->getSubroutineProducer($subroutine_reference,
@subroutine_parameters);
# OR
use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
($stdout_fh,$stderr_fh) =
$obj->getSubroutineProducer($subroutine_reference,
@subroutine_parameters);
# OR
use IO::Pipe::Producer;
$stdout_fh = new IO::Pipe::Producer($subroutine_reference,
@subroutine_parameters);
# OR
use IO::Pipe::Producer;
($stdout_fh,$stderr_fh) =
new IO::Pipe::Producer($subroutine_reference,
@subroutine_parameters);
# Then you can read the returned handles like any other
# file handle...
while()
{print "STDOUT From Producer: $_"}
while()
{print "STDERR From Producer: $_"}
# You can also do the same thing with system calls using
# the getSystemProducer subroutine. However, this feature
# is not accessible via the new constructor
use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
$stdout_fh =
$obj->getSystemProducer("echo "Hello World!"");
use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
($stdout_fh,$stderr_fh) =
$obj->getSystemProducer("echo "Hello World!"");
# However, this is exactly the same as:
use IO::Pipe::Producer;
$stdout_fh = new Producer(sub{system(@_)},
"echo "Hello World!"");
# OR
use IO::Pipe::Producer;
($stdout_fh,$stderr_fh) =
new IO::Pipe::Producer(sub{system(@_)},
"echo "Hello World!"");
xmms-pipe 0.5.5
xmmspipe is a plugin for XMMS that enables it to be controlled by sending strings to a named pipe (FIFO). more>>
echo play_pause > ~/.xmms/inpipe
will cause XMMS to pause or play.
Since version 0.5.0, it is possible to setup an output pipe, and query XMMS for information. For example, sending "report title" to the input pipe will cause the current songs title to be printed on the output pipe.
Included is a demo program called "fade", that shows how to use the plugin to fade the current song and advance to the next one. It requires the output pipe to be be enabled (via the Config window).
The Infopipe plugin does output pipes a little differently.
When I first wrote this plugin, I didnt know about other programs that I couldve used to control XMMS with shell scripts, such as xmmsctrl or xmms-shell. However, Ive kept xmmspipe alive because pipes may be preferable in some situations:
The pipe automatically inherits the security features of the underlying filesystem (e.g. you could change its permissions so that only users of a particular group can control XMMS).
In many programming languages, writing to a pipe is easier than executing programs, making it easier to build programs to control XMMS.
The plugin can call internal XMMS functions which means it can have more functionality than programs relying on the xmms_remote_* functions alone. For example, XMMSPipe can load/save playlists.
Sometimes I think XMMS itself should just be an MP3-playing daemon that interfaces with the outside world exclusively through pipes (one for input, at least one for output). This would allow a lot more flexibility, e.g. the GUI could be arbitrary and playlists could be managed by an external program. (It would work in the same way gkrellm works with files in /proc.) Also, the code would be simpler because it only has to worry about reading various audio formats and playing them. It wouldnt have to deal with window managers, X, etc.
Enhancements:
- Added playlist_move command due to Graeme Yeo
Simple UDP proxy/pipe 0.3
Simple UDP proxy/pipe is an advanced UDP proxy/datapipe/packets forwarder and modifier with multiple functions. more>>
Multiple clients allowed (you can connect many clients you want to this proxy), creation of ACP files (tcpdump capture files, just like a sniffer), packets forwarding (chat style, each packet is forwarded to all the other clients and server connected), packets injection (the tool opens a specific UDP port where you can send your customized packets which will be sent to the server), hexadecimal visualization and plugins support for the modification and visualization of the packets with some example plugins already included (Zdaemon huffman, Doom huffman, Half-life decoding and one for the replacement of the text strings).
Plugins (which work on both Windows and Linux) are very basic to create and use, just take a look at example_sudp.c for more informations.
Pipepanic 0.1.3
Pipepanic is a pipe connecting game using libSDL. more>>
Comes with built-in help, is primarily mouse/stylus driven and can be played in different resolutions and orientations.
SpiralCrypt 0.10.2
SpiralCrypt is a stream cipher cyclic key. more>>
Includes check sum and file stat calculations, standard IO processing, named pipe processing and keys, shredding, random keys.
FlowFlowMania 0.6
FlowFlowMania project is a remake of the classical puzzle game Pipe Mania on Linux with GP2X compliance. more>>
Enhancements:
- new skins mechanism enhancement
- new type of piece : the logical checkpoints !
- new grahical representation of special pieces ("logical" and "mandatory" with a layer)
- new test levels
- and as always some bug fix ...
PipeBandwidth 0.1
PipeBandwidth is a program that measures the speed at which data goes through a pipe and prints statistics to stderr. more>>
Basically, it just reads from stdin, writes data back to stdout, and measures the speed. PipeBandwidth can be useful to measure transfer rates while sending data through netcat or compressing with gzip or bzip2.
progress 1.0
Progress is a utility used in a pipe to report progress of data transfer to standard error. more>>
Enhancements:
- February 9, 2003
- progress 1.0
- Initial announcement
mod_auth_pipe 1.0
mod-auth-pipe is a module of authentication written for Apache 1 (it hasnt been tested with Apache 2, but it may work). more>>
Actually, this module is just mod-auth-shadow with a few modifications in order to accept any program as a pipe, letting this one validate both users andr groups.
mod_auth_pipe contents the module itself and an example pipe.
mod-auth-pipe can be configured independantly for whole server, for any VirtualHost or just per Location/Directory. It has very few configuration variables and its format is very simple. In order to configure apache to authenticate, for example, access to the administrative interface of oscommerce you can type this on your httpd.conf:
< Directory /var/www/oscommerce/catalog/admin >
AuthType Basic
AuthName osCommerce admin site
AuthPipe on
AuthPipeProgram /usr/local/bin/auth-pipe
require group oscommerce-admins
< /Location >
This way, and with a well-made auth-pipe program you can be sure that only those within the group oscommerce-admins could enter that section of your web.
pipebench 0.40
pipebench is a utility that shows the status and a benchmark of piped commands. more>>
Pipebench measures the speed of a pipe, by sitting in the middle passing the data along to the next process. Works on at least Linux, OpenBSD, NetBSD, Solaris and x86, Alpha, HPPA, Sparc and Sparc64.
Compiling
Just type make to compile.
Type make install to have pipebench be installed in /usr/local/bin
Chart::GRACE 0.95
Chart::GRACE is a Perl object for displaying data via Xmgrace. more>>
SYNOPSIS
use Chart::GRACE;
xmgrace($a, { SYMBOL => plus};
use Chart::GRACE ();
$grace = new Chart::GRACE;
$grace->plot($pdl);
xmgrace($pdl, { LINESTYLE => dotted });
Provides a perl/PDL interface to the XMGR plotting package. Can be used to plot PDLs or Perl arrays.
A simple function interface is provided that is based on the more complete object-oriented interface.
The interface can be implemented using either anonymous pipes or named pipes (governed by the module variable Chart::GRACE::NPIPE). If named pipes are used ($NPIPE = 1) XMGR can be controlled via the pipe and buttons are available for use in XMGR. If an anonymous pipe is used XMGR will not accept button events until the pipe has been closed.
Currently the named pipe option can not support data sets containing 3 or more columns (I have not worked out how to do it anyway!). This means that only TYPE XY is supported. For anonymouse pipe 3 or more columns can be supplied along with the graph type.
The default option is to use the named pipe.
Chart::XMGR 0.95
Chart::XMGR is a Perl object for displaying data via XMGR. more>>
SYNOPSIS
use Chart::XMGR;
xmgr($a, { SYMBOL => plus};
use Chart::XMGR ();
$xmgr = new Chart::XMGR;
$xmgr->line($pdl);
$pdl->$xmgr->line;
xmgr($pdl, { LINESTYLE => dotted });
Provides a perl/PDL interface to the XMGR plotting package. Can be used to plot PDLs or Perl arrays.
A simple function interface is provided that is based on the more complete object-oriented interface.
The interface can be implemented using either anonymous pipes or named pipes (governed by the module variable Chart::XMGR::NPIPE). If named pipes are used ($NPIPE = 1) XMGR can be controlled via the pipe and buttons are available for use in XMGR. If an anonymous pipe is used XMGR will not accept button events until the pipe has been closed.
Currently the named pipe option can not support data sets containing 3 or more columns (I havent worked out how to do it anyway!). This means that only TYPE XY is supported. For anonymouse pipe 3 or more columns can be supplied along with the graph type.
The default option is to use the named pipe.