Free ns software for linux

dnsutl package is a collection tools to make administering DNS easier. These include:
dns-rev
Take the forward DNS mapping and generate the reverse mapping. This is useful for producing a self-consistent DNS configuration.
dns-ethers
By using a bogus record type, you can keep the MAC address with the IP address, and generate the /etc/ethers file.
dns-hosts
Take the forward DNS mapping and generate the /etc/hosts file.
dns-bootp
Using the MAC and IP information, you can generate the /etc/bootptab file.
dns-ng
Take the forward DNS mapping and generate the /etc/netgroup file.
dns- bootparams
Using the MAC and IP information, you can generate the Sun /etc/bootparams file.
dns-boot- check
Check your named(8) configuration for self- consistency.
dns-hosts-import
Turn your /etc/hosts file into a DNS forward map, as a first step to configuring your DNS server.
dns-dhcp
Using the MAC and IP information, you can generate the /etc/dhcp.conf file.
All of these programs are both faster than shell scripts, and more robust when faced with all the peculiar semantics of DNS resource files. They even understand the $include directive.
dnsutl runs on almost any flavor of UNIX. The source distribution is self configuring using a GNU Autoconf generated configure script.
Enhancements:
- A bug has been fixed in the SRRF parser, so it more closely follows RFC 1035.
- A bug has been fixed in the name server (ns) record validation.

