anchor.diff:                     (setf error-occurred-p t)
                      (main-event-handler e sock))))
                (body-callback (chunk finishedp)
  +               "Called (sometimes multiple times per request) when the HTTP
  +                parser sends us a chunk of body content, which mainly occurs
  +                during a chunked HTTP request. This function is responsible
  +                for calling our :body-chunk, and also for buffering body data
  +                if the route allows."
                  (when error-occurred-p
                    (return-from body-callback))
                  ;; forward the chunk to the callback provided in the chunk-enabled
  
positive.code:                  (do-run-hooks (sock) (run-hooks :post-route request response)
                     nil)))
               (header-callback (headers)
                 ;; if we got the headers, it means we can find the route we're
                 ;; destined to use. if the route accepts chunks and the body is
                 ;; chunked, run the router now so it can set up chunk listening.
                 ;; otherwise, save the route for later and let the rest of the
                 ;; request come in.
                 (future-handler-case
                   (let* ((method (http-parse:http-method http))
                          (resource (http-parse:http-resource http))
  
negative.code:     (setup-parser sock)))
  
  (defun read-data (sock data)
    "A simple read-cb handler that passes data to the HTTP parser attached to the
     socket the data is coming in on. The parser runs all necessary callbacks
     directly, so this function just blindly feeds the data in."
    (log:debu1 "(read) ~a: ~a bytes" sock (length data))
  