Free ipv4 software for linux

Net::IPv4Addr is a Perl extension for manipulating IPv4 addresses.

SYNOPSIS
use Net::IPv4Addr qw( :all );

my ($ip,$cidr) = ipv4_parse( "127.0.0.1/24" );
my ($ip,$cidr) = ipv4_parse( "192.168.100.10 / 255.255.255.0" );

my ($net,$msk) = ipv4_network( "192.168.100.30" );

my $broadcast = ipv4_broadcast( "192.168.100.30/26" );

if ( ipv4_in_network( "192.168.100.0", $her_ip ) ) {
print "Welcome !";
}

etc.

Net::IPv4Addr provides functions for parsing IPv4 addresses both in traditional address/netmask format and in the new CIDR format. There are also methods for calculating the network and broadcast address and also to see check if a given address is in a specific network.

IPTables::IPv4::DBTarpit::SiteConfig is a configuration info for DBTarpit.

SYNOPSIS

use IPTables::IPv4::DBTarpit::SiteConfig;

$hashref = new IPTables::IPv4::DBTarpit::SiteConfig;

This module returns a hash pointer to the configuration information used to intall DBTarpit. The values shown below are what was configured when DBTarpit was installed for this site.

|, $txt, q| =head1 EXPORT

none

IPy is a Python class and tools for handling of IPv4 and IPv6 addresses and networks. The script is similar to the Net::IP Perl module.
The IP class allows a comfortable parsing and handling for most notations in use for IPv4 and IPv6 Addresses and Networks. It was greatly inspired bei RIPEs Perl module NET::IPs interface but doesnt share the Implementation. It doesnt share non-CIDR netmasks, so funky stuff lixe a netmask 0xffffff0f cant be done here.
>>> from IPy import IP
>>> ip = IP(127.0.0.0/30)
>>> for x in ip:
... print x
...
127.0.0.0
127.0.0.1
127.0.0.2
127.0.0.3
>>> ip2 = IP(0x7f000000/30)
>>> ip == ip2
1
>>> ip.reverseNames()
[0.0.0.127.in-addr.arpa., 1.0.0.127.in-addr.arpa.,
2.0.0.127.in-addr.arpa., 3.0.0.127.in-addr.arpa.]
>>> ip.reverseName()
0-3.0.0.127.in-addr.arpa.
>>> ip.iptype()
PRIVATE
Enhancements:
- This release is able to parse any IPv4 and IPv6 address in many formats with or without netmask.

ipv6calc provides a small utility to manipulate IPv6 addresses.
ipv6calc can be used by scripts to convert IPv6 addresses from one format to another.
ipv6calc is a small but powerful utility written in the C programming language to manipulate (not only) IPv6 addresses. ipv6calc allows the users to convert a given IPv6 address to the compressed format or to the format used by /proc/net/if_inet6. ipv6calc is also the replacement of the old ip6_int Perl program.
This utility is also used to extend features on network-functions-ipv6 library, used by initscripts-ipv6.
Hint: take also a look at the Advanced Network Management Laboratory / IPv6 Address Oracle if you want to learn more about IPv6 addresses.
Enhancements:
- remove non-ascii chars on GEOIP_DATABASE_INFO
- update databases
- make code for printing GeoIP and IP2Location universal for IPv4 and IPv6
- fix missing printout of footer in case of IPv6 address is given
- toggle background for lines with embedded IPv4 address

"ncp" is a utility for copying files in a LAN. It has absolutely no security or integrity checking, no throttling, no features, except one: you dont have to type the coordinates of your peer.
npush will now use IPv6 and IPv4 multicast on the multicast groups ff02::6e63:7030 (6e63:7030 == ncp0) and 224.110.99.112 (110.99.112 == ncp). If both methods fail, npush will resort to the broadcast packets used by previous versions. You can force the broadcast method by passing "-b" to npush so that previous npoll versions can see the announcements.
NCP Basically it works like this:
1. You and your buddy want to play Quake
2. Your buddy has a level that you dont have
3. He types npush filename and waits. npush sends out UDP announcement packets proclaiming that someone wants to send something
4. You type npoll. npoll waits until it sees one of these packets
5. The files are copied with tar over a TCP socket, so permissions and file dates (and if you are root, owners) are preserved.
Enhancements:
- use libowfat

SendIP is a command-line tool to send arbitrary IP packets. It has a large number of options to specify the content of every header of a RIP, RIPng, BGP, TCP, UDP, ICMP, or raw IPv4/IPv6 packet.
It also allows any data to be added to the packet. Checksums can be calculated automatically, but if you wish to send out wrong checksums, that is supported too.
Here is a list of protocols that SendIP currently understands:
- IPv4 (but see below section 7)
- TCP
- BGP
- ICMP
- UDP
- RIP
- NTP
- IPv6 (except on solaris)
- ICMPv6
- TCP
- UDP
- RIPng
- NTP?
Other protocols will be added in future versions, as and when I have time to add them.
Of course, it is still possible to send packets using other protocols, but you have to construct the packet data and headers entirely by hand.
Installation
make ; make install should work.
You MUST use GNU make.
On Solaris you need to use gcc-3.x or above, and GNU binutils.
On other platforms, you probably need gcc-2.x or above.
If you have install problems on Solaris, try:
make install INSTALL=/usr/ucb/install
If you cant persuade it to compile or install, mail me with details of what goes wrong, and what system you are trying to install it on.
By this I mean at least:
- output of make -k veryclean all install
- OS, including version
- version of make, gcc, etc
- version of sendip
- anything else you think might be relevant
You can change where it installs by changing BINDIR and/or PREFIX at the top of the Makefile.
A .spec file is included to build RPMS, and source and binary RPMS are also available from the web page. Debian packages are also available, and sendip is included in the FreeBSD ports collection.
Usage
SendIP can take a huge number of commandline parameters. For this reason, future versions may have some sort of user interface...
Please read the man page or sendip -h for details. They are not documented here because they change often between versions and I cant be bothered to keep this up to date.

JIPSY library is a drop-in replacement for parts of the java.net classes that enables Java applications to seamlessly communicate using IPv4 and IPv6.

Applications require no modification or re-compilation to use the software, therefore making any Java network application IPv6-ready.