Free first direct software for linux

FIRST LIVE primarily it is to assist law enforcement agencies and its officer to combat cyber terrorism and other malicious activities. FIRST LIVECD usage and application can be also extended to private organizations and individuals who are need alternative in securing their network and computer system. FIRST LIVECD objectives are to capture and to provide an immediate environment (workspace) to perform live:

1. Computer Forensics Analysis
2. Incident Response
3. Data Acquisition And Recovery
4. Virus Scanning And Detection
5. Vulnerability Assessment
6. Runs On Any x86 Computer Without Any Installation
7. One Stop Solutions For Fast Deployment And Low Cost Security Product.
8. User Friendly

Check Your Network Address Translator for Compatibility with Peer-to-Peer Protocols.
If you are accessing the Internet from behind a Network Address Translator (NAT) of some kind, I would appreciate your help in surveying the behavior of different NATs, in terms of how and whether they support a certain technique for enabling peer-to-peer communication between NATted hosts (particularly when both endpoints are behind NATs). Down, you can understand what NAT is.
Suppose there are three communicating hosts: A, B, and C. Host A is a "well-known" Internet server with a permanent IP address, which acts as an "introducer" for the other two nodes. (For example, Host A might be a well-known ultrapeer or a game catalog server of some kind.) Host B, using Host As "introduction" services, would like to establish a direct peer-to-peer connection with host C. Both B and C, however, are behind (probably different) network address/port translators, and neither of them has exclusive use of any public IP address.
To initiate a peer-to-peer connection with host C, host B first sends A a message requesting an "introduction" to host C. A sends B a reply message containing Cs IP address and UDP port number as reported by host C, in addition to Cs IP address and UDP port number as observed by A. (If C is behind a NAT, then these two address/port combinations will be different.) At the same time, host A sends host C a message containing Bs IP address and UDP port numbers - again, both the ones reported by B and the ones observed by A, which will be different if B is behind a NAT.
Now B and C each know that they want to initiate a connection with each other, and they know each others public (NATted) as well as original IP addresses and UDP port numbers. Both B and C now start attempting to send UDP messages directly to each other, at each of the available addresses. If B and C happen to be behind the same NAT, then they will be able to communicate with each other directly using their "originally reported" IP addresses and UDP port numbers.
In the more common case where B and C are behind different NATs, the "originally reported" addresses will be useless because they will both be private IP addresses in different addressing domains. Instead, the IP address/UDP port combinations observed by A can be used in this case to establish direct communication. Although Bs NAT will initially filter out any UDP packets arriving from Cs public (NATted) UDP port directed at Bs public port, the first UDP message B sends to C will cause Bs NAT to open up a new UDP session keyed on Cs public port, allowing future incoming traffic from C to pass through the NAT to B. Similarly, the first few messages from B to C may be filtered out by Cs NAT, but will be able to start passing through the firewall as soon as Cs first message to B causes Cs NAT to open up a new session. In this way, each NAT is tricked into thinking that its respective internal host is the "initiator" of this new session, when in fact the session is fully symmetrical and was initiated (with As help) simultaneously in each direction.
Required NAT Behavior
There is one important requirement that the NATs must satisfy in order for this technique to work: the NATs must be designed so that they assign only one (public IP address, public UDP port) pair to each (internal IP address, internal UDP port) combination, rather than allocating and assigning a new public UDP port for each new UDP session. Recall that a "session" in Internet terminology is defined by the IP addresses and port numbers of both communicating endpoints, so host Bs communication with host A is considered to be one session while host Bs communication with host C is a different session. If Bs NAT, for example, assigns one public UDP port for Bs communication with A, and then assigns B a different public UDP port for the new session B tries to open up with C, then the above technique for peer-to-peer communication will not work because Cs messages to B will be directed to the wrong UDP port.
RFC 3022 explicitly allows and suggests that NATs behave in the former, "desirable" fashion, by maintaining a single (public IP, public port) mapping for a given (internal IP, internal port) combination independent of the number of active sessions involving this mapping. This behavior is not only good for compatibility with UDP applications, but it also helps to conserve the NATs scarce pool of public port numbers. Maintaining a consistent public port mapping does not adversely affect security in any way, either, because incoming traffic can still be filtered on a per-session basis regardless of how addresses are translated. There in fact appears to be no good reason not to implement the desirable behavior in a NAT, except perhaps for the implementation simplicity of naively allocating a new public port for every new session. Unfortunately, RFC 3022 does not require NATs to implement the desirable behavior, which has led me to wonder just how many real NATs actually do, and hence this page.
What NAT Check Does
The program natcheck.c is basically just a program that "pings" a well-known UDP port at two different servers that are publically accessible on the Internet. Both of these servers run the program natserver.c, with the command-line arguments "1" and "2" respectively. In addition, there a third "conspiring" server runs natserver with the command-line argument "3". Whenever each of the first two servers receives a UDP request, it not only sends a reply directly to the sender of that request, but also sends a message to the third server, which in turn "bounces" the reply back to the original client. The effect is that the client will receive not only solicited "ping" replies from the server the request was directed to, but also "unsolicited" replies from the third server.
To determine if the network address translator in use is implementing the desirable behavior of maintaining a single (public IP address, public port) mapping for a given (client IP address, client port), the client program natcheck.c basically just initiates a sequence of simultaneous pings to the first two servers (in case some of the requests or replies are lost in transit) and checks that the clients address and UDP port as reported by both servers is the same. If the NAT naively allocates a new public port for each new session, then the source port as reported by the two servers will be different, and its time to upgrade your NAT.
The replies echoed from the third server are used only to check whether the NAT properly filters out unsolicited incoming traffic on a per-session basis. Since the client never sends any messages to the third server, if the NAT is properly implementing firewall functionality, the client should never see the third servers echoed replies even after opening up active communication sessions with the first two servers.
Enhancements:
- The NAT Check client no longer attempts to guess whether you have Basic NAT or Network Address/Port Translation (NAPT). It turns to be quite difficult to test for this property reliably, because many NAPTs attempt to bind a private UDP port to a public port with the same port number if that port number is available, causing NAT Check to falsely report Basic NAT. The only way to test for this property reliably would be to run NAT Check on at least two client machines simultaneously, and since this property isnt terribly important to P2P apps its just not worth the trouble.
- The NAT Check client now tests for one additional NAT feature, which I call loopback translation. If a NAT supports loopback translation, it means that a host on the private network behind the NAT can communicate with other hosts on the same private network using public (translated) port bindings assigned by the NAT. Most NATs probably do not support this feature yet, but it may become increasingly important in the future where P2P clients may be located behind a common ISP-deployed NAT as well as individual home NATs. More details on loopback translation will appear in the next version of my Internet-Draft, to be released soon.
- The NAT Check client program now has a command-line option, "-v", which turns on verbose messages during the test.

