anchor.diff:  call presence on your behalf if the authentication was successful."
     (setf (username connection) username)
     (let ((result (funcall (get-auth-method mechanism) connection username password resource)))
  -    (when (and (eq result :authentication-successful) bind-et-al)
  +    (if (and (eq result :authentication-successful)
  +	     bind-et-al)
  +	(progn
   	  (when (feature-p connection :bind)
   	    (bind connection resource)
   	    (receive-stanza connection))
  
positive.code:    (port
      :accessor port
      :initarg :port
      :initform *default-port*)
     (stanza-thread
      :accessor stanza-thread
      :initform nil)
     (stanza-callback
      :accessor stanza-callback
      :initarg  :stanza-callback
      :initform 'default-stanza-callback))
    (:documentation "A TCP connection between this XMPP client and
  an, assumed, XMPP compliant server.  The connection does not
  know whether or not the XML stream has been initiated nor whether
  
negative.code: ;;; you do please feel free to submit a patch.
  (defmethod xml-element-to-event ((connection connection)
  				 (object xml-element) (name (eql :message)))
    (make-instance 'message
                   :xml-element object
  		 :from (value (get-attribute object :from))
  		 :to (value (get-attribute object :to))
                   :id (value (get-attribute object :id))
                   :type (value (get-attribute object :type))
  		 :body (if (get-element object :body)
  			   (data (get-element (get-element object :body) :\#text))
  			   "nil")))
  
  (defmethod stanza-waiting-p ((connection connection))
    "listens into the socket stream and checks whether stanzas have arrived"
    (listen (usocket:socket-stream (server-socket connection))))
  
  ;;
  ;; Receive stanzas
  ;;
  
  (defmethod receive-stanza-loop ((connection connection)	&key
                                  (stanza-callback 'default-stanza-callback)
                                  dom-repr)
    "Reads from connection's stream and parses the XML received
  on-the-go.  As soon as it has a complete element it calls
  the stanza-callback (which by default eventually dispatches
  to HANDLE)."
    (loop (receive-stanza connection
  			:stanza-callback stanza-callback
  			:dom-repr dom-repr)))
  
  (defmethod receive-stanza ((connection connection) &key
  			   (stanza-callback 'default-stanza-callback)
  			   dom-repr)
    "Returns one stanza.  Hangs until one is received."
    (let* ((stanza (read-stanza connection))
  	 (tagname (dom:tag-name (dom:document-element stanza))))
      (cond
       ((equal tagname "stream:error")
        (when stanza-callback
  	(car (funcall stanza-callback stanza connection :dom-repr dom-repr)))
        (error "Received error."))
       (t
        (when stanza-callback
  	(car (funcall stanza-callback stanza connection :dom-repr dom-repr)))))))
  
  (defun read-stanza (connection)
    (unless (server-source connection)
  