Free dns country lookup software for linux

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.

Locale::SubCountry is a Perl module that can convert state, province, county etc. names to/from code.

SYNOPSIS

my $country_code = GB;
my $UK = new Locale::SubCountry($country_code);
if ( not $UK )
{
die "Invalid code $country_coden";
}
elsif ( $UK->has_sub_countries )
{
print($UK->full_name(DGY),"n"); # Dumfries and Galloway
print($UK->regional_division(DGY),"n"); # CT (Scotland)
}

my $australia = new Locale::SubCountry(AUSTRALIA);
print($australia->country,"n"); # AUSTRALIA
print($australia->country_code,"n"); # AU

if ( $australia->has_sub_countries )
{
print($australia->code(New South Wales ),"n"); # NSW
print($australia->full_name(S.A.),"n"); # South Australia
my $upper_case = 1;
print($australia->full_name(Qld,$upper_case),"n"); # QUEENSLAND
print($australia->category(NSW),"n"); # state
print($australia->FIPS10_4_code(ACT),"n"); # 01
print($australia->ISO3166_2_code(02),"n"); # NSW

my @aus_state_names = $australia->all_full_names;
my @aus_code_names = $australia->all_codes;
my %aus_states_keyed_by_code = $australia->code_full_name_hash;
my %aus_states_keyed_by_name = $australia->full_name_code_hash;

foreach my $code ( sort keys %aus_states_keyed_by_code )
{
printf("%-3s : %sn",$code,$aus_states_keyed_by_code{$code});
}
}

# Methods for country codes and names

my $world = new Locale::SubCountry::World;
my @all_countries = $world->all_full_names;
my @all_country_codes = $world->all_codes;

my %all_countries_keyed_by_name = $world->full_name_code_hash;
my %all_country_keyed_by_code = $world->code_full_name_hash;

This module allows you to convert the full name for a countries administrative region to the code commonly used for postal addressing. The reverse lookup can also be done. Sub country codes are defined in "ISO 3166-2:1998, Codes for the representation of names of countries and their subdivisions".

Sub countries are termed as states in the US and Australia, provinces in Canada and counties in the UK and Ireland.

Names and ISO 3166-2 codes for all sub countries in a country can be returned as either a hash or an array.

Names and ISO 3166-1 codes for all countries in the world can be returned as either a hash or an array.

ISO 3166-2 codes can be converted to FIPS 10-4 codes. The reverse lookup can also be done.

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

DNS::Config is a Perl module with DNS Configuration.

SYNOPSIS

use DNS::Config;
my $config = new DNS::Config();
$config->debug();

ABSTRACT

This class represents a configuration for a domain name service daemon (DNS).

A domain name service daemon configuration knows about the zone information actively provided to the service users as well as lots of other configuration data.

This class allows to represent this configuration data in a more or less generic way. Another class, the file adaptor, then knows how to write the information to a file in a daemon specific format.

So far this class is strongly related to the ISCs Bind domain name service daemon but it is inteded to get more generic in upcoming releases. Your help is welcome.

Telephony::CountryDialingCodes is a Perl module that can convert international dialing codes to country codes and vice versa.

SYNOPSIS

# Usage method 1 (using object methods):
use Telephony::CountryDialingCodes;
my $o = new Telephony::CountryDialingCodes();
my $country_code = NL;
print "The dialing access code for country $country_code is " . $o->dialing_code($country_code) . "n";
my $dialing_code = 1;
my @country_codes = $o->country_codes($dialing_code);
print "The country code(s) for dialing access code $dialing_code is/are: " . join(,,@country_codes) . "n";


# Usage method 2 (using class methods):
use Telephony::CountryDialingCodes;
my $country_code = NL;
print "The dialing access code for country $country_code is " . Telephony::CountryDialingCodes->dialing_code($country_code) . "n";
my $dialing_code = 1;
my @country_codes = Telephony::CountryDialingCodes->country_codes($dialing_code);
print "The country code(s) for dialing access code $dialing_code is/are: " . join(,,@country_codes) . "n";

# Extracting an intl dialing code from an intl phone number:
use Telephony::CountryDialingCodes;
my $o = new Telephony::CountryDialingCodes();
my $dialing_code = $o->extract_dialing_code(+521234567890);
# $dialing_code will contain 52.

This class exports a method for determining a countrys international dialing code, and another method for doing the reverse: i.e. determining the country code(s) that belong(s) to a given international dialing code.

You can call these methods as class methods or you can create an object and call these methods as object methods. The difference is that if you call them in object context that the internal lookup tables are freed when the object is destroyed, otherwise if you call the methods in class context, then the internal lookup tables are global and will persist for the lifespan of the current process. Its not really a big deal which approach you choose, so for the sake of style, use the object method approach if you have no clue which is better.

DNSMasq Webmin Module is a Webmin module to allow configuration of DNSMasq, a DNS proxy and DHCP server.

DNS name parser is a Java utility library for parsing dns names, ip and hw addresses.

Synopsis

import su.netdb.parser.*;

Parser parser = new Parser();

Hashtable result = parser.parse(str);

System.out.println("string: "+result.get("string"));
System.out.println("hw: "+result.get("hw"));
System.out.println("name: "+result.get("name"));
System.out.println("domain: "+result.get("domain"));
System.out.println("ip_low: "+result.get("ip_low"));
System.out.println("ip_high: "+result.get("ip_high"));

"DNS name parser" is an utility library created to be used in a search application. Given a single input field its function is to differentiate between several types of possible input strings. Namely if it a dns name, IP address (exact, ip range or ip with wildcards) or hardware address. The result of the parsing is a Hashtable with possible keys "string", "hw", "name", "domain", "ip_low" and "ip_high".

Net::DNS::ToolKit are tools for working with DNS packets.

SYNOPSIS

use Net::DNS::ToolKit qw(

get1char
get16
get32
put1char
put16
put32
getIPv4
putIPv4
putIPv6
getIPv6
getstring
putstring
dn_comp
dn_expand
parse_char
gethead
newhead
getflags
get_qdcount
get_ancount
get_nscount
get_arcount
put_qdcount
put_ancount
put_nscount
put_arcount
inet_aton
inet_ntoa
ipv6_aton
ipv6_n2x
ipv6_n2d
sec2time
ttlAlpha2Num
collapse
strip
get_ns
gettimeofday
);

$char = get1char($buffer,$offset);
($int, $newoff) = get16($buffer,$offset);
($long, $newoff) = get32($buffer,$offset);
$newoff = put1char($buffer,$offset,$u_char);
$newoff = put16($buffer,$offset,$int);
$newoff = put32($buffer,$offset,$long);
$flags = getflags($buffer);
$int = get_qdcount($buffer);
$int = get_ancount($buffer);
$int = get_nscount($buffer);
$int = get_arcount($buffer);
$newoff = put_qdcount($buffer,$int);
$newoff = put_ancount($buffer,$int);
$newoff = put_nscount($buffer,$int);
$newoff = put_arcount($buffer,$int);
($netaddr,$newoff)=getIPv4($buffer,$offset);
$newoff = putIPv4($buffer,$offset,$netaddr);
($ipv6addr,$newoff)=getIPv6($buffer,$offset);
$newoff = putIPv6($buffer,$offset,$ipv6addr);
($offset,
$id,$qr,$opcode,$aa,$tc,$rd,$ra,$mbz,$ad,$cd,$rcode,
$qdcount,$ancount,$nscount,$arcount)
= gethead($buffer);
$newoff = newhead($buffer,$id,$flags,
$qdcount,$ancount,$nscount,$arcount);
($b,$h,$d,$a)=parse_char($char);
($newoff,$name) = dn_expand($buffer,$offset);
($newoff,@dnptrs)=dn_comp($buffer,$offset,$name,@dnptrs);
$dotquad = inet_ntoa($netaddr);
$netaddr = inet_aton($dotquad);
$ipv6addr = ipv6_aton($ipv6_text);
$hex_text = ipv6_n2x($ipv6addr);
$dec_text = ipv6_n2d($ipv6addr);
$timetxt = sec2time($seconds);
$seconds = ttlAlpha2Num($timetext);
$shorthost = collapse($zonename,$longhost);
$tag = strip($P_tag);
@nameservers = get_ns();
($secs,$usecs) = gettimeofday();

Routines to pick apart, examine and put together DNS packets. They can be used for diagnostic purposes or as building blocks for DNS applications such as DNS servers and clients or to allow user applications to interact directly with remote DNS servers.