Posted by & filed under OpenNIC.

Hi,

Prior to writing a charter I hope to determine how well received .firm
will be as a top level domain.

The domain will be for users who want to establish any kind of presence
in the OpenNIC name space, commercial or non commercial.

This would be the alternate ‘.com’ , more or less but open to any kind
of use with very little restriction. While the name space is likely to
turn into the twilight zone quickly, it would make it easy for companies
to register their trademark vanity on OpenNIC.

Cheers,
Tim [Post]

I personally think this is a good idea, however there have been top level domains such as .pro, .tel and even .travel created, but how often do you see them used? Maybe it’s just that we need to beat into peoples head that “just” because a domain does not end in dot com does not mean it’s rubbish.

But even I see my self crawling through Google, and when I see a .info domain I sort of skip over it.

It probably has more to do with content, I know that I can get Panasonic’s website when I type in panasonic.com (which I think alot of people do … brandname dot com), but I can’t get it when I goto www.panasonic.pro.

Why does dot com seem to be the de facto location for registering domains?

Posted by & filed under Misc, OpenNIC.

Ahhh, the modern BBS. Let’s examine it. The modern BBS (which has yet to be given a name) is a mini hackathon project that I am doing to give some life to the rotting away OpenNIC “.bbs” top level domain. I am going to operate a bulitin board system, but update it a little at the same time.

My plans are to use SSH, Perl and Curses (Curses::UI to be exact) to do funky ASCII interfaces without spending *too* much time working on the fine lines.

Will share more when I awaken from my slumber.

Posted by & filed under OpenNIC.

What does it take to run a Top Level Domain Registry? And what’s more easy to run: a ccTLD or gTLD?

Opinions so far have ranged from “it’s easy” to “it’s a serious business” – both of which are obviously far too vague to being to measure what is an intriguing question. Some suggestions fall down in favour of the easy option: “only 5 ccTLDs show 24 x 7 support”, “registries are not difficult to run”. Others say, “it requires great technical skills, and business approach”. They maintain that the while technically and even theoretically it is easy to run a top-level domain, the realities mean providing and/or selling domains, advanced review systems, legal considerations and so on.

( the above was quoted from http://blog.icann.org/?p=21 )

It’s with some what of a geeky pride that I stand up and say: “I run my own top level domain (and you don’t)“, and I thought I might write a little article on how you can put your own geek hat on and say for yourself, that you run your own top level domain.

(Please don’t hurt my geek pride by saying dotING is not part of ICANN’s official root)

I will be looking at everything from technical requirements, through to staffing requirements and costs [which I did in my last post]. I will look at what software is needed to successfully operate a top level domain, the hardware and the management skills.

By reading this guide, I will assume that you know how to change the network settings for your operating system (i.e., change your DNS server(s)) and that you know how to install (but not configure) BIND. I will also assume that you run a decent operating system that is not based on the Windows architecture.

Required software
For this, I will presume you already have BIND (I recommend version 9) of some sort installed on your machine. I will be using Ubuntu 7.10 ( yes, I know I need to upgrade :) ), with the BIND that ships with Ubuntu. Other installations of BIND may or may not be similar. If not, I would suggest reading up on a basic BIND tutorial.

sudo apt-get install bind9 dnsutils

The first config change
The first thing I do when I set up an Ubuntu machine to serve my own custom TLD, is I change the first few lines of /etc/bind/named.conf (this can be different on other distro’s) to say something like this:

options {
recursion yes;
allow-query { any; };
};

zone “.” in
{
type slave;
file “/etc/bind/db.root”;
masters { 75.127.96.89; };
notify no;
};

// This is the name of the TLD that I want to create
zone “mytld” {
type master;
file “/etc/bind/mytld.zone”;
allow-transfer { any; };
allow-query { any; };
};

A few things have changed. First, we have almost finished setting up the DNS server to start resolving OpenNIC Top Level Domains (such as .geek). Also, the framework for the new local mytld top level domain is put in place.

Now all that is needed is for us to finish setting up OpenNIC resolving (the “.” zone) and to make our first domain in the mytld top level domain to start resolving.

# cd /etc/bind
# mv db.root db.root.backup
# dig . ns @75.127.96.89 > db.root
#
sudo /etc/init.d/bind restart

By now, when you switch your computer to your new BIND setup, you should be resolving sites like google.com just like before. Not only should you resolve sites in .com etc, but also .geek (try sharesource.geek)

If this is working, all that is left is to create the /etc/bind/mytld.zone file;

