Free tomp3 0.17 software for linux

FLV::ToMP3 can convert audio from a FLV file into an MP3 file.

SYNOPSIS

use FLV::ToMP3;
my $converter = FLV::ToMP3->new();
$converter->parse_flv($flv_filename);
$converter->save($mp3_filename);

See also flv2mp3.

Extracts audio data from an FLV file and constructs an MP3 file. See the flv2mp3 command-line program for a nice interface and a detailed list of caveats and limitations.

TAC project is a pure Tcl version of AOL Instant Messenger (AIM).
The TAC client began its life as a small add-on program distributed with TiK, the Tcl/Tk client.
TAC has only a few of the features found in native Windows and Macintosh clients.
It is easy for users to add features to TAC using Tcl. TAC is meant to give users with only console access the ability to use AOL Instant Messenger.
Enhancements:
- Small bug fixed with away package that allows numbers in away messages
- Mobile phone package added
- New Away command: /awayfile or a:f sets the away message to the contents of the filename supplied as an argument
- Bugs fixed with shell escape function

iftop does for network usage what top(1) does for CPU usage. iftop project listens to network traffic on a named interface and displays a table of current bandwidth usage by pairs of hosts.
Enhancements:
- This release includes improved support for non-Linux platforms, including Mac OS X, FreeBSD, and OpenBSD.
- Other features include support for 802.1q VLANs, and optional removal of the shell escape function.

Pod::POM is a POD Object Model.

SYNOPSIS

use Pod::POM;

my $parser = Pod::POM->new(%options);

# parse from a text string
my $pom = $parser->parse_text($text)
|| die $parser->error();

# parse from a file specified by name or filehandle
my $pom = $parser->parse_text($file)
|| die $parser->error();

# parse from text or file
my $pom = $parser->parse($text_or_file)
|| die $parser->error();

# examine any warnings raised
foreach my $warning ($parser->warnings()) {
warn $warning, "n";
}

# print table of contents using each =head1 title
foreach my $head1 ($pom->head1()) {
print $head1->title(), "n";
}

# print each section
foreach my $head1 ($pom->head1()) {
print $head1->title(), "n";
print $head1->content();
}

# print the entire document as HTML
use Pod::POM::View::HTML;
print Pod::POM::View::HTML->print($pom);

# create custom view
package My::View;
use base qw( Pod::POM::View::HTML );

sub view_head1 {
my ($self, $item) = @_;
return < h1 >,
$item->title->present($self),
"< /h1 >n",
$item->content->present($self);
}

package main;
print My::View->print($pom);

This module implements a parser to convert Pod documents into a simple object model form known hereafter as the Pod Object Model. The object model is generated as a hierarchical tree of nodes, each of which represents a different element of the original document. The tree can be walked manually and the nodes examined, printed or otherwise manipulated. In addition, Pod::POM supports and provides view objects which can automatically traverse the tree, or section thereof, and generate an output representation in one form or another.

Pen is a load balancer for "simple" TCP-based protocols such as HTTP or SMTP. Pen project allows several servers to appear as one to the outside.
It automatically detects servers that are down and distributes clients among the available servers. This gives high availability and scalable performance.
The load balancing algorithm keeps track of clients and will try to send them back to the server they visited the last time. The client table has a number of slots (default 2048, settable through command-line arguments). When the table is full, the least recently used one will be thrown out to make room for the new one.
This is superior to a simple round-robin algorithm, which sends a client that connects repeatedly to different servers. Doing so breaks applications that maintain state between connections in the server, including most modern web applications.
When pen detects that a server is unavailable, it scans for another starting with the server after the most recently used one. That way we get load balancing and "fair" failover for free.
Correctly configured, pen can ensure that a server farm is always available, even when individual servers are brought down for maintenance or reconfiguration. The final single point of failure, pen itself, can be eliminated by running pen on several servers, using vrrp to decide which is active.
Enhancements:
- This release fixes a bug in the weighted server selection: server_by_weight would never consider blacklisted servers, which kept them blacklisted indefinitely.

XFA library implements an API that can be used to create NFA (either programmatically or from regular expressions) and to convert them in the minimal equivalent DFA.

XFA library requires an ANSI C compiler, and this makes it portable virtually over every system.

The complexity of the graphs that are treatable with XFA is only limited by the amount of memory available on the machine.

SYNOPSIS:

#include < xfa.h >

