anchor.diff:      (ecase protocol
         (:stream
          (let ((mcl-sock
  -	      (openmcl-socket:make-socket :remote-host (host-to-hostname host)
  +	      (openmcl-socket:make-socket :remote-host host
   					  :remote-port port
  -					  :local-host (when local-host (host-to-hostname local-host))
  +					  :local-host local-host
   					  :local-port local-port
   					  :format (to-format element-type protocol)
   					  :external-format ccl:*default-external-format*
  
positive.code:   (with-mapped-conditions (usocket)
      (openmcl-socket:receive-from (socket usocket) length :buffer buffer)))
  
  (defmethod get-local-address ((usocket usocket))
    (let ((address (openmcl-socket:local-host (socket usocket))))
      (when address
        (hbo-to-vector-quad address))))
  
  (defmethod get-peer-address ((usocket stream-usocket))
    (let ((address (openmcl-socket:remote-host (socket usocket))))
      (when address
        (hbo-to-vector-quad address))))
  
  (defmethod get-local-port ((usocket usocket))
    (openmcl-socket:local-port (socket usocket)))
  
negative.code: 	 (setf (connected-p usocket) t)
  	 usocket)))))
  
  #+ccl-1.11-sockets
  (defun socket-listen (host port
                        &key
                          (reuse-address nil reuse-address-supplied-p)
                          (reuseaddress (when reuse-address-supplied-p reuse-address))
                          (backlog 5)
                          (element-type 'character))
    (let ((local-address (openmcl-socket:resolve-address :host host :port port :connect :passive)))
      (with-mapped-conditions ()
        (make-stream-server-socket (openmcl-socket:make-socket :connect :passive
                                                               :address-family (openmcl-socket:socket-address-family local-address)
                                                               :local-address local-address
                                                               :reuse-address reuseaddress
                                                               :backlog backlog
                                                               :format (to-format element-type :stream))
                                   :element-type element-type))))
  
  #-ccl-1.11-sockets
  (defun socket-listen (host port
                        &key reuseaddress
                             (reuse-address nil reuse-address-supplied-p)
                             (backlog 5)
                             (element-type 'character))
  