$ORIGIN .
$TTL 3600       ; 1 hour
mytld                IN SOA  this.computer.com. bob.this.computer.com. (
                                2009010101 ; serial
                                3600       ; refresh (1 hour)
                                3600       ; retry (1 hour)
                                604800     ; expire (1 week)
                                86400      ; minimum (1 day)
                                )
$TTL 86400      ; 1 day
$ORIGIN mytld.
www                     A       202.172.90.1
bob                     A       202.172.90.2

This file looks complicated, but really, it’s not too hard to understand! The third line starts the authority, which basically says to other servers that use this top level domain “look, this.computer.com runs this computer. and bob@this.computer.com administrates it!”

The next lines say that “The following records will last for 1 day, so if the other DNS servers look up this address, they don’t need to ask for another 24 hours”. The line following “$TTL 86400” says “I am going to be lazy… all domains (at the left hand side) are going to have mytld. at the end”.

The last two lines state that the domain www.mytld will resolve to the IP 202.172.90.1, and the domain bob.mytld will resolve to the IP 202.172.90.2.

# sudo /etc/init.d/bind restart

A quick restart of BIND, and we should be able to resolve domains like www.mytld and bob.mytld on the local machine!

# dig www.mytld @127.0.0.1
; <<>> DiG 9.4.1-P1.1 <<>> www.mytld
;; global options:  printcmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 25028
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 6, ADDITIONAL: 6

;; QUESTION SECTION:
;www.mytld.                      IN      A

;; ANSWER SECTION:
www.mytld.               86400   IN      A       202.172.90.1

This means that your new top level domain is now resolving locally.

Think you have the killer domain?
Well, there is a way that you can share it with the world, and let other people share in the joy of your new top level domain! Goto OpenNIC, and ask if they would like to add your top level domain into their root.

Think editing config files is a pain everytime someone wants a new domain, or wants to change some basic information? Well, my top level domain administration software, Galium, will fix those problems for you right up :)

Please, if you think that something is missing, or you want some clarification or anything like that, leave a comment, and I will get back to you!

Posted by & filed under Random Thoughts.

If we were to run a proper top level domain (eg, a .au or a .nz), I would need seven or eight computers located around the world. The proof is in the root.

dig au NS @4.2.2.2 | grep ^au. | wc -l

The command above returns “8“, which means that the Australian top level domain has eight name servers that might be queried when you type in any website who’s domain name ends in .au

dig com NS @4.2.2.2 | grep ^com. | wc -l

This command (notice how we are looking at the .com tld this time) returns “13“, which means that when you enter a domain name ending in .com, you could ask one of a possible 13 domain name servers around the planet for information about a domain in the .com TLD.

Interesting Internet Factoid!
47 out of the 264 active top level domains on the internet have either two or three nameservers set as being authoritative (that is, they are allowed to respond to requests for that top level domain, that they are seen as a master). That’s a nice 18% of all top level domains. (This information was correct 29th July 2008 … 1am).

To run a top level domain, we will assume that we need three machines! If you want to get in with the new TLD craze, where ICANN have opened up registration of TLD’s, you will need at least three servers to act as namerservers. This is a very safe bet.

How much does three servers cost? Well, before your start Googling for webhosts – wait. You will need either a dedicated machine or a VPS.

In my experience, a simple machine can very easily handle a load of 1,000 DNS queries a second, so, logically thinking, if you have three machines, your new top level domain would be able to handle around 2,500 queries a second!

A quick Google for dedicated hosts showed that to get three servers in three continents will cost me around $150 per server (in AUD) a month, which means, before you have even let one internet user access a website, you have paid $450. This is not counting the registration free for a new TLD that ICANN will probably ask you to pay them (early estimates are that a top level domain that is in the ICANN root will cost about $10,000 … I am guessing for $25,000 and $100,000 or more for “premium” top level domains like .blog).

The raw cost!

Now, think about that for a second. This means that for three years of operation at a minimum you would be looking at 10000+(450*12*3)+(40000*3) or $146,200.