IceGenerator provides a direct stream generator for Icecast/Shoutcast servers.
It streams MP3s to an Icecast/Shoutcast server without resampling it, saving CPU time. It features directory searches, MySQL/PGSQL support, M3U/PLS support, ID3 tags, META dynamic info, and a telnet interface. v
Main idea for this program is radio automation on a Icecast/Shoutcast server. If you have many server processes and CPU saving is your priority, u can use IceGenerator.
Obviously mp3s/oggs will be already resampled to allow their streaming on your bandwidth capability.
Main features:
- Automatically put into playlist directories full of mp3s, or a MySQL table
- No resampling is allowed, so CPU is saved
- MP3s/OGGs are played randomly or in alphabetic order, without repeating twice a song
- You can loop the whole playlist at its end
- When IceGenerator quits, finish its last song first
- IceGenerator status is optionally reported to syslog/log file
- Very useful when used with crond
- ID3 support

SomaList is a part of the Soma project.

Soma project started in summer 2003 to manage the digital version of an acitvists radio old spools.

The first release just gave just the chance to play random some audio files in a directory using an external program (at that time mpg123). In despite of that this software was never used, i kept on thinking about soma project for some weeks, until i started directly to work with a group called Reload, which was experimenting at the time a project called "eterete" and creating a place for a web radio at Pergola Tribe (a selfmanaged house in Milan).

We used, of course, a release, which was a little bit better to manage the radio-playlist and of course we implemented the software itself. From september till december soma became a software suite, configurable through file and (remote administration...). Thats thanks to the relationships and the inputs that such a community like Reload can create.

A group of passionate activists was able to make broadcastings and broadcast schedules, to find out new problems and to give implementation advices. They also suggest me the idea that soma (originally a simple play-list manager) could become a programs suite, which has a player, a software for deferred broadcasting, a more user friendly admininstration, documentation and distribution.

Some time after came soma player and soma admin. The player was still very behind compared to my implementation ideas. Somadmin was straight away on line and advertised on radio.inventati.org/somadmin/

In January 2004 we showed Soma at the first italian (web and air-waves) radio meeting in Naples.The meeting was technologically and politically profitable and it was an attempt to build up a real radio-network. Radio.inventati.org was actually the only example od direct cooperation among even very different people: individuals, improvised groups, very old and movement radios and experiences from overseas countries.

On the web site there are occasional streamings, weekly streamings, and 24hrs music flows.

