anchor.diff:      (let ((*request* req)
             (*reply* rep)
             (*http-server* driver))
  -      (if (request-method req)
  -          (on-request-data user-driver (if-let (format (request-external-format req))
  +      (case (request-state req)
  +        (:headers
  +         (parse-headers driver user-driver data))
  +        (:body
  +         (on-request-data user-driver (if-let (format (request-external-format req))
                                            (babel:octets-to-string data :encoding format)
  -                                         data))
  -          (parse-headers user-driver (socket-server socket) data)))))
  +                                         data)))
  +        (:closed
  +         (if (request-keep-alive-p *request*)
  +             (new-request driver socket)
  +             (close socket)))))))
   
   (defparameter +100-continue+ #.(babel:string-to-octets (format nil "HTTP/1.1 100 Continue~a~a" +crlf-ascii+ +crlf-ascii+)))
  -(defun parse-headers (driver server data)
  +(defun parse-headers (server driver data)
     (multiple-value-bind (donep parser rest)
         (feed-parser (request-request-parser *request*) (babel:octets-to-string data :encoding :ascii))
       (when donep
  
positive.code: 
  (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))))
  
  (defmethod on-server-connection ((driver http-server-driver) socket)
    (new-request driver socket))
  
negative.code:    (http-version :accessor request-http-version)
     (external-format :initarg :external-format :accessor request-external-format)
     (request-parser :initform (make-request-parser) :reader request-request-parser)
     (keep-alive-p :accessor request-keep-alive-p :initform t)
     (state :accessor request-state :initform :headers)
     (socket :initarg :socket :reader request-socket)))
  
  (defmethod close ((req request) &key abort)
    (setf (request-state req) :closed)
    (when abort
      (setf (request-keep-alive-p req) nil)))
  
  ;; TODO - the reply implementation needs to go below all the header parsing later anyway.
  (eval-when (:compile-toplevel :load-toplevel :execute)
  