from twisted.xish import domish, xpath, utility
from twisted.protocols import xmlstream
DigestAuthQry = xpath.intern("/iq/query/digest")
PlaintextAuthQry = xpath.intern("/iq/query/password")
def basicClientFactory(jid, secret):
a = BasicAuthenticator(jid, secret)
return xmlstream.XmlStreamFactory(a)
class IQ(domish.Element):
""" Wrapper for a Info/Query packet
This provides the necessary functionality to send IQs and get notified
when a result comes back. It's a subclass from domish.Element, so you can
use the standard DOM manipulation calls to add data to the outbound
request.
@type callbacks: C{hemp.utility.CallbackList}
@cvar callbacks: Callback list to be notified when response comes back
"""
def __init__(self, xmlstream, type = "set"):
"""
@type xmlstream: C{XmlStream}
@param xmlstream: XmlStream to use for transmission of this IQ
@type type: C{str}
@param type: IQ type identifier ('get' or 'set')
"""
domish.Element.__init__(self, ("jabber:client", "iq"))
self.addUniqueId()
self["type"] = type
self._xmlstream = xmlstream
self.callbacks = utility.CallbackList()
def addCallback(self, fn, *args, **kwargs):
"""
Register a callback for notification when the IQ result
is available.
"""
self.callbacks.addCallback(True, fn, *args, **kwargs)
def send(self, to = None):
"""
Call this method to send this IQ request via the associated XmlStream
@type to: C{str}
@type to: Jabber ID of the entity to send the request to
@returns: Callback list for this IQ. Any callbacks added to this list will
be fired when the result comes back.
"""
if to != None:
self["to"] = to
self._xmlstream.addOnetimeObserver("/iq[@id='%s']" % self["id"], \
self._resultEvent)
self._xmlstream.send(self.toXml())
def _resultEvent(self, iq):
self.callbacks.callback(iq)
self.callbacks = None
class BasicAuthenticator(xmlstream.ConnectAuthenticator):
""" Authenticates an XmlStream against a Jabber server as a Client
This only implements non-SASL authentication, per
U{JEP 78<http://www.jabber.org/jeps/jep-0078.html>}. Additionally, this
authenticator provides the ability to perform inline registration, per
U{JEP 77<http://www.jabber.org/jeps/jep-0077.html>}.
Under normal circumstances, the BasicAuthenticator generates the L{STREAM_AUTHD_EVENT}
once the stream has authenticated. However, it can also generate other events, such
as:
- L{INVALID_USER_EVENT} : Authentication failed, due to invalid username
- L{AUTH_FAILED_EVENT} : Authentication failed, due to invalid password
- L{REGISTER_FAILED_EVENT} : Registration failed
If authentication fails for any reason, you can attempt to register by calling
the L{registerAccount} method. If the registration succeeds, a L{STREAM_AUTHD_EVENT}
will be fired. Otherwise, one of the above errors will be generated (again).
"""
namespace = "jabber:client"
INVALID_USER_EVENT = "//event/client/basicauth/invaliduser"
AUTH_FAILED_EVENT = "//event/client/basicauth/authfailed"
REGISTER_FAILED_EVENT = "//event/client/basicauth/registerfailed"
def __init__(self, jid, password):
xmlstream.ConnectAuthenticator.__init__(self, jid.host)
self.jid = jid
self.password = password
def streamStarted(self, rootelem):
iq = IQ(self.xmlstream, "get")
iq.addElement(("jabber:iq:auth", "query"))
iq.query.addElement("username", content = self.jid.user)
iq.addCallback(self._authQueryResultEvent)
iq.send()
def _authQueryResultEvent(self, iq):
if iq["type"] == "result":
iq = IQ(self.xmlstream, "set")
iq.addElement(("jabber:iq:auth", "query"))
iq.query.addElement("username", content = self.jid.user)
iq.query.addElement("resource", content = self.jid.resource)
if DigestAuthQry.matches(iq):
digest = xmlstream.hashPassword(self.xmlstream.sid, self.password)
iq.query.addElement("digest", content = digest)
else:
iq.query.addElement("password", content = self.password)
iq.addCallback(self._authResultEvent)
iq.send()
else:
if iq.error["code"] == "401":
self.xmlstream.dispatch(iq, self.INVALID_USER_EVENT)
else:
self.xmlstream.dispatch(iq, self.AUTH_FAILED_EVENT)
def _authResultEvent(self, iq):
if iq["type"] == "result":
self.xmlstream.dispatch(self.xmlstream, xmlstream.STREAM_AUTHD_EVENT)
else:
self.xmlstream.dispatch(iq, self.AUTH_FAILED_EVENT)
def registerAccount(self, username = None, password = None):
if username:
self.jid.user = username
if password:
self.password = password
iq = IQ(self.xmlstream, "set")
iq.addElement(("jabber:iq:register", "query"))
iq.query.addElement("username", content = self.jid.user)
iq.query.addElement("password", content = self.password)
iq.addCallback(self._registerResultEvent)
iq.send()
def _registerResultEvent(self, iq):
if iq["type"] == "result":
self.streamStarted(None)
else:
self.xmlstream.dispatch(iq, self.REGISTER_FAILED_EVENT)