Blogaria

Oh the joy of having code to work on where you can tinker around and fix stuff. Oh the even bigger joy when it's your own code. Well, to summarize: I started writing my own simple straight-thru proxy where I know what's happening and why, and where I can freely tinker around. I'll post it on this site once I'm comfortable with it. In the mean time: here's a preview of how the DNS issue can be fixed.

Below is a C++ function dnsresolve() which takes one argument: a hostname. Its address is returned as an in_addr_t struct. The function basically just wraps gethostbyname() but additionally it does two things:

• DNS entries are cached. Typically a browser will request a page from http://somesite/index.html, then the index page will lead to a multitude of requests like http://somesite/stylesheet.css, http://somesite/logo.png, and what not. So caching DNS entries makes sense: subsequent requests from a site don't have to be resolved.
• When a DNS lookup fails, then the resolver function res_init() is called. There's the missing part! This was what I was looking for all along in Squid or HTTP::Proxy... Having this in the code means that after a sleep/wake cycle, the first DNS lookup will fail but that this lookup will invoke res_init(). If the network is up and running by that time, then next lookups will succeed by using the new resolver environment. From the manpage: The res_init() routine reads the configuration file (if any; see resolver(5)) to get the default domain name, search list and the Internet address of the local name server(s). Brilliant. That's exactly what I needed, and now I know where to get it.

#include "main"

// Single DNS entry in the cache: address and the time it was resolved
struct DnsEntry {
    in_addr_t dnsresult;
    int lookuptime;
};

// Typedefs: map of entries, iterator
typedef std::map<string, DnsEntry> DnsMap;
typedef DnsMap::iterator DnsMapIterator;

// Cache of entries
static DnsMap dnsmap;

// dnsresolve("hostname") returns the resolved name as an in_addr_t type
// and caches the result. The cache expiry is 'nsexpiry' seconds.
// Upon failure a string exception is thrown.
in_addr_t dnsresolve(string const &host) {

    // See if we have the record stored yet and if it's still recent.
    DnsMapIterator it = dnsmap.find(host);
    if (it != dnsmap.end()) {
        DnsEntry entry = dnsmap[host];
        if (entry.lookuptime >= time(0) - nsexpiry) {
            MSG(4, (msg << "DNS cache for " << host << " still valid"));
            return entry.dnsresult;
        }
    }

    // Not found or expired. Look up.
    mutex_lock((void*)gethostbyname);
    struct hostent *hostaddr = gethostbyname(host.c_str());
    mutex_unlock((void*)gethostbyname);

    // If lookup is succesful: enter in cache. Else throw exception and reset
    // the resolver lib. A next time might be successful - e.g. after a
    // laptop wakeup on a new network (then the daemon must be kicked into
    // life).
    if (hostaddr) {     
        DnsEntry entry;
        MSG(4, (msg << "DNS queried succesfully for " << host));
        memcpy(&entry.dnsresult, hostaddr->h_addr_list[0], sizeof(in_addr_t));
        entry.lookuptime = time(0);
        dnsmap[host] = entry;
        return entry.dnsresult;
    } else {
        ostringstream o;
        o << "Failed to resolve downstream host " << host
          << ": " << strerror(errno);
        res_init();
        throw o.str();
    }
}