anchor.diff:    *root-POA*)
   
   (eval-when (:load-toplevel :execute)
  +  (setq *new-connection-callback* 'poa-connection-handler)
     (pushnew (cons "RootPOA" #'root-POA)
              *default-initial-references*
              :key #'car :test #'equal ))
  
positive.code: 
  ;;;; Server proper
  
  (defvar *server-socket* nil
    "The `master' socket that we accept new connections on")
  
  (defclass clorb-adaptor ()
    ((orb :initarg :orb  :accessor adaptor-orb)
     (listner-socket
      :initarg :listner
      :initform nil :accessor listner-socket)
     (client-streams :initform nil :accessor client-streams-raw)))
  
  (defun setup-server (&optional (orb (ORB_init)))
    (setq *server-socket* (open-passive-socket *port*))
    (let ((adaptor (make-instance 'clorb-adaptor
                     :orb orb
                     :listner *server-socket*)))
      (setf (adaptor orb) adaptor)))
  
  (defmethod listner-sockets ((adaptor clorb-adaptor))
    (if (listner-socket adaptor)
        (list (listner-socket adaptor))))
  
  (defmethod listner-host ((adaptor clorb-adaptor))
    (passive-socket-host *server-socket*))
  
  (defmethod listner-port ((adaptor clorb-adaptor))
    (passive-socket-port *server-socket*))
  
  (defmethod handle-socket ((adaptor clorb-adaptor) socket &optional allow-blocking)
    (let ((conn (accept-connection-on-socket socket allow-blocking)))
      (when conn
        (push conn (client-streams-raw adaptor)))))
  
  (defmethod client-streams ((adaptor clorb-adaptor))
    (dolist (stream (client-streams-raw adaptor))
      (unless (socket-stream-functional-p stream)
        (mess 1 "Removing closed stream ~S" stream)
        (setf (client-streams-raw adaptor)
          (delete stream (client-streams-raw adaptor)))))
    (client-streams-raw adaptor))
  
  (defmethod handle-stream ((adaptor clorb-adaptor) stream)
    (when (and (typep stream 'stream)
               (socket-stream-functional-p stream))
      (when (socket-stream-listen stream)
        (mess 1 "Getting message from ~S" stream)
        (get-message stream))
      t))
  
  (defun get-message (stream)
    (let ((sreq (make-server-request
                 :stream stream
                 :buffer (get-work-buffer))))
      (when (read-request sreq stream)
        (decode-request sreq)
        (poa-demux sreq))))
  
  (defun poa-demux (sreq)
    (with-slots (object-key operation) sreq
  
negative.code:   (op:run orb))
  
  (defun recover (&optional (orb (ORB_init)))
    (io-reset :listner nil)
    (main-loop orb))
  