Follow @Openwall on Twitter for new release announcements and other news
[<prev] [next>] [thread-next>] [day] [month] [year] [list]
Date: Mon, 15 Dec 2014 02:39:46 -0800
From: Brad Conroy <>
Subject: mDNS and alternate hostname database backends

I've been looking into using a simplified DNS caching mechanism using the file-
system as the "database" and came across this from the wiki:

> The inability to use mDNS (a multicast-DNS-based zero config system) with musl
> has been raised as an issue by users in the past. On glibc, using mDNS is
> accomplished with NSS; obviously musl does not have (or want) NSS.
> In principle, however, musl is fully extensible to use alternate hostname
> database backends in place of normal DNS. All that's needed is a daemon that
> runs on localhost, speaks DNS, and translates the requests to whatever backend
> is needed. However it's unclear whether there are any existing tools of this
> form. Developing one, adapting an existing DNS proxy program, or documenting
> how to setup an existing program that's already capable could be a nice future
> project.

My idea is much simpler: store the data as file name by the hostname (in /tmp ?):
/tmp/hosts/a for ipv4  (limit to 15/host so they can be stored in the inode*)
/tmp/hosts/aaaa for ipv6 (limit to 3/host *)
* of the filesystems capable of inlining data, ext4 has the lowest at 60 bytes.
This means we can just read/write an array of uint32_t for ipv4 and uint128_t
with something like:

	static int get_value(const char *path, void *buf,size_t len){
		int fd = open(path, O_RDONLY);
		if (fd<0) return fd;
		return len;
	static int set_value(const char *path, void *buf,size_t len){
		int fd = open(path, O_CREAT|O_WRONLY|O_TRUNC);
		if (fd<0) return fd;
		return len;

The existing systems /etc/hosts* don't account for TTL, but using the filesystem
we can hack this feature pretty simply using the filesystem by adding the TTL
to the modification time.

	struct utimbuf ut={.actime=st.st_atime, .modtime=ttl+st.st_mtime};

Note: I chose mod time for TTL since a file system may be mounted noatime

if /tmp/hosts/a (or aaaa for ipv6) does not exist
   1. mkdir
   2. read in /etc/hosts to our format
       a.) for and and their mathing ipv6 counterparts :: and ::1,
            create a hard link to NULL and localhost
       b.)similarly create hard links for aliases. for example:


/tmp/hosts/a/ will contain a uint32_t representing
with a modification time set to INT_MAX
  /tmp/hosts/a/  --hardlink--> /tmp/hosts/a/
  /tmp/hosts/a/ --hardlink--> /tmp/hosts/a/
  /tmp/hosts/a/ --hardlink--> /tmp/hosts/a/

This seems pretty over-simplified, but it opens up some possibilities:

 1. the network functions could be much smaller and rely on a single binary to do
     all of the hard work in a unix style.  Before anyone argues that starting an
     external program takes too long, I must point out that this is typically
     insignificant compared to DNS query/response time and that keeping this
     functionality internal to the libc requires making certain tradeoffs to keep
     the overall code size and complexity down.  Other functions already call
     /bin/sh IIRC, so this isn't a huge leap. ... though all code _could_ stay in
     the libc if there is a good argument for it.
2.  sharing caches between clients now becomes as easy as using rsync or
     even tar or cpio.
3.  A cron task can replace a running daemon to periodically clean up the cache
     If disk space is low, it can purge or it could even systematically recheck the
     DNS, update the TTL and even ping all the entries to get a response time so
     it can sort them from fastest to slowest entries 
4.  Ad-blocking can be as simple as:
       cd /tmp/hosts/a;
       ln NULL
5.  Filtering can also be accomplish using standard users/groups.
     blacklist filtering by making them hardlinks to NULL
     whitelist filtering by making /tmp/hosts read only
6.  Because the cache is so simple, integrating it to work with other caching
     methods like nss/nscd, libresolvconf, dnsmasq, djbdns and bind _should_
     be fairly straight forward.

I've been working on my own rudimentary implementation to include with my
own libc.h headers, (only for small, single file static apps) but I primarily use
musl, so I'd be interested in hearing any feedback, especially if there is a
possibility that it could become a standard practice.  My guess is that it has
probably already been done by Bell Labs for Plan.

Brad Conroy

Powered by blists - more mailing lists

Confused about mailing lists and their use? Read about mailing lists on Wikipedia and check out these guidelines on proper formatting of your messages.