anchor.diff:                    (funcall (second server) connection))
                    (t (tcp4-send-packet connection blah (logand #xFFFFFFFF (1+ seq)) nil
                                         :ack-p t :rst-p t))))))
  -      (t (unless (logtest flags +tcp4-flag-rst+)
  +      (t (format t "Ignoring packet from ~X ~S~%" remote-ip
  +                 (subseq packet start end))
  +         (unless (logtest flags +tcp4-flag-rst+)
              (let ((connection (make-tcp-connection :state :syn-received
                                                     :local-port local-port
                                                     :remote-port remote-port
  
positive.code:              ((>= offset end))
             (tcp-send connection data offset (min (+ offset mss) end))))
          (t ;; Send one packet.
           (let ((s-next (tcp-connection-s-next connection)))
             (setf (tcp-connection-s-next connection)
                   (logand (+ s-next (- end start))
                           #xFFFFFFFF))
             (tcp4-send-packet connection s-next
                               (tcp-connection-r-next connection)
                               (if (and (eql start 0)
                                        (eql end (length data)))
                                   data
                                   (subseq data start end))
                               :psh-p t)))))))
  
  (defvar *test-message* #(#x47 #x45 #x54 #x20 #x2F #x0D #x0A #x0D #x0A))
  
  (defun send-ping (destination &optional (identifier 0) (sequence-number 0) payload)
    (let ((packet (make-array (+ 8 (if payload (length payload) 56)))))
  
negative.code:       (setf (tcp-stream-packet stream) (pop (tcp-connection-rx-data connection))))))
  
  (defun tcp-connection-closed-p (stream)
    (with-tcp-connection-locked (tcp-stream-connection stream)
      (let ((connection (tcp-stream-connection stream)))
        (refill-tcp-stream-buffer stream)
        (and (null (tcp-stream-packet stream))
             (not (eql (tcp-connection-state connection) :established))
             (not (eql (tcp-connection-state connection) :syn-received))))))
  
  (defmethod sys.gray:stream-listen ((stream tcp-stream))
    (with-tcp-connection-locked (tcp-stream-connection stream)
      (refill-tcp-stream-buffer stream)
      (not (null (tcp-stream-packet stream)))))
  
  (defmethod sys.gray:stream-read-byte ((stream tcp-stream))
    (with-tcp-connection-locked (tcp-stream-connection stream)
      (when (not (refill-tcp-packet-buffer stream))
        (return-from sys.gray:stream-read-byte :eof))
      (let* ((packet (tcp-stream-packet stream))
             (byte (aref (first packet) (second packet))))
        (when (>= (incf (second packet)) (third packet))
          (setf (tcp-stream-packet stream) nil))
        byte)))
  
  (defmethod sys.gray:stream-read-sequence ((stream tcp-stream) sequence &optional (start 0) end)
    (unless end (setf end (length sequence)))
  