anchor.diff:  (defun net-receive (&key timeout)
     (assert (or (eql *mode* :server) (eql *mode* :client)))
     #+(not (and sbcl windows))
  -  (usocket:wait-for-input *inbound-socket* :timeout timeout :ready-only t)
  +  (usocket:wait-for-input *socket* :timeout timeout :ready-only t)
     #+(and sbcl windows) t
     (multiple-value-bind (buffer size host port)
  -      (usocket:socket-receive *inbound-socket* *inbound-buffer* nil)
  +      (usocket:socket-receive *socket* *buffer* nil)
       (values (restore-from-buffer buffer 0 size) host port)))
   
   (defun net-send (message)
     (assert (or (eql *mode* :server) (eql *mode* :client)))
     (let ((buffer (store-to-buffer message)))
  -    (usocket:socket-send *outbound-socket* buffer nil)))
  +    (usocket:socket-send *socket* buffer nil
  +                         :host *remote-host* :port *remote-port*)))
   
   (defmacro with-serve-request ((request &key timeout) &body body)
     `(let ((,request (net-receive :timeout ,timeout)))
  
positive.code:   (assert (boundp '*mode*))
    (ecase *mode*
      ((:server :client)
       (usocket:socket-close *inbound-socket*)
       (when (boundp '*outbound-socket*)
         (usocket:socket-close *outbound-socket*)))
      ((:normal)))
    (makunbound '*inbound-socket*)
    (makunbound '*outbound-socket*)
    (makunbound '*mode*))
  
  (defun store-to-buffer (object)
  
negative.code:                      nil nil :protocol :datagram :local-port port))
              (host (usocket:get-local-address socket))
              (port (usocket:get-local-port socket)))
         (setf *local-host* host *local-port* port *socket* socket)))
      ((:normal)))
    (setf *mode* mode))
  
  