anchor.diff:    (marshal-giop-set-message-length buffer)
     (connection-send-buffer conn buffer)
     (when req
  -    (push req (connection-client-requests conn))
  -    (push req *corba-waiting-requests*)))
  +    (push req (connection-client-requests conn))))
   
   
   (defun find-waiting-request (conn request-id)
     (let ((req-list (connection-client-requests conn)))
  -    (let ((req (find request-id req-list :key #'request-req-id)))
  +    (let ((req (find request-id req-list :key #'request-id)))
         (if req
           (setf (connection-client-requests conn) (delete req req-list))
           (mess 4 "Unexpected response with request id ~d" request-id))
         req)))
  -
  --
  -;;;; IIOP - Profiles
  -
  -
  -(defstruct IIOP-PROFILE
  -  (version '(1 . 0))
  -  (host    nil)
  -  (port    0    :type fixnum)
  -  (key     nil))
  -
  -
  -(defmethod profile-short-desc ((profile IIOP-PROFILE) stream)
  -  (format stream "~A:~A" 
  -          (iiop-profile-host profile)
  -          (iiop-profile-port profile)))
  -
  -(defmethod profile-equal ((profile1 iiop-profile) (profile2 iiop-profile))
  -  (and (equal (iiop-profile-host profile1) (iiop-profile-host profile2))
  -       (equal (iiop-profile-port profile1) (iiop-profile-port profile2))
  -       (equalp (iiop-profile-key profile1) (iiop-profile-key profile2))))
  -
  -(defmethod profile-hash ((profile iiop-profile))
  -  (sxhash (list* (iiop-profile-host profile)
  -                 (iiop-profile-port profile)
  -                 (coerce (iiop-profile-key profile) 'list))))
  -
  -(defmethod decode-ior-profile ((tag (eql 0)) encaps)
  -  (unmarshal-encapsulation encaps #'unmarshal-iiop-profile-body))
  -
  -(defun unmarshal-iiop-profile-body (buffer)
  -  (make-iiop-profile
  -   :version (cons (unmarshal-octet buffer) 
  -                  (unmarshal-octet buffer))
  -   :host (unmarshal-string buffer)
  -   :port (unmarshal-ushort buffer)
  -   :key (unmarshal-osequence buffer)))
  -
  -(defmethod raw-profiles ((objref CORBA:Proxy))
  -  (or (object-raw-profiles objref)
  -      (setf (object-raw-profiles objref)
  -            (map 'list
  -                 (lambda (p)
  -                   (cons iop:tag_internet_iop
  -                         (marshal-make-encapsulation
  -                          (lambda (buffer)
  -                            (let ((version (iiop-profile-version p)))
  -                              (marshal-octet (car version) buffer)
  -                              (marshal-octet (cdr version) buffer))
  -                            (marshal-string (iiop-profile-host p) buffer)
  -                            (marshal-ushort (iiop-profile-port p) buffer)
  -                            (marshal-osequence (iiop-profile-key p) buffer)))))
  -                 (object-profiles objref)))))
  -
  -
  --
  -;;;; IIOP - Sending request
  -
  -#+unused-functions
  -(defun request-prepare (req object)
  -  (let* ((conn (get-object-connection object)))
  -    (unless conn
  -      (raise-system-exception 'corba:comm_failure))
  -    (setf (request-connection req) conn)    
  -    (setf (request-status req) nil)
  -    (setf (request-req-id req) (next-request-id conn))
  -    (values
  -     (or (object-forward object) object)
  -     (setf (request-buffer req) (get-work-buffer (the-orb req)))
  -     conn)))
  -
  -
  -
  -(defun request-marshal-head (req)
  -  (let ((connection (request-start-request req)))
  -    (setf (request-req-id req) (next-request-id connection))
  -    (will-send-request (the-orb req) req)
  -    (setf (request-buffer req) 
  -          (connection-start-request
  -           connection
  -           (request-req-id req)
  -           (service-context-list req)
  -           (response-expected req)
  -           (request-effective-profile req)
  -           (request-operation req)))))
  -
  -
  -(defun send-request (req)
  -  (let ((buffer (request-buffer req)))
  -    (setf (request-buffer req) nil)
  -    (setf (request-status req) nil)
  -    (connection-send-request (request-connection req) buffer
  -                             (if (response-expected req) req))))
   
   
   
positive.code:       (request-locate-repy req status buffer))))
  
  
  
  ;;;; Event loop (orb-wait)
  
  (defvar *new-connection-callback*
    (lambda (desc)
      (io-descriptor-destroy desc)))
  
  
  (defun orb-wait (&optional wait-func &rest wait-args)
    (if *running-orb*
      (if wait-func
        (loop until (apply wait-func wait-args) do (orb-work))
        (orb-work))
      (if wait-func
        (apply #'process-wait "orb-wait" wait-func wait-args)
        (sleep 0.1))))
  
  
  (defun orb-work ()
    (declare (optimize (debug 3)))
    (multiple-value-bind (event desc) (io-driver)
      (when event
        (mess 2 "io-event: ~S ~A" event (io-descriptor-stream desc)))
      (let ((conn (gethash desc *desc-conn*)))
        (case event
          (:read-ready
           ;;(io-descriptor-set-read desc nil 0 0)
           (connection-read-ready conn))
          (:write-ready
           (io-descriptor-set-write desc nil 0 0)
           (connection-write-ready conn))
          (:new
           (funcall *new-connection-callback* desc))
          (:connected
           ;; Not implemented yet..; for outgoing connections setup
           nil)
          (:error
           (mess 4 "Error: ~A" (io-descriptor-error desc))
           (io-descriptor-destroy desc)
           (connection-error conn))
          ((nil)
           (mess 1 "time out"))))))
  
  
  
  
negative.code: 
  
  
  ;;;; Support for static stubs
  
  (defun start-request (operation object &optional no-response)
  