GNS-3 is a graphical network simulator that allows you to design complex network topologies. You may run simulations, or configure each device, from a simple workstation to a powerful Cisco router.
To allows complete simulations, GNS-3 is based on two existing projects:
- NS-3 , a discrete-event network simulator for Internet systems, targeted primarily for research and educational use.
- Dynamips, an IOS emulator which allows users to run IOS binary images from Cisco Systems.
This application is an open source product that may be used on multiple platforms, including Windows, Linux, and MacOS X.
Main features:
- Design of high quality network topologies.
- Emulation of Cisco routers.
- Load-balancing on multiple hosts/hypervisors when in emulation mode.
- Topology import and export.
- Image exports (PNG, JPEG, BMP, XPM).
Enhancements:
- Hypervisor load-balancing is now used to address the per process limit problem (http://dynagen.org/tutorial.htm#_Toc165530762).
- Configuration of multiple nodes may be done. The user can change hostnames.

RIR to DNS converter is a tool to convert Regional Internet Registry data to a DNS country lookup zone. You can use it to build your own DNS zone for looking up country codes from IP addresses.

It uses data directly from RIPE, ARIN, APNIC, LACNIC, and AFRINIC. The data can be updated on a schedule of your choosing.

The input data comes from:

ftp://ftp.afrinic.net/pub/stats/afrinic/delegated-afrinic-latest
ftp://ftp.apnic.net/pub/stats/apnic/delegated-apnic-latest
ftp://ftp.arin.net/pub/stats/arin/delegated-arin-latest
ftp://ftp.ripe.net/pub/stats/ripencc/delegated-ripencc-latest
ftp://ftp.lacnic.net/pub/stats/lacnic/delegated-lacnic-latest

The input data format is described in:

http://www.apnic.net/db/rir-stats-format.html

The output is a BIND 9 zone file that can be used to look up country codes
in a similar fashion to in-addr.arpa. For example, to find out what country
203.30.47.58 is:

host 58.47.30.203.rir.example.com
58.47.30.203.rir.example.com has address 127.0.65.86

where 65 and 85 are ASCII for A and U, which means 203.30.47.58 is
in Australia (AU).

HOW TO USE IT

Just feed it the above delegated- -latest files into stdin and it will
spit out the zone file to stdout. The zone file will only have the IP addresses,
so you could $INCLUDE it into a zone file that contains NS records, SOA, $ORIGIN,
etc.

WHY USE IT

You dont need the resolution of MaxMinds GeoIP database, but you do want
something that is free and you want it kept up to date on a schedule that
you decide.

You could use this to block or tag email based on countries, block or redirect
visitors to your website based on end-user country, and so on. Be very
careful about blocking mail this way, though, as you may block legitimate
email. Instead of blocking outright, use it in a SpamAssassin rule to add
something to the spam level, based on where the email comes from.

HOW IT WORKS

The RIR files contain ranges of IP addresses, and indicate what CC each range is allocated to. At the simplest level, rir2dns just sorts the ranges then iterates
through the IPs in each range and generates a reverse-dns-style A record that
represents the country code.

HOW IT WORKS - IN DETAIL

Rather than iterate through each IP address, the program tries to skip through
entire classes at a time (256 IPs, 65536 IPs, etc). Rather than iterate
through each IP, the loop iterates through classes or IP ranges (whichever are
smaller at the loop control), using control-breaks to accummulate neighbouring
ranges where possible so that entire classes that are in the same country dont
generate huge numbers of records.

Firstly, IPs are considered to be 4-digit numbers, but in base-256. In other
words, each octet is dealt with as if it were a single base-256 digit. This
turns out to be convenient because optimisations of large chunks of IP space can be done by looking for places where least-significant base-256 digits are zero.

Next, IP ranges are broken down into the following sub-ranges:

Optional individual IP addresses (ie: 4 octets)
Optional A-class ranges (ie: 3 octets)
Optional B-class ranges (ie: 2 octets)
Optional C-class ranges (ie: 1 octet)
Optional B-class ranges (ie: 2 octets)
Optional A-class ranges (ie: 3 octets)
Optional individual IP addresses (ie: 4 octets)

Considering that there is a pattern here, Im sure theres an elegant way to
handle breaking this down into two loops (one reducing the octets and one
increasing the octets), but I cant be bothered, so Ill break it down into
seven loops. Kind of hard-coded, but at least its simple.

For ease of processing, the IP addresses are actually converted to 32-bit numbers, then back again. This simplifies mathematics and looping through ranges.

Thats pretty much it, really...

Note that currently there are about 80,000 RIR records between all five
registries. This takes about 35 seconds on a 2.4GHz P4 to process, and
generates a 26MB file with around 3/4 million lines (RRs). This causes BIND
to use about 100MB or so of memory, and on a slow machine will probably cause it to take too long to reply, while it searches the zone. That size zone can
take a minute or two to load, which is quite a while.

Basic algorithm:

Read & process RIR data:

Read RIR ranges
Sort RIR ranges by start IP address
Glue together contiguous ranges of the same country

For each range

Generate the IPs at the start of the range

Generate the A-classes at the start of the range

Generate the B-classes at the start of the range

Generate the C-classes in the middle of the range

Generate the B-classes at the end of the range

Generate the A-classes at the end of the range

Generate the IPs at the end of the range

PDL::LinearAlgebra::Trans is a Linear Algebra based transcendental functions for PDL.

SYNOPSIS

use PDL::LinearAlgebra::Trans;

$a = random (100,100);
$sqrt = msqrt($a);

This module provides some matrix transcendental functions. Moreover it provides sec, asec, sech, asech, cot, acot, acoth, coth, csc, acsc, csch, acsch.

EOD

pp_add_exported(, mexp mexpts mlog msqrt mpow mcos msin mtan msec mcsc mcot mcosh msinh mtanh msech mcsch mcoth macos masin matan masec macsc macot macosh masinh matanh masech macsch macoth sec asec sech asech cot acot acoth coth mfun csc acsc csch acsch toreal pi);

pp_def(geexp, Pars => [io,phys]A(n,n);int deg();scale();[io]trace();int [o]ns();int [o]info(), GenericTypes => [D], Code => /* ----------------------------------------------------------------------| int dgpadm_(integer *ideg, integer *m, double *t, double *h__, integer *ldh, double *wsp, integer *lwsp, integer *ipiv, integer *iexph, integer *ns, integer *iflag)

XML::Namespace is a Perl module with simple support for XML Namespaces.

SYNOPSIS

Example 1: using XML::Namespace objects

use XML::Namespace;

my $xsd = XML::Namespace->new(http://www.w3.org/2001/XMLSchema#);

# explicit access via the uri() method
print $xsd->uri(); # http://www.w3.org/2001/XMLSchema#
print $xsd->uri(integer); # http://www.w3.org/2001/XMLSchema#integer

# implicit access through AUTOLOAD method
print $xsd->integer; # http://www.w3.org/2001/XMLSchema#integer

Example 2: importing XML::Namespace objects

use XML::Namespace
xsd => http://www.w3.org/2001/XMLSchema#,
rdf => http://www.w3.org/1999/02/22-rdf-syntax-ns#;

# xsd and rdf are imported subroutines that return
# XML::Namespace objects which can be used as above

print xsd->uri(integer); # http://www.w3.org/2001/XMLSchema#integer
print xsd->integer; # http://www.w3.org/2001/XMLSchema#integer

This module implements a simple object for representing XML Namespaces in Perl. It provides little more than some syntactic sugar for your Perl programs, saving you the bother of typing lots of long-winded URIs. It was inspired by the Class::RDF::NS module distributed as part of Class::RDF.

slookup is a simple program to do parallelized DNS lookups in a convenient way (useful for log parsing scripts and one-liners).
slookup project reads names (A/MX/NS lookups) or addresses (in dotted-quad format for PTR) on stdin and writes the results on stdout. One record per line. It can run up to 128 parallel DNS lookup processes (easily overloading a slow DNS server) which makes for Really Fast lookups for a large number of records.
Beware, output is written in the order the DNS replies are received, which is usually different from the input order if parallel lookups are done.
It has been tested on the following platforms:
Solaris 2.6 / UltraSparc / gcc 2.7.2.3
RedHat Linux 7.0 / 2.2.17 / glibc-2.1.94 / gcc 2.96
Debian sarge / 2.6.8.1 / glibc-2.3.2 / gcc 3.3.5
Debian etch / 2.6.15 / glibc-2.3.6 / gcc 4.0.3
FreeBSD 5.3-RELEASE / gcc 3.4.2
FreeBSD 6.0-RELEASE / gcc 3.4.4
Enhancements:
- Support for looking up NS records was added.

sshfp generates DNS SSHFP records from SSH public keys. It can take public keys from a knownhosts file or from scanning the hosts sshd daemon.

The ssh client can use these SSHFP records if you set "VerifyHostKeyDNS yes" in the file /etc/ssh/ssh_config.

SYNTAX

sshfp [-k [ knownhosts_file ]] [-a] | [ < hostname1 > [hostname2 ...]]
sshfp -s [ -a < domain > ] | [< hostname1 > [hostname2 ...]] [@ns]

OPTIONS

-s / --scan < hostname1 > [hostname2 ...]
Scan hosts or domain for public SSH keys using ssh-keyscan
-k / --knownhosts [knownhosts_file] < hostname1 > [hostname2 ...]
Obtain public SSH keys from a known_hosts file. Defaults to using
~/.ssh/known_hosts
-a / --all
Scan all hosts in the known_hosts file when used with -k. When used
with -s, it will attempt an zone transfer (AXFR) to obtain all A
records in the domain specified.
-t / --trailing-dot
Add a trailing dot to the hostname in the SSHFP records. It is not
possible to determine whether a known_hosts or dns query is for a
FQDN (eg [3]www.xelerance.com) or not (eg www) or not (unless -d
domainname -a is used, in which case a trailing dot is always
appended). Non-FQDN get their domainname appended through
/etc/resolv.conf These non-FQDN will happen when using a non-FQDN (eg
sshfp -k www) or known_hosts entries obtained by running ssh
[4]www.sub where .domain.com is implied. When -t is used, all
hostnames not ending with a dot, that at least contain two parts in
their hostname (eg [5]www.sub but not www get a trailing dot. Note
that the output of sshfp can also just be manually editted for
trailing dots.
-o / --output < filename >
Write to filename instead of stdout
-h / --help
Output help information and exit.
-v / --version
Output version information and exit.