anchor.diff:  
   (defun new-request (driver socket)
     (setf (gethash socket (http-server-connections driver))
  -        (cons (make-instance 'request
  -                             :socket socket
  -                             :external-format (http-server-external-format-in driver))
  -              (make-instance 'reply
  -                             :socket socket
  -                             :external-format (http-server-external-format-out driver)
  -                             :http-server driver))))
  +        (let ((req (make-instance 'request
  +                                  :socket socket
  +                                  :external-format (http-server-external-format-in driver))))
  +          (cons req
  +                (make-instance 'reply
  +                               :socket socket
  +                               :request req
  +                               :external-format (http-server-external-format-out driver)
  +                               :http-server driver)))))
   
   (defmethod on-server-connection ((driver http-server-driver) socket)
     (new-request driver socket))
  
positive.code:                               +crlf-ascii+))
     (status :accessor reply-status :initform 200)
     (socket :reader reply-socket :initarg :socket)
     (headers-written-p :accessor reply-headers-written-p :initform nil)
     (http-server :reader reply-http-server :initarg :http-server)
     (keep-alive-p :accessor reply-keep-alive-p :initform t)
     (chunkedp :accessor reply-chunked-p :initform t)
     (external-format :accessor reply-external-format :initarg :external-format)))
  
  
negative.code:             (request-url *request*) (request-parser-url parser)
              (request-headers *request*) (request-parser-headers parser))
        (when (string-equal "1.0" (request-http-version *request*))
          (setf (request-keep-alive-p *request*) nil)))
      (when rest
        (if donep
            (cond ((or
                    (member :upgrade (request-headers *request*)
                            :test #'string-equal
                            :key #'car)
                    (string-equal "CONNECT" (request-method *request*)))
                   (close *request*)
                   (unregister-http-socket server *socket*)
                   (on-request-upgrade driver (babel:string-to-octets rest :encoding :ascii)))
                  (t
                   (when (member '(:expect . "100-continue") (request-headers *request*)
                                 :test #'equalp)
                     ;; TODO - perhaps we shouldn't write this when the client's HTTP version is <1.1?
                     (write-sequence +100-continue+ (reply-socket *reply*)))
                   (when (member '(:connection . "keep-alive") (request-headers *request*)
                                 :test #'equalp)
                     (setf (request-keep-alive-p *request*) t))
                   (when (member '(:connection . "close") (request-headers *request*)
                                 :test #'equalp)
                     (setf (request-keep-alive-p *request*) nil))
                   (setf (request-state *request*) :body)
                   (on-http-request driver)
                   (on-request-data driver
                                    (let ((rest-octets (babel:string-to-octets rest :encoding :ascii)))
                                      (if-let (format (request-external-format *request*))
                                        (babel:octets-to-string rest-octets :encoding format)
                                        rest-octets)))))
            (parse-headers server driver rest)))))
  
  (defun unregister-http-socket (driver socket)
    (remhash socket (http-server-connections driver)))
  
  (defmethod on-socket-close ((driver http-server-driver))
    (unregister-http-socket driver *socket*))
  
  (defun http-listen (driver &key
                      (host iolib:+ipv4-unspecified+)
  