xfa_trans_t *xfa_alloc_trans(xfa_system_t *sys, unsigned long const *map, unsigned long flags, xfa_state_t *from, xfa_state_t *to );
void xfa_free_trans(xfa_system_t *sys, xfa_trans_t *trn);
xfa_state_t *xfa_alloc_state(xfa_system_t *sys, int phsize);
void xfa_free_state(xfa_system_t *sys, xfa_state_t *stt, int recurse);
void xfa_free_attr(xfa_system_t *sys, xfa_attr_t *attr);
int xfa_do_once(xfa_system_t *sys, xfa_state_t *stt, int (*dproc) (void *, xfa_system_t *, xfa_state_t *), void *priv);
xfa_state_t *xfa_nfa2dfa(xfa_system_t *sys, xfa_state_t *stt);
int xfa_label_states(xfa_system_t *sys, xfa_state_t *stt, unsigned long *label);
int xfa_dfa_minimize(xfa_system_t *sys, xfa_state_t *stt);
int xfa_re2nfa(xfa_system_t *sys, xfa_state_t **csts, xfa_state_t **cste, unsigned char const **ptr);

APSR is a network testing tool, designed to send and receive arbitrary network packets. APSR can be used to test firewalls, routing, security and many other things.
The project is splitted in two main programs, apsend to create packets and aprecv to sniff packets. The main goal of the APSR project is to develop a high quality network testing tool.
Main features:
- Sending and receiving of packets
- Ouput and documentation in different languages
- Easy installation (autoconf/automake support) and binary packages
- Configuration files
- Logfiles and filters in a variety of formats (text, xml, sql, gdbm, csv, ...)
- Syslog and database (sql) interfaces
- Daemon mode
- Thread support
- IPv4/v6 and MAC resolving
- Broadcast / Multicast support
- Special "packet-sets" (wake-on-lan for example)
- Client/Server system
- HTML based management system
- Graphical user interfaces/front ends (GUIs/FEs): GTK/QT/ncurses
- Module support using a simple packet construction language (PCL)
- Plugin support (perl/python or perl/ruby)
Which protocols will be supported by APSR final 1.0 ?
Who knows, currently(0.17-12) we can read more then 110 different protocol headers and create packets for about 30 different protocols.
And whats with the application layer?
Application layer protocols will be implemented through a simple module API. The modules can be written in C or (theoretically) in any other language. They will be loaded dynamically.
Enhancements:
- A lot of compilation problems have been fixed and the code has been cleaned.
- Some (Free)BSD-specific bugs have been fixed.
- No new features have been added.
- Users are advised to upgrade to this release.

Slirp provides a SLIP/PPP emulator over shell/telnet/ssh/etc.
Slirp is a (C)SLIP/PPP emulator based on the original BSD sources. It allows the user to pull up a full internet connection over a shell connection, and features sharing multiple modems for additional bandwidth.
Slirp emulates a PPP or SLIP connection over a normal terminal. This is an actual PPP or SLIP link, firewalled for peoples protection.
It makes a quick way to connect your Palm Pilot over the Internet via your Unix or Linux box!!! You dont need to mess around with your /etc/inetd.conf or your /etc/ppp/options on your system.
Slirp works on most Unix platforms, including:
Linux glibc and libc5 systems
Solaris 2.x
OSF/1
or any Unix that can compile GNU autoconfed programs with GCC.
Palm Pilot users can use this to connect their PalmOS device to the system and onto the Internet, using their home computer as a host. If you need to raise a temporary link, or cant run pppd, Slirp may help.
Enhancements:
- Changes for operation under Cygwin
- Added patch for Cygwin I_PUSH by Michael Wetherell
- dns is now transferred to peer, (If compiled with -DUSE_MS_DNS) (Ripped off from hacked pppd version 2.2.0f)
- Two dns options can be specified on command line, (Only the first is used internally, but both will get transferred to peer)
- Has a hack for connecting to a MS direct cable connect (If compiled with -DMS_DCC) Only works when PPP (-P option) is chosen, but gives effectively a nated direct cable connect. (A chat script option would be nicer)
- Fix to exit code that incorrectly iterated list of ttys attached
- Fixes to terminal restore code, No longer closes stdin on exit
- If stdout, or stderr are redirected, it wont close them (so you can debug using fprintf(stderr...)
- No longer removes 0s, 1s from incoming data stream
- New Option nozeros to not look at strings of 0s, 1s to cause exit/suspend (See docs/CONFIG)
- Can specify alternate tty on command line using "tty ttydevice" (Overrides SLIRP_TTY environment variable) (see docs/CONFIG)
- Debug builds log raw incoming data, and ppp checksum fault packets
- Minor documentation updates
- Does not close all file handles, (Pain when trying to debug)
- Can manually turn on early debugging in main()
- Most of Tims security fixes in place, (It is still insecure...) Probably snprintf will make slirp less portable.