fixed string literal parsing; broder will test

[invirt/packages/invirt-dns.git] / invirt-dns

diff --git a/invirt-dns b/invirt-dns
index 3d95965..b2a9ac6 100755 (executable)
--- a/invirt-dns
+++ b/invirt-dns
@@ -3,6 +3,7 @@ from twisted.internet import reactor
 from twisted.names import server
 from twisted.names import dns
 from twisted.names import common
+from twisted.names import authority
 from twisted.internet import defer
 from twisted.python import failure
 
@@ -11,6 +12,7 @@ import invirt.database
 import psycopg2
 import sqlalchemy
 import time
+import re
 
 class DatabaseAuthority(common.ResolverBase):
     """An Authority that is loaded from a file."""
@@ -57,19 +59,6 @@ class DatabaseAuthority(common.ResolverBase):
         ttl = 900
         name = name.lower()
 
-        # XXX hack for the transition to two separate dev/prod clusters
-        if 'dev.xvm.mit.edu' in self.domains and name.endswith('prod.xvm.mit.edu'):
-            # import time, sys
-            # print time.localtime(), 'handling prod request', name
-            # sys.stdout.flush()
-
-            # Point the client in the right direction for prod requests.
-            authority = dns.RRHeader('prod.xvm.mit.edu', dns.NS, dns.IN, 3600,
-                    dns.Record_NS(name='ns1.prod.xvm.mit.edu', ttl=3600), auth=True)
-            additional = dns.RRHeader('ns1.prod.xvm.mit.edu', dns.A, dns.IN, 3600,
-                    dns.Record_A(address='18.181.0.221', ttl=3600), auth=True)
-            return defer.succeed(([], [authority], [additional]))
-
         if name in self.domains:
             domain = name
         else:
@@ -103,12 +92,6 @@ class DatabaseAuthority(common.ResolverBase):
                     results.append(dns.RRHeader(domain, dns.SOA, dns.IN,
                                                 ttl, self.soa, auth=True))
             else: # Request for a subdomain.
-                if 'passup' in dir(config.dns) and host in config.dns.passup:
-                    record = dns.Record_CNAME('%s.%s' % (host, config.dns.parent), ttl)
-                    return defer.succeed((
-                        [dns.RRHeader(name, dns.CNAME, dns.IN, ttl, record, auth=True)],
-                        [], []))
-
                 value = invirt.database.Machine.query().filter_by(name=host).first()
                 if value is None or not value.nics:
                     return defer.fail(failure.Failure(dns.AuthoritativeDomainError(name)))
@@ -131,11 +114,70 @@ class DatabaseAuthority(common.ResolverBase):
             #Doesn't exist
             return defer.fail(failure.Failure(dns.AuthoritativeDomainError(name)))
 
+class QuotingBindAuthority(authority.BindAuthority):
+    """
+    A BindAuthority that (almost) deals with quoting correctly
+    
+    This will catch double quotes as marking the start or end of a
+    quoted phrase, unless the double quote is escaped by a backslash
+    """
+    # Match either a quoted or unquoted string literal followed by
+    # whitespace or the end of line.  This yields two groups, one of
+    # which has a match, and the other of which is None, depending on
+    # whether the string literal was quoted or unquoted; this is what
+    # necessitates the subsequent filtering out of groups that are
+    # None.
+    string_pat = \
+            re.compile(r'"((?:[^"\\]|\\.)*)"|((?:[^\\\s]|\\.)+)(?:\s+|\s*$)')
+
+    # For interpreting escapes.
+    escape_pat = re.compile(r'\\(.)')
+
+    def collapseContinuations(self, lines):
+        L = []
+        state = 0
+        for line in lines:
+            if state == 0:
+                if line.find('(') == -1:
+                    L.append(line)
+                else:
+                    L.append(line[:line.find('(')])
+                    state = 1
+            else:
+                if line.find(')') != -1:
+                    L[-1] += ' ' + line[:line.find(')')]
+                    state = 0
+                else:
+                    L[-1] += ' ' + line
+        lines = L
+        L = []
+
+        for line in lines:
+            in_quote = False
+            split_line = []
+            for m in string_pat.finditer(line):
+                [x] = [x for x in m.groups() if x is not None]
+                split_line.append(escape_pat.sub(r'\1', x))
+            L.append(split_line)
+        return filter(None, L)
+
 if '__main__' == __name__:
-    resolver = DatabaseAuthority()
+    resolvers = []
+    for zone in config.dns.zone_files:
+        for origin in config.dns.domains:
+            r = QuotingBindAuthority(zone)
+            # This sucks, but if I want a generic zone file, I have to
+            # reload the information by hand
+            r.origin = origin
+            lines = open(zone).readlines()
+            lines = r.collapseContinuations(r.stripComments(lines))
+            r.parseLines(lines)
+            
+            resolvers.append(r)
+    resolvers.append(DatabaseAuthority())
 
     verbosity = 0
-    f = server.DNSServerFactory(authorities=[resolver], verbose=verbosity)
+    f = server.DNSServerFactory(authorities=resolvers, verbose=verbosity)
     p = dns.DNSDatagramProtocol(f)
     f.noisy = p.noisy = verbosity