The object of the technical research was a digital environment, which could let individuals or whole communities gain access to a common schedule with resum?s,
repetitions, deferred programs, live broadcastings, regular broadcastings as one national and international network. Soma could satisfy this need and could be easly managed through the web thanks to somadmin, which could update the soma admin in real time.

The developments went on. Somaplayer is now reality. The only music player which can stream directly an mp3, an ogg vorbis, a wav, a track from an audio cd or a streaming directly on an icecast server (icecast 2 or shoutcast) or just play it on a computer using sound drivers or sound daemons.

At the moment more other people work at this project, who debug the software, write docs, work at the website and make installation packages (for debian).

Invasores project was first designed as a proof of concept of which language would be faster to develop games.

Glass Icons Theme provides a full transparent set of icons.

Full Transparent SVG Icons, are in beta-test.

This is the first public release.

Radio Shortest Path First (RSPF) is a routing protocol for wireless networks. This particular implementation is written for Linux and conforms to version 2.2 of the protocol specification. There are many reasons why our networks are complicated, but one significant thing is that you can no longer assume that just because you hear one station, then they can hear you. This means you can have a lot of unidirectional routes.
The current specification is RSPF version 2.2, written by Fred Goldstein K1IO. Until recently, if people were using RSPF at all, they would of been using RSPF version 2.1, which is available in the NOS program, written by Phil Karn and others. The RSPF code itself in NOS was written by Anders Klements.Thats why standard protocols dont work very well over amateur packet radio.
Now with the knowledge of how his protocol worked in real life, Fred then updated and improved RSPF to version 2.2. And, until late 1995, that was all that happened.
What did happen was that I was in my senior years in my undergraduate degree at University of Technology, Sydney and looking for an interesting Thesis. After seeing emails from Carl Makin VK1KCM asking if anyone was going to fix RSPF in NOS, this gave me my idea for my Thesis.
Enhancements:
- Control port speaks IPv6
- Made the ChangeLog prettier
- Fixed the checksum code so it works.
- Put everything through syslog()
- :s/t/ /

RDFStore::Parser::SiRPAC is a Perl module that implements a streaming RDF Parser as a direct implementation of XML::Parser::Expat.

SYNOPSIS

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $p=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Handlers => {
Init => sub { print "INITn"; },
Final => sub { print "FINALn"; },
Assert => sub { print "STATEMENT - @_n"; }
},
NodeFactory => new RDFStore::NodeFactory() );

$p->parsefile(http://www.gils.net/bsr-gils.rdfs);
$p->parsefile(http://www.gils.net/rdf/bsr-gils.rdfs);
$p->parsefile(/some/where/my.rdf);
$p->parsefile(file:/some/where/my.rdf);
$p->parse(*STDIN); #parse stream but with *blocking* Expat (see below example for n-blocking parsing using XML::Parse::ExpatNB)

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $pstore=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Style => RDFStore::Parser::Styles::RDFStore::Model,
NodeFactory => new RDFStore::NodeFactory(),
store => {
persistent => 1,
seevalues => 1,
options => { Name => /tmp/test }
}
);
my $rdfstore_model = $pstore->parsefile(http://www.gils.net/bsr-gils.rdfs);

#using the expat no-blocking feature (generally for large XML streams) - see XML::Parse::Expat(3)
my $rdfstore_stream_model = $pstore->parsestream(*STDIN);

This module implements a Resource Description Framework (RDF) streaming parser completely in Perl using the XML::Parser::Expat(3) module. The actual RDF parsing happens using an instance of XML::Parser::Expat with Namespaces option enabled and start/stop and char handlers set. The RDF specific code is based on the modified version of SiRPAC of Sergey Melnik in Java; a lot of changes and adaptations have been done to actually run it under Perl. Expat options may be provided when the RDFStore::Parser::SiRPAC object is created. These options are then passed on to the Expat object on each parse call.

Exactly like XML::Parser(3) the behavior of the parser is controlled either by the Style entry elsewhere in this document and/or the Handlers entry elsewhere in this document options, or by the setHandlers entry elsewhere in this document method. These all provide mechanisms for RDFStore::Parser::SiRPAC to set the handlers needed by Expat. If neither Style nor Handlers are specified, then parsing just checks the RDF document syntax against the W3C RDF Raccomandation . When underlying handlers get called, they receive as their first parameter the Expat object, not the Parser object.

To see some examples about how to use it look at the sections below and in the samples and utils directory coming with this software distribution.
E.g. With RDFStore::Parser::SiRPAC you can easily write an rdfingest.pl script to do something like this:

fetch -o - -q http://dmoz.org/rdf/content.rdf.u8.gz |
gunzip - |
sed -f dmoz.content.sed | rdfingest.pl -