summaryrefslogtreecommitdiff
path: root/sleekxmpp/__init__.py
diff options
context:
space:
mode:
Diffstat (limited to 'sleekxmpp/__init__.py')
-rw-r--r--sleekxmpp/__init__.py270
1 files changed, 270 insertions, 0 deletions
diff --git a/sleekxmpp/__init__.py b/sleekxmpp/__init__.py
new file mode 100644
index 00000000..d7eff574
--- /dev/null
+++ b/sleekxmpp/__init__.py
@@ -0,0 +1,270 @@
+#!/usr/bin/python2.5
+
+"""
+ SleekXMPP: The Sleek XMPP Library
+ Copyright (C) 2007 Nathanael C. Fritz
+ This file is part of SleekXMPP.
+
+ SleekXMPP is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ SleekXMPP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SleekXMPP; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+"""
+from __future__ import absolute_import
+from . basexmpp import basexmpp
+from xml.etree import cElementTree as ET
+from . xmlstream.xmlstream import XMLStream
+from . xmlstream.xmlstream import RestartStream
+from . xmlstream.matcher.xmlmask import MatchXMLMask
+from . xmlstream.matcher.xpath import MatchXPath
+from . xmlstream.matcher.many import MatchMany
+from . xmlstream.handler.callback import Callback
+from . xmlstream.stanzabase import StanzaBase
+from . xmlstream import xmlstream as xmlstreammod
+import time
+import logging
+import base64
+import sys
+import random
+import copy
+from . import plugins
+from . import stanza
+srvsupport = True
+try:
+ import dns.resolver
+except ImportError:
+ srvsupport = False
+
+
+
+#class PresenceStanzaType(object):
+#
+# def fromXML(self, xml):
+# self.ptype = xml.get('type')
+
+
+class ClientXMPP(basexmpp, XMLStream):
+ """SleekXMPP's client class. Use only for good, not evil."""
+
+ def __init__(self, jid, password, ssl=False, plugin_config = {}, plugin_whitelist=[], escape_quotes=True):
+ global srvsupport
+ XMLStream.__init__(self)
+ self.default_ns = 'jabber:client'
+ basexmpp.__init__(self)
+ self.plugin_config = plugin_config
+ self.escape_quotes = escape_quotes
+ self.set_jid(jid)
+ self.plugin_whitelist = plugin_whitelist
+ self.auto_reconnect = True
+ self.srvsupport = srvsupport
+ self.password = password
+ self.registered_features = []
+ self.stream_header = """<stream:stream to='%s' xmlns:stream='http://etherx.jabber.org/streams' xmlns='%s' version='1.0'>""" % (self.server,self.default_ns)
+ self.stream_footer = "</stream:stream>"
+ #self.map_namespace('http://etherx.jabber.org/streams', 'stream')
+ #self.map_namespace('jabber:client', '')
+ self.features = []
+ self.authenticated = False
+ self.sessionstarted = False
+ self.registerHandler(Callback('Stream Features', MatchXPath('{http://etherx.jabber.org/streams}features'), self._handleStreamFeatures, thread=True))
+ self.registerHandler(Callback('Roster Update', MatchXPath('{%s}iq/{jabber:iq:roster}query' % self.default_ns), self._handleRoster, thread=True))
+ self.registerHandler(Callback('Roster Update', MatchXMLMask("<presence xmlns='%s' type='subscribe' />" % self.default_ns), self._handlePresenceSubscribe, thread=True))
+ self.registerFeature("<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' />", self.handler_starttls, True)
+ self.registerFeature("<mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />", self.handler_sasl_auth, True)
+ self.registerFeature("<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' />", self.handler_bind_resource)
+ self.registerFeature("<session xmlns='urn:ietf:params:xml:ns:xmpp-session' />", self.handler_start_session)
+
+ #self.registerStanzaExtension('PresenceStanza', PresenceStanzaType)
+ #self.register_plugins()
+
+ def importStanzas(self):
+ for modname in stanza.__all__:
+ __import__("%s.%s" % (globals()['stanza'].__name__, modname))
+ for register in getattr(stanza, modname).stanzas:
+ self.registerStanza(**register)
+
+ def __getitem__(self, key):
+ if self.plugin.has_key(key):
+ return self.plugin[key]
+ else:
+ logging.warning("""Plugin "%s" is not loaded.""" % key)
+ return False
+
+ def get(self, key, default):
+ return self.plugin.get(key, default)
+
+ def connect(self, address=tuple()):
+ """Connect to the Jabber Server. Attempts SRV lookup, and if it fails, uses
+ the JID server."""
+ self.importStanzas()
+ if not address or len(address) < 2:
+ if not self.srvsupport:
+ logging.debug("Did not supply (address, port) to connect to and no SRV support is installed (http://www.dnspython.org). Continuing to attempt connection, using server hostname from JID.")
+ else:
+ logging.debug("Since no address is supplied, attempting SRV lookup.")
+ try:
+ answers = dns.resolver.query("_xmpp-client._tcp.%s" % self.server, "SRV")
+ except dns.resolver.NXDOMAIN:
+ logging.debug("No appropriate SRV record found. Using JID server name.")
+ else:
+ # pick a random answer, weighted by priority
+ # there are less verbose ways of doing this (random.choice() with answer * priority), but I chose this way anyway
+ # suggestions are welcome
+ addresses = {}
+ intmax = 0
+ priorities = []
+ for answer in answers:
+ intmax += answer.priority
+ addresses[intmax] = (answer.target.to_text()[:-1], answer.port)
+ priorities.append(intmax) # sure, I could just do priorities = addresses.keys()\n priorities.sort()
+ picked = random.randint(0, intmax)
+ for priority in priorities:
+ if picked <= priority:
+ address = addresses[priority]
+ break
+ if not address:
+ # if all else fails take server from JID.
+ address = (self.server, 5222)
+ result = XMLStream.connect(self, address[0], address[1], use_tls=True)
+ if result:
+ self.event("connected")
+ else:
+ print "** Failed to connect -- disconnected"
+ self.event("disconnected")
+ return result
+
+ # overriding reconnect and disconnect so that we can get some events
+ # should events be part of or required by xmlstream? Maybe that would be cleaner
+ def reconnect(self):
+ print "** Reconnect -- disconnected"
+ self.event("disconnected")
+ XMLStream.reconnect(self)
+
+ def disconnect(self, init=True, close=False, reconnect=False):
+ print "** Called -- disconnected"
+ # raise TypeError
+ self.event("disconnected")
+ XMLStream.disconnect(self, reconnect)
+
+ def registerFeature(self, mask, pointer, breaker = False):
+ """Register a stream feature."""
+ self.registered_features.append((MatchXMLMask(mask), pointer, breaker))
+
+ def updateRoster(self, jid, name=None, subscription=None, groups=[]):
+ """Add or change a roster item."""
+ iq = self.makeIqSet()
+ iq.attrib['from'] = self.fulljid
+ query = self.makeQueryRoster(iq)
+ item = ET.Element('item')
+ item.attrib['jid'] = jid
+ if name:
+ item.attrib['name'] = name
+ if subscription in ['to', 'from', 'both']:
+ item.attrib['subscription'] = subscription
+ else:
+ item.attrib['subscription'] = 'none'
+ for group in groups:
+ groupxml = ET.Element('group')
+ groupxml.text = group
+ item.append.groupxml
+ return self.send(iq, self.makeIq(self.getId()))
+
+ def getRoster(self):
+ """Request the roster be sent."""
+ self.send(self.makeIqGet('jabber:iq:roster'))
+
+ def _handleStreamFeatures(self, features):
+ for subelement in features.xml:
+ for feature in self.registered_features:
+ if feature[0].match(subelement):
+ #if self.maskcmp(subelement, feature[0], True):
+ if feature[1](subelement) and feature[2]: #if breaker, don't continue
+ return True
+
+ def handler_starttls(self, xml):
+ if self.ssl_support:
+ self.add_handler("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls' />", self.handler_tls_start)
+ self.send(xml)
+ return True
+ else:
+ logging.warning("The module tlslite is required in to some servers, and has not been found.")
+ return False
+
+ def handler_tls_start(self, xml):
+ logging.debug("Starting TLS")
+ if self.startTLS():
+ raise RestartStream()
+
+ def handler_sasl_auth(self, xml):
+ logging.debug("Starting SASL Auth")
+ self.add_handler("<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />", self.handler_auth_success)
+ self.add_handler("<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />", self.handler_auth_fail)
+ sasl_mechs = xml.findall('{urn:ietf:params:xml:ns:xmpp-sasl}mechanism')
+ if len(sasl_mechs):
+ for sasl_mech in sasl_mechs:
+ self.features.append("sasl:%s" % sasl_mech.text)
+ if 'sasl:PLAIN' in self.features:
+ self.send("""<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='PLAIN'>%s</auth>""" % str(base64.b64encode('\x00' + self.username + '\x00' + self.password)))
+ else:
+ logging.error("No appropriate login method.")
+ self.disconnect()
+ #if 'sasl:DIGEST-MD5' in self.features:
+ # self._auth_digestmd5()
+ return True
+
+ def handler_auth_success(self, xml):
+ self.authenticated = True
+ self.features = []
+ raise RestartStream()
+
+ def handler_auth_fail(self, xml):
+ logging.info("Authentication failed.")
+ self.disconnect()
+ self.event("failed_auth")
+
+ def handler_bind_resource(self, xml):
+ logging.debug("Requesting resource: %s" % self.resource)
+ out = self.makeIqSet()
+ res = ET.Element('resource')
+ res.text = self.resource
+ xml.append(res)
+ out.append(xml)
+ id = out.get('id')
+ response = self.send(out, self.makeIqResult(id))
+ self.set_jid(response.find('{urn:ietf:params:xml:ns:xmpp-bind}bind/{urn:ietf:params:xml:ns:xmpp-bind}jid').text)
+ logging.info("Node set to: %s" % self.fulljid)
+
+ def handler_start_session(self, xml):
+ if self.authenticated:
+ response = self.send(self.makeIqSet(xml), self.makeIq(self.getId()))
+ logging.debug("Established Session")
+ self.sessionstarted = True
+ self.event("session_start")
+
+ def _handleRoster(self, roster):
+ xml = roster.xml
+ xml = roster.xml
+ roster_update = {}
+ for item in xml.findall('{jabber:iq:roster}query/{jabber:iq:roster}item'):
+ if not item.attrib['jid'] in self.roster:
+ self.roster[item.attrib['jid']] = {'groups': [], 'name': '', 'subscription': 'none', 'presence': {}, 'in_roster': False}
+ self.roster[item.attrib['jid']]['name'] = item.get('name', '')
+ self.roster[item.attrib['jid']]['subscription'] = item.get('subscription', 'none')
+ self.roster[item.attrib['jid']]['in_roster'] = 'True'
+ for group in item.findall('{jabber:iq:roster}group'):
+ self.roster[item.attrib['jid']]['groups'].append(group.text)
+ if self.roster[item.attrib['jid']]['groups'] == []:
+ self.roster[item.attrib['jid']]['groups'].append('Default')
+ roster_update[item.attrib['jid']] = self.roster[item.attrib['jid']]
+ if xml.get('type', 'result') == 'set':
+ self.send(self.makeIqResult(xml.get('id', '0')))
+ self.event("roster_update", roster_update)