That is, $10,000 for the registration free to get your new Top Level Domain into the ICANN’s roots, $450 a month for three years to pay for three name servers (you will need more as the top level domain gets more popular, as I said above, dot com has around thirteen servers. The price also pays for food and coffee for three administrators ($40,000)

Sounds like a lot, but if the registrar owner makes $4 on each domain, then only 36,550 domains need to be sold to customers.

Running a top level domain that is in the ICANN/IANA root is relatively easy. The biggest stumbling block will be the amount of money that is required.

In my next post, I will look at the software end. What software is required in order for customers to register domains? What is needed for you to serve clients with responses to a top level domain, and of course, it would not be me without explaining how you can put your top level domain live on the internet without paying a free to ICANN or IANA!

Posted by & filed under OpenNIC.

I am currently working on the next version of galium, the software that runs the .ing top level domain name. This update will be minor upgrade-wise (going from a 0.2 to a 0.3), but will provide a few new features, and will pave the way to galium 1.0.

What Galium 0.3 will do:

  • Enforce domain limits per user
  • Fix the last cron update “bug” (it’s not really a bug, but it is annoying)
  • Finally allow the adding of A, NS, MX etc records, so a glue name server is not required (this means that requests are handled by the slave servers directly! Can anyone spell speed increase?)
  • It will not have hardcoded SOA records…  this will be able to be changed. Somehow.

The future (Galium 0.4 and higher):

  • Allow domains to be registered via an API (probably with MyInfo)
  • Keep a backup of all (or some) previous generated TLD configurations somewhere
  • Support more backends then just BIND
  • Have a WHOIS server

Posted by & filed under OpenNIC.

My Galium top level domain software will get a minor update soon, which will fix a few [minor] outstanding issues.

  • Usernames can now contain the “-” character
  • The zone file generator will not always give the outputted revision as being “0” (this stopped all updates from not appearing on slave DNS servers until the following update on the next day … bad).
  • The cron that generates the zone file now reloads bind!

I will release this version as soon as it’s commited, and then begin working on the ability to add A, MX and a few other types of records. At the moment it only works via glues.

UPDATE: the new version of Galium was released, and can be downloaded from http://sharesource.org/project/galium/files/136/

Posted by & filed under Experimental.

A good friend of mine, Jordan Bracco recently forced me to rediscover Ruby on Rails. He told me that the new version, 1.9 is “5000x faster”, so I thought, well, why not!

The last version of Ruby I tried was either version 1.7 or 1.8, and it was not really something that I would say rocked my boat. It was slow, and just plain did not do (at that time what I though) I wanted.

Me being a version freak – and a speed freak, decided that I would go to the Ruby, check out their CVS repository out (seriously, these guys need to update to mercurial, just like Mozilla has!) and compiled Ruby’s latest trunk version.

The speed speaks for it’s self. A basic “Hello World” Ruby on Rails app does 700 requests a second, while a basic “Hello World” in PHP does 800. For this use case, yes, PHP is faster, but what you have to remember is that Ruby on Rails is much, much, much more sophisticated in terms of functionality.

I recently rewrote a page that is on ShareSource.org, and it is almost twice as fast. The difference here, is that the Ruby rewrite had no cache. Every single hit with Apache benchmark was generated on demand, while the PHP version of the ShareSource.org page in question was kept in cache for five minutes.

Aaaahhh, I am loving Ruby already.

Posted by & filed under OpenNIC.

Call it what you want, but I stiill think that .ing (or dotING as I have named it) is one of the best top level domains that is around at the moment.

All you need to take advantage of dotING is to be a user of OpenNIC. OpenNIC is a community effort to create an alternative root, which compliments that of the traditional ICANN root server. This means that OpenNIC is able to provide alternative top level domains. There are many reasons I don’t like ICANN, and ultimately don’t trust it, and RegisterFly is just the start of the reasons.

Switching to OpenNIC is easy to do, it’s as simple as changing your DNS settings, which you can read all about on the OpenNIC website.

A friend of mine, Tim Post, when I he gave me the idea about starting the .ing top level domain, created a list of all possible “premium” dotING domain names.

So, now is the time to switch to OpenNIC. Not only because there are many cool top level domains (like .ing, .geek or .oss) but also to push forward for a community controlled internet. Sure, we have open source operating systems and compilers, and we even have open source dns servers. Now at last, we have “open source” root servers.

Posted by & filed under Experimental, MyBanco.

Ever wanted to run your own bank? Well, my new [experimental] web application allows you to do exactly that. While some may say that I just have way too much time on my hands, others might just say that I should get top marks for my IPT [Information Processing Technology] assignment.

We had to build a database system, which implemented relational databases, and I thought, well, I could make my very own banking software, and fulfil one of my many dreams: to run my own bank.

The software, written in PHP was a testing ground for many new things that I have wanted to go and try, but never really had a project to try them out on.

I must say that MyBanco would have to be the first application that I have written with the mindset of handling around 700 transactions every second.

MyBanco uses a backend for it’s database which I have dubbed ‘MyInfo’. MyInfo is a JSON-RPC like protocol, which is easy to use, and can send multiple packets (I just thought then it might have been better to call these chunks… hmmmm) all at once, and get a response from all those packets. Think of it as a easy to read and faster to pharse version of XML-RPC.

I will chat at MyBanco a little more later, when the time is right, but for the moment this post will do :)

(hope you like the new blog!)