net.lisp, zone.lisp: Improve commentary and docstrings.

[zone] / zone.lisp

diff --git a/zone.lisp b/zone.lisp
index 0e0ed47..9e5795d 100644 (file)
--- a/zone.lisp
+++ b/zone.lisp
@@ -27,21 +27,7 @@
 (defpackage #:zone
   (:use #:common-lisp
        #:mdw.base #:mdw.str #:collect #:safely
 (defpackage #:zone
   (:use #:common-lisp
        #:mdw.base #:mdw.str #:collect #:safely

-       #:net #:net-sys #:services)
-  (:export #:soa #:mx #:zone #:zone-record #:zone-subdomain
-          #:*default-zone-source* #:*default-zone-refresh*
-            #:*default-zone-retry* #:*default-zone-expire*
-            #:*default-zone-min-ttl* #:*default-zone-ttl*
-            #:*default-mx-priority* #:*default-zone-admin*
-          #:*zone-output-path*
-          #:*preferred-subnets* #:zone-preferred-subnet-p
-          #:preferred-subnet-case
-          #:zone-find #:zone-parse #:zone-write #:zone-create #:defzone
-          #:defrevzone #:zone-save #:zone-make-name
-          #:defzoneparse #:zone-parse-host
-          #:bind-hostname #:bind-record #:bind-format-record
-          #:bind-record-type #:bind-record-format-args
-          #:timespec-seconds #:make-zone-serial))
+       #:net #:services))

 
 (in-package #:zone)
 
 
 (in-package #:zone)
 


@@ -73,10 +59,12 @@
        (push r a)
        (setf val q)))))
 
        (push r a)
        (setf val q)))))
 

+(export 'timespec-seconds)

 (defun timespec-seconds (ts)
 (defun timespec-seconds (ts)

-  "Convert a timespec TS to seconds.  A timespec may be a real count of
-   seconds, or a list (COUNT UNIT): UNIT may be any of a number of obvious
-   time units."
+  "Convert a timespec TS to seconds.
+
+   A timespec may be a real count of seconds, or a list (COUNT UNIT).  UNIT
+   may be any of a number of obvious time units."

   (cond ((null ts) 0)
        ((realp ts) (floor ts))
        ((atom ts)
   (cond ((null ts) 0)
        ((realp ts) (floor ts))
        ((atom ts)


@@ -103,10 +91,11 @@
     (maphash (lambda (key val) (declare (ignore val)) (collect key)) ht)))
 
 (defun iso-date (&optional time &key datep timep (sep #\ ))
     (maphash (lambda (key val) (declare (ignore val)) (collect key)) ht)))
 
 (defun iso-date (&optional time &key datep timep (sep #\ ))

-  "Construct a textual date or time in ISO format.  The TIME is the universal
-   time to convert, which defaults to now; DATEP is whether to emit the date;
-   TIMEP is whether to emit the time, and SEP (default is space) is how to
-   separate the two."
+  "Construct a textual date or time in ISO format.
+
+   The TIME is the universal time to convert, which defaults to now; DATEP is
+   whether to emit the date; TIMEP is whether to emit the time, and
+   SEP (default is space) is how to separate the two."

   (multiple-value-bind
       (sec min hr day mon yr dow dstp tz)
       (decode-universal-time (if (or (null time) (eq time :now))
   (multiple-value-bind
       (sec min hr day mon yr dow dstp tz)
       (decode-universal-time (if (or (null time) (eq time :now))


@@ -124,6 +113,7 @@
 ;;;--------------------------------------------------------------------------
 ;;; Zone types.
 
 ;;;--------------------------------------------------------------------------
 ;;; Zone types.
 

+(export 'soa)

 (defstruct (soa (:predicate soap))
   "Start-of-authority record information."
   source
 (defstruct (soa (:predicate soap))
   "Start-of-authority record information."
   source


@@ -134,11 +124,13 @@
   min-ttl
   serial)
 
   min-ttl
   serial)
 

+(export 'mx)

 (defstruct (mx (:predicate mxp))
   "Mail-exchange record information."
   priority
   domain)
 
 (defstruct (mx (:predicate mxp))
   "Mail-exchange record information."
   priority
   domain)
 

+(export 'zone)

 (defstruct (zone (:predicate zonep))
   "Zone information."
   soa
 (defstruct (zone (:predicate zonep))
   "Zone information."
   soa


@@ -149,29 +141,37 @@
 ;;;--------------------------------------------------------------------------
 ;;; Zone defaults.  It is intended that scripts override these.
 
 ;;;--------------------------------------------------------------------------
 ;;; Zone defaults.  It is intended that scripts override these.
 

+(export '*default-zone-source*)

 (defvar *default-zone-source*
   (let ((hn (gethostname)))
     (and hn (concatenate 'string (canonify-hostname hn) ".")))
   "The default zone source: the current host's name.")
 
 (defvar *default-zone-source*
   (let ((hn (gethostname)))
     (and hn (concatenate 'string (canonify-hostname hn) ".")))
   "The default zone source: the current host's name.")
 

+(export '*default-zone-refresh*)

 (defvar *default-zone-refresh* (* 24 60 60)
   "Default zone refresh interval: one day.")
 
 (defvar *default-zone-refresh* (* 24 60 60)
   "Default zone refresh interval: one day.")
 

+(export '*default-zone-admin*)

 (defvar *default-zone-admin* nil
   "Default zone administrator's email address.")
 
 (defvar *default-zone-admin* nil
   "Default zone administrator's email address.")
 

+(export '*default-zone-retry*)

 (defvar *default-zone-retry* (* 60 60)
   "Default znoe retry interval: one hour.")
 
 (defvar *default-zone-retry* (* 60 60)
   "Default znoe retry interval: one hour.")
 

+(export '*default-zone-expire*)

 (defvar *default-zone-expire* (* 14 24 60 60)
   "Default zone expiry time: two weeks.")
 
 (defvar *default-zone-expire* (* 14 24 60 60)
   "Default zone expiry time: two weeks.")
 

+(export '*default-zone-min-ttl*)

 (defvar *default-zone-min-ttl* (* 4 60 60)
   "Default zone minimum TTL/negative TTL: four hours.")
 
 (defvar *default-zone-min-ttl* (* 4 60 60)
   "Default zone minimum TTL/negative TTL: four hours.")
 

+(export '*default-zone-ttl*)

 (defvar *default-zone-ttl* (* 8 60 60)
   "Default zone TTL (for records without explicit TTLs): 8 hours.")
 
 (defvar *default-zone-ttl* (* 8 60 60)
   "Default zone TTL (for records without explicit TTLs): 8 hours.")
 

+(export '*default-mx-priority*)

 (defvar *default-mx-priority* 50
   "Default MX priority.")
 
 (defvar *default-mx-priority* 50
   "Default MX priority.")
 


@@ -181,14 +181,15 @@
 (defvar *zones* (make-hash-table :test #'equal)
   "Map of known zones.")
 
 (defvar *zones* (make-hash-table :test #'equal)
   "Map of known zones.")
 

+(export 'zone-find)

 (defun zone-find (name)
   "Find a zone given its NAME."
   (gethash (string-downcase (stringify name)) *zones*))
 (defun zone-find (name)
   "Find a zone given its NAME."
   (gethash (string-downcase (stringify name)) *zones*))

-

 (defun (setf zone-find) (zone name)
   "Make the zone NAME map to ZONE."
   (setf (gethash (string-downcase (stringify name)) *zones*) zone))
 
 (defun (setf zone-find) (zone name)
   "Make the zone NAME map to ZONE."
   (setf (gethash (string-downcase (stringify name)) *zones*) zone))
 

+(export 'zone-record)

 (defstruct (zone-record (:conc-name zr-))
   "A zone record."
   (name '<unnamed>)
 (defstruct (zone-record (:conc-name zr-))
   "A zone record."
   (name '<unnamed>)


@@ -197,16 +198,25 @@
   (make-ptr-p nil)
   data)
 
   (make-ptr-p nil)
   data)
 

+(export 'zone-subdomain)

 (defstruct (zone-subdomain (:conc-name zs-))
 (defstruct (zone-subdomain (:conc-name zs-))

-  "A subdomain.  Slightly weird.  Used internally by zone-process-records
-   below, and shouldn't escape."
+  "A subdomain.
+
+   Slightly weird.  Used internally by `zone-process-records', and shouldn't
+   escape."

   name
   ttl
   records)
 
   name
   ttl
   records)
 

-(defvar *zone-output-path* *default-pathname-defaults*
-  "Pathname defaults to merge into output files.")
+(export '*zone-output-path*)
+(defvar *zone-output-path* nil
+  "Pathname defaults to merge into output files.

 
 

+   If this is nil then use the prevailing `*default-pathname-defaults*'.
+   This is not the same as capturing the `*default-pathname-defaults*' from
+   load time.")
+
+(export '*preferred-subnets*)

 (defvar *preferred-subnets* nil
   "Subnets to prefer when selecting defaults.")
 
 (defvar *preferred-subnets* nil
   "Subnets to prefer when selecting defaults.")
 


@@ -217,16 +227,20 @@
   "Choose a file name for a given ZONE and TYPE."
   (merge-pathnames (make-pathname :name (string-downcase zone)
                                  :type (string-downcase type))
   "Choose a file name for a given ZONE and TYPE."
   (merge-pathnames (make-pathname :name (string-downcase zone)
                                  :type (string-downcase type))

-                  *zone-output-path*))
+                  (or *zone-output-path* *default-pathname-defaults*)))

 
 

+(export 'zone-preferred-subnet-p)

 (defun zone-preferred-subnet-p (name)
   "Answer whether NAME (a string or symbol) names a preferred subnet."
   (member name *preferred-subnets* :test #'string-equal))
 
 (defun zone-preferred-subnet-p (name)
   "Answer whether NAME (a string or symbol) names a preferred subnet."
   (member name *preferred-subnets* :test #'string-equal))
 

+(export 'preferred-subnet-case)

 (defmacro preferred-subnet-case (&body clauses)
 (defmacro preferred-subnet-case (&body clauses)

-  "CLAUSES have the form (SUBNETS . FORMS) -- evaluate the first FORMS whose
-   SUBNETS (a list or single symbol, not evaluated) are considered preferred
-   by zone-preferred-subnet-p.  If SUBNETS is the symbol t then the clause
+  "Execute a form based on which networks are considered preferred.
+
+   The CLAUSES have the form (SUBNETS . FORMS) -- evaluate the first FORMS
+   whose SUBNETS (a list or single symbol, not evaluated) are listed in
+   `*preferred-subnets*'.  If SUBNETS is the symbol `t' then the clause

    always matches."
   `(cond
     ,@(mapcar (lambda (clause)
    always matches."
   `(cond
     ,@(mapcar (lambda (clause)


@@ -244,9 +258,47 @@
              clauses)))
 
 (defun zone-process-records (rec ttl func)
              clauses)))
 
 (defun zone-process-records (rec ttl func)

-  "Sort out the list of records in REC, calling FUNC for each one.  TTL is
-   the default time-to-live for records which don't specify one."
+  "Sort out the list of records in REC, calling FUNC for each one.
+
+   TTL is the default time-to-live for records which don't specify one.
+
+   REC is a list of records of the form
+
+       ({ :ttl TTL | TYPE DATA | (LABEL . REC) }*)
+
+   The various kinds of entries have the following meanings.
+
+   :ttl TTL            Set the TTL for subsequent records (at this level of
+                         nesting only).
+
+   TYPE DATA           Define a record with a particular TYPE and DATA.
+                         Record types are defined using `defzoneparse' and
+                         the syntax of the data is idiosyncratic.
+
+   ((LABEL ...) . REC) Define records for labels within the zone.  Any
+                         records defined within REC will have their domains
+                         prefixed by each of the LABELs.  A singleton list
+                         of labels may instead be written as a single
+                         label.  Note, therefore, that
+
+                               (host (sub :a \"169.254.1.1\"))
+
+                         defines a record for `host.sub' -- not `sub.host'.
+
+   If REC contains no top-level records, but it does define records for a
+   label listed in `*preferred-subnets*', then the records for the first such
+   label are also promoted to top-level.
+
+   The FUNC is called for each record encountered, represented as a
+   `zone-record' object.  Zone parsers are not called: you get the record
+   types and data from the input form; see `zone-parse-records' if you want
+   the raw output."
+

   (labels ((sift (rec ttl)
   (labels ((sift (rec ttl)

+            ;; Parse the record list REC into lists of `zone-record' and
+            ;; `zone-subdomain' objects, sorting out TTLs and so on.
+            ;; Returns them as two values.
+

             (collecting (top sub)
               (loop
                 (unless rec
             (collecting (top sub)
               (loop
                 (unless rec


@@ -267,16 +319,21 @@
                                     sub)))
                         (t
                          (error "Unexpected record form ~A" (car r))))))))
                                     sub)))
                         (t
                          (error "Unexpected record form ~A" (car r))))))))

+

           (process (rec dom ttl)
           (process (rec dom ttl)

+            ;; Recursirvely process the record list REC, with a list DOM of
+            ;; prefix labels, and a default TTL.  Promote records for a
+            ;; preferred subnet to toplevel if there are no toplevel records
+            ;; already.
+

             (multiple-value-bind (top sub) (sift rec ttl)
               (if (and dom (null top) sub)
             (multiple-value-bind (top sub) (sift rec ttl)
               (if (and dom (null top) sub)

-                  (let ((preferred nil))
-                    (dolist (s sub)
-                      (when (some #'zone-preferred-subnet-p
-                                  (listify (zs-name s)))
-                        (setf preferred s)))
-                    (unless preferred
-                      (setf preferred (car sub)))
+                  (let ((preferred
+                         (or (find-if (lambda (s)
+                                        (some #'zone-preferred-subnet-p
+                                              (listify (zs-name s))))
+                                      sub)
+                             (car sub))))

                     (when preferred
                       (process (zs-records preferred)
                                dom
                     (when preferred
                       (process (zs-records preferred)
                                dom


@@ -291,11 +348,16 @@
                 (process (zs-records s)
                          (cons (zs-name s) dom)
                          (zs-ttl s))))))
                 (process (zs-records s)
                          (cons (zs-name s) dom)
                          (zs-ttl s))))))

+
+    ;; Process the records we're given with no prefix.

     (process rec nil ttl)))
 
     (process rec nil ttl)))
 

+(export 'zone-parse-host)

 (defun zone-parse-host (f zname)
 (defun zone-parse-host (f zname)

-  "Parse a host name F: if F ends in a dot then it's considered absolute;
-   otherwise it's relative to ZNAME."
+  "Parse a host name F.
+
+   If F ends in a dot then it's considered absolute; otherwise it's relative
+   to ZNAME."

   (setf f (stringify f))
   (cond ((string= f "@") (stringify zname))
        ((and (plusp (length f))
   (setf f (stringify f))
   (cond ((string= f "@") (stringify zname))
        ((and (plusp (length f))


@@ -372,9 +434,12 @@
 ;;;--------------------------------------------------------------------------
 ;;; Serial numbering.
 
 ;;;--------------------------------------------------------------------------
 ;;; Serial numbering.
 

+(export 'make-zone-serial)

 (defun make-zone-serial (name)
 (defun make-zone-serial (name)

-  "Given a zone NAME, come up with a new serial number.  This will (very
-   carefully) update a file ZONE.serial in the current directory."
+  "Given a zone NAME, come up with a new serial number.
+
+   This will (very carefully) update a file ZONE.serial in the current
+   directory."

   (let* ((file (zone-file-name name :serial))
         (last (with-open-file (in file
                                   :direction :input
   (let* ((file (zone-file-name name :serial))
         (last (with-open-file (in file
                                   :direction :input


@@ -392,8 +457,8 @@
     (safely-writing (out file)
       (format out
              ";; Serial number file for zone ~A~%~
     (safely-writing (out file)
       (format out
              ";; Serial number file for zone ~A~%~

-               ;;   (LAST-SEQ DAY MONTH YEAR)~%~
-               ~S~%"
+              ;;   (LAST-SEQ DAY MONTH YEAR)~%~
+              ~S~%"

              name
              (cons seq now)))
     (from-mixed-base '(100 100 100) (reverse (cons seq now)))))
              name
              (cons seq now)))
     (from-mixed-base '(100 100 100) (reverse (cons seq now)))))


@@ -402,10 +467,12 @@
 ;;; Zone form parsing.
 
 (defun zone-parse-head (head)
 ;;; Zone form parsing.
 
 (defun zone-parse-head (head)

-  "Parse the HEAD of a zone form.  This has the form
+  "Parse the HEAD of a zone form.
+
+   This has the form

 
      (NAME &key :source :admin :refresh :retry
 
      (NAME &key :source :admin :refresh :retry

-                :expire :min-ttl :ttl :serial)
+               :expire :min-ttl :ttl :serial)

 
    though a singleton NAME needn't be a list.  Returns the default TTL and an
    soa structure representing the zone head."
 
    though a singleton NAME needn't be a list.  Returns the default TTL and an
    soa structure representing the zone head."


@@ -432,7 +499,13 @@
                      :min-ttl (timespec-seconds min-ttl)
                      :serial serial))))
 
                      :min-ttl (timespec-seconds min-ttl)
                      :serial serial))))
 

+(export 'zone-make-name)

 (defun zone-make-name (prefix zone-name)
 (defun zone-make-name (prefix zone-name)

+  "Compute a full domain name from a PREFIX and a ZONE-NAME.
+
+   If the PREFIX ends with `.' then it's absolute already; otherwise, append
+   the ZONE-NAME, separated with a `.'.  If PREFIX is nil, or `@', then
+   return the ZONE-NAME only."

   (if (or (not prefix) (string= prefix "@"))
       zone-name
       (let ((len (length prefix)))
   (if (or (not prefix) (string= prefix "@"))
       zone-name
       (let ((len (length prefix)))


@@ -440,13 +513,17 @@
            (join-strings #\. (list prefix zone-name))
            prefix))))
 
            (join-strings #\. (list prefix zone-name))
            prefix))))
 

+(export 'defzoneparse)

 (defmacro defzoneparse (types (name data list
                               &key (prefix (gensym "PREFIX"))
 (defmacro defzoneparse (types (name data list
                               &key (prefix (gensym "PREFIX"))

-                                   (zname (gensym "ZNAME"))
-                                   (ttl (gensym "TTL")))
+                                   (zname (gensym "ZNAME"))
+                                   (ttl (gensym "TTL")))

                        &body body)
                        &body body)

-  "Define a new zone record type (or TYPES -- a list of synonyms is
-   permitted).  The arguments are as follows:
+  "Define a new zone record type.
+
+   The arguments are as follows:
+
+   TYPES       A singleton type symbol, or a list of aliases.

 
    NAME                The name of the record to be added.
 
 
    NAME                The name of the record to be added.
 


@@ -496,29 +573,28 @@
                                                   :make-ptr-p ,tmakeptrp)
                                 ,col)))
                 ,@body)))
                                                   :make-ptr-p ,tmakeptrp)
                                 ,col)))
                 ,@body)))

-         ',type)))))
-
-(defun zone-parse-records (zone records)
-  (let ((zname (zone-name zone)))
-    (with-collection (rec)
-       (flet ((parse-record (zr)
-                (let ((func (or (get (zr-type zr) 'zone-parse)
-                                (error "No parser for record ~A."
-                                       (zr-type zr))))
-                      (name (and (zr-name zr) (stringify (zr-name zr)))))
-                  (funcall func
-                           name
-                           zname
-                           (zr-data zr)
-                           (zr-ttl zr)
-                           rec))))
-         (zone-process-records records
-                               (zone-default-ttl zone)
-                               #'parse-record))
-      (setf (zone-records zone) (nconc (zone-records zone) rec)))))
-
+          ',type)))))
+
+(export 'zone-parse-records)
+(defun zone-parse-records (zname ttl records)
+  "Parse a sequence of RECORDS and return a list of raw records.
+
+   The records are parsed relative to the zone name ZNAME, and using the
+   given default TTL."
+  (collecting (rec)
+    (flet ((parse-record (zr)
+            (let ((func (or (get (zr-type zr) 'zone-parse)
+                            (error "No parser for record ~A."
+                                   (zr-type zr))))
+                  (name (and (zr-name zr) (stringify (zr-name zr)))))
+              (funcall func name zname (zr-data zr) (zr-ttl zr) rec))))
+      (zone-process-records records ttl #'parse-record))))
+
+(export 'zone-parse)

 (defun zone-parse (zf)
 (defun zone-parse (zf)

-  "Parse a ZONE form.  The syntax of a zone form is as follows:
+  "Parse a ZONE form.
+
+   The syntax of a zone form is as follows:

 
    ZONE-FORM:
      ZONE-HEAD ZONE-RECORD*
 
    ZONE-FORM:
      ZONE-HEAD ZONE-RECORD*


@@ -527,13 +603,12 @@
      ((NAME*) ZONE-RECORD*)
    | SYM ARGS"
   (multiple-value-bind (zname ttl soa) (zone-parse-head (car zf))
      ((NAME*) ZONE-RECORD*)
    | SYM ARGS"
   (multiple-value-bind (zname ttl soa) (zone-parse-head (car zf))

-    (let ((zone (make-zone :name zname
-                          :default-ttl ttl
-                          :soa soa
-                          :records nil)))
-      (zone-parse-records zone (cdr zf))
-      zone)))
+    (make-zone :name zname
+              :default-ttl ttl
+              :soa soa
+              :records (zone-parse-records zname ttl (cdr zf)))))

 
 

+(export 'zone-create)

 (defun zone-create (zf)
   "Zone construction function.  Given a zone form ZF, construct the zone and
    add it to the table."
 (defun zone-create (zf)
   "Zone construction function.  Given a zone form ZF, construct the zone and
    add it to the table."


@@ -542,10 +617,12 @@
     (setf (zone-find name) zone)
     name))
 
     (setf (zone-find name) zone)
     name))
 

+(export 'defzone)

 (defmacro defzone (soa &rest zf)
   "Zone definition macro."
   `(zone-create '(,soa ,@zf)))
 
 (defmacro defzone (soa &rest zf)
   "Zone definition macro."
   `(zone-create '(,soa ,@zf)))
 

+(export 'defrevzone)

 (defmacro defrevzone (head &rest zf)
   "Define a reverse zone, with the correct name."
   (destructuring-bind
 (defmacro defrevzone (head &rest zf)
   "Define a reverse zone, with the correct name."
   (destructuring-bind


@@ -579,6 +656,98 @@
   ":txt TEXT"
   (rec :data data))
 
   ":txt TEXT"
   (rec :data data))
 

+(export '*dkim-pathname-defaults*)
+(defvar *dkim-pathname-defaults*
+  (make-pathname :directory '(:relative "keys")
+                :type "dkim"))
+
+(defzoneparse :dkim (name data rec)
+  ":dkim (KEYFILE {:TAG VALUE}*)"
+  (destructuring-bind (file &rest plist) (listify data)
+    (let ((things nil) (out nil))
+      (labels ((flush ()
+                (when out
+                  (push (get-output-stream-string out) things)
+                  (setf out nil)))
+              (emit (text)
+                (let ((len (length text)))
+                  (when (and out (> (+ (file-position out)
+                                       (length text))
+                                    64))
+                    (flush))
+                  (when (plusp len)
+                    (cond ((< len 64)
+                           (unless out (setf out (make-string-output-stream)))
+                           (write-string text out))
+                          (t
+                           (do ((i 0 j)
+                                (j 64 (+ j 64)))
+                               ((>= i len))
+                             (push (subseq text i (min j len)) things))))))))
+       (do ((p plist (cddr p)))
+           ((endp p))
+         (emit (format nil "~(~A~)=~A;" (car p) (cadr p))))
+       (emit (with-output-to-string (out)
+               (write-string "p=" out)
+               (when file
+                 (with-open-file
+                     (in (merge-pathnames file *dkim-pathname-defaults*))
+                   (loop
+                     (when (string= (read-line in)
+                                    "-----BEGIN PUBLIC KEY-----")
+                       (return)))
+                   (loop
+                     (let ((line (read-line in)))
+                       (if (string= line "-----END PUBLIC KEY-----")
+                           (return)
+                           (write-string line out)))))))))
+      (rec :type :txt
+          :data (nreverse things)))))
+
+(eval-when (:load-toplevel :execute)
+  (dolist (item '((sshfp-algorithm rsa 1)
+                 (sshfp-algorithm dsa 2)
+                 (sshfp-algorithm ecdsa 3)
+                 (sshfp-type sha-1 1)
+                 (sshfp-type sha-256 2)))
+    (destructuring-bind (prop sym val) item
+      (setf (get sym prop) val)
+      (export sym))))
+
+(export '*sshfp-pathname-defaults*)
+(defvar *sshfp-pathname-defaults*
+  (make-pathname :directory '(:relative "keys")
+                :type "sshfp"))
+
+(defzoneparse :sshfp (name data rec)
+  ":sshfp { FILENAME | ((FPR :alg ALG :type HASH)*) }"
+  (if (stringp data)
+      (with-open-file (in (merge-pathnames data *sshfp-pathname-defaults*))
+       (loop (let ((line (read-line in nil)))
+               (unless line (return))
+               (let ((words (str-split-words line)))
+                 (pop words)
+                 (when (string= (car words) "IN") (pop words))
+                 (unless (and (string= (car words) "SSHFP")
+                              (= (length words) 4))
+                   (error "Invalid SSHFP record."))
+                 (pop words)
+                 (destructuring-bind (alg type fpr) words
+                   (rec :data (list (parse-integer alg)
+                                    (parse-integer type)
+                                    fpr)))))))
+      (flet ((lookup (what prop)
+              (etypecase what
+                (fixnum what)
+                (symbol (or (get what prop)
+                            (error "~S is not a known ~A" what prop))))))
+       (dolist (item (listify data))
+         (destructuring-bind (fpr &key (alg 'rsa) (type 'sha-1))
+             (listify item)
+           (rec :data (list (lookup alg 'sshfp-algorithm)
+                            (lookup type 'sshfp-type)
+                            fpr)))))))
+

 (defzoneparse :mx (name data rec :zname zname)
   ":mx ((HOST :prio INT :ip IPADDR)*)"
   (dolist (mx (listify data))
 (defzoneparse :mx (name data rec :zname zname)
   ":mx ((HOST :prio INT :ip IPADDR)*)"
   (dolist (mx (listify data))


@@ -641,12 +810,16 @@
       (rec :name (zone-parse-host "mask" name)
           :type :a
           :data (ipnet-mask n))
       (rec :name (zone-parse-host "mask" name)
           :type :a
           :data (ipnet-mask n))

-      (rec :name (zone-parse-host "broadcast" name)
+      (rec :name (zone-parse-host "bcast" name)

           :type :a
           :data (ipnet-broadcast n)))))
 
 (defzoneparse (:rev :reverse) (name data rec)
           :type :a
           :data (ipnet-broadcast n)))))
 
 (defzoneparse (:rev :reverse) (name data rec)

-  ":reverse ((NET :bytes BYTES) ZONE*)"
+  ":reverse ((NET :bytes BYTES) ZONE*)
+
+   Add a reverse record each host in the ZONEs (or all zones) that lies
+   within NET.  The BYTES give the number of prefix labels generated; this
+   defaults to the smallest number of bytes needed to enumerate the net."

   (setf data (listify data))
   (destructuring-bind (net &key bytes) (listify (car data))
     (setf net (zone-parse-net net name))
   (setf data (listify data))
   (destructuring-bind (net &key bytes) (listify (car data))
     (setf net (zone-parse-net net name))


@@ -673,48 +846,62 @@
                (setf (gethash name seen) t)))))))))
 
 (defzoneparse (:cidr-delegation :cidr) (name data rec :zname zname)
                (setf (gethash name seen) t)))))))))
 
 (defzoneparse (:cidr-delegation :cidr) (name data rec :zname zname)

-  ":cidr-delegation ((NET :bytes BYTES) (TARGET-NET [TARGET-ZONE])*)"
+  ":cidr-delegation ((NET :bytes BYTES) ((TARGET-NET*) [TARGET-ZONE])*)
+
+   Insert CNAME records for delegating a portion of the reverse-lookup
+   namespace which doesn't align with an octet boundary.
+
+   The NET specifies the origin network, in which the reverse records
+   naturally lie.  The BYTES are the number of labels to supply for each
+   address; the default is the smallest number which suffices to enumerate
+   the entire NET.  The TARGET-NETs are subnets of NET which are to be
+   delegated.  The TARGET-ZONEs are the zones to which we are delegating
+   authority for the reverse records: the default is to append labels for those
+   octets of the subnet base address which are not the same in all address in
+   the subnet."

   (setf data (listify data))
   (destructuring-bind (net &key bytes) (listify (car data))
     (setf net (zone-parse-net net name))
     (unless bytes
       (setf bytes (ipnet-changeable-bytes (ipnet-mask net))))
     (dolist (map (or (cdr data) (list (list net))))
   (setf data (listify data))
   (destructuring-bind (net &key bytes) (listify (car data))
     (setf net (zone-parse-net net name))
     (unless bytes
       (setf bytes (ipnet-changeable-bytes (ipnet-mask net))))
     (dolist (map (or (cdr data) (list (list net))))

-      (destructuring-bind (tnet &optional tdom) (listify map)
-       (setf tnet (zone-parse-net tnet name))
-       (unless (ipnet-subnetp net tnet)
-         (error "~A is not a subnet of ~A."
-                (ipnet-pretty tnet)
-                (ipnet-pretty net)))
-       (unless tdom
-         (with-ipnet (net mask) tnet
-           (setf tdom
-                 (join-strings
-                  #\.
-                  (append (reverse (loop
-                                    for i from (1- bytes) downto 0
-                                    until (zerop (logand mask
-                                                         (ash #xff
-                                                              (* 8 i))))
-                                    collect (ldb (byte 8 (* i 8)) net)))
-                          (list name))))))
-       (setf tdom (string-downcase (stringify tdom)))
-       (dotimes (i (ipnet-hosts tnet))
-         (unless (zerop i)
-           (let* ((addr (ipnet-host tnet i))
-                  (tail (join-strings #\.
-                                      (loop
-                                       for i from 0 below bytes
-                                       collect
-                                       (logand #xff
-                                               (ash addr (* 8 i)))))))
-             (rec :name (format nil "~A.~A" tail name)
-                  :type :cname
-                  :data (format nil "~A.~A" tail tdom)))))))))
+      (destructuring-bind (tnets &optional tdom) (listify map)
+       (dolist (tnet (listify tnets))
+         (setf tnet (zone-parse-net tnet name))
+         (unless (ipnet-subnetp net tnet)
+           (error "~A is not a subnet of ~A."
+                  (ipnet-pretty tnet)
+                  (ipnet-pretty net)))
+         (unless tdom
+           (with-ipnet (net mask) tnet
+             (setf tdom
+                   (join-strings
+                    #\.
+                    (append (reverse (loop
+                                      for i from (1- bytes) downto 0
+                                      until (zerop (logand mask
+                                                           (ash #xff
+                                                                (* 8 i))))
+                                      collect (ldb (byte 8 (* i 8)) net)))
+                            (list name))))))
+         (setf tdom (string-downcase (stringify tdom)))
+         (dotimes (i (ipnet-hosts tnet))
+           (unless (zerop i)
+             (let* ((addr (ipnet-host tnet i))
+                    (tail (join-strings #\.
+                                        (loop
+                                         for i from 0 below bytes
+                                         collect
+                                         (logand #xff
+                                                 (ash addr (* 8 i)))))))
+               (rec :name (format nil "~A.~A" tail name)
+                    :type :cname
+                    :data (format nil "~A.~A" tail tdom))))))))))

 
 ;;;--------------------------------------------------------------------------
 ;;; Zone file output.
 
 
 ;;;--------------------------------------------------------------------------
 ;;; Zone file output.
 

+(export 'zone-write)

 (defgeneric zone-write (format zone stream)
   (:documentation "Write ZONE's records to STREAM in the specified FORMAT."))
 
 (defgeneric zone-write (format zone stream)
   (:documentation "Write ZONE's records to STREAM in the specified FORMAT."))
 


@@ -725,10 +912,12 @@
   "Stream to write zone data on.")
 
 (defmethod zone-write :around (format zone stream)
   "Stream to write zone data on.")
 
 (defmethod zone-write :around (format zone stream)

+  (declare (ignore format))

   (let ((*writing-zone* zone)
        (*zone-output-stream* stream))
     (call-next-method)))
 
   (let ((*writing-zone* zone)
        (*zone-output-stream* stream))
     (call-next-method)))
 

+(export 'zone-save)

 (defun zone-save (zones &key (format :bind))
   "Write the named ZONES to files.  If no zones are given, write all the
    zones."
 (defun zone-save (zones &key (format :bind))
   "Write the named ZONES to files.  If no zones are given, write all the
    zones."


@@ -746,6 +935,7 @@
 ;;;--------------------------------------------------------------------------
 ;;; Bind format output.
 
 ;;;--------------------------------------------------------------------------
 ;;; Bind format output.
 

+(export 'bind-hostname)

 (defun bind-hostname (hostname)
   (if (not hostname)
       "@"
 (defun bind-hostname (hostname)
   (if (not hostname)
       "@"


@@ -795,8 +985,10 @@ $TTL ~2@*~D~2%"
   (dolist (zr (zone-records zone))
     (bind-record (zr-type zr) zr)))
 
   (dolist (zr (zone-records zone))
     (bind-record (zr-type zr) zr)))
 

+(export 'bind-record)

 (defgeneric bind-record (type zr))
 
 (defgeneric bind-record (type zr))
 

+(export 'bind-format-record)

 (defun bind-format-record (name ttl type format args)
   (format *zone-output-stream*
          "~A~20T~@[~8D~]~30TIN ~A~40T~?~%"
 (defun bind-format-record (name ttl type format args)
   (format *zone-output-stream*
          "~A~20T~@[~8D~]~30TIN ~A~40T~?~%"


@@ -814,9 +1006,11 @@ $TTL ~2@*~D~2%"
                        (bind-record-type type)
                        format args)))
 
                        (bind-record-type type)
                        format args)))
 

+(export 'bind-record-type)

 (defgeneric bind-record-type (type)
   (:method (type) type))
 
 (defgeneric bind-record-type (type)
   (:method (type) type))
 

+(export 'bind-record-format-args)

 (defgeneric bind-record-format-args (type data)
   (:method ((type (eql :a)) data) (list "~A" (ipaddr-string data)))
   (:method ((type (eql :ptr)) data) (list "~A" (bind-hostname data)))
 (defgeneric bind-record-format-args (type data)
   (:method ((type (eql :a)) data) (list "~A" (ipaddr-string data)))
   (:method ((type (eql :ptr)) data) (list "~A" (bind-hostname data)))


@@ -827,6 +1021,10 @@ $TTL ~2@*~D~2%"
   (:method ((type (eql :srv)) data)
     (destructuring-bind (prio weight port host) data
       (list "~2D ~5D ~5D ~A" prio weight port (bind-hostname host))))
   (:method ((type (eql :srv)) data)
     (destructuring-bind (prio weight port host) data
       (list "~2D ~5D ~5D ~A" prio weight port (bind-hostname host))))

-  (:method ((type (eql :txt)) data) (list "~S" (stringify data))))
+  (:method ((type (eql :sshfp)) data)
+    (cons "~2D ~2D ~A" data))
+  (:method ((type (eql :txt)) data)
+    (cons "~#[\"\"~;~S~:;(~@{~%~8T~S~} )~]"
+         (mapcar #'stringify (listify data)))))

 
 ;;;----- That's all, folks --------------------------------------------------
 
 ;;;----- That's all, folks --------------------------------------------------