from twisted.words.protocols.jabber import xmlstream
from twisted.internet import protocol
from twisted.words.xish import domish, utility
from twisted.internet import reactor
from twisted.python import log
import sys, sha
log.startLogging(sys.stdout)
 
 
def magicHash(password, sid):
	magic1 = int()
	magic2 = int()
	magic1 = 0x50305735
	magic2 = 0x12345671
	sum = 7
	for z in password:
		if z == ' ':
			continue
		if z == '\t':
			continue
		magic1 = magic1 ^  (((magic1 & 0x3f) + sum) * ord(z)) + (magic1 << 8)
		magic2 += (magic2 << 8) ^ magic1
		sum = sum + ord(z)
	magic1 = magic1 & 0x7fffffff
	magic2 = magic2 & 0x7fffffff
	print sid+"%08x%08x"%(magic1, magic2)
	return sid+"%08x%08x"%(magic1, magic2)
 
def ping(xmlstream):
	print 'ping'
	xmlstream.send('  \t  ')
	reactor.callLater(40, ping, xmlstream)
 
class TlenAuthInitializer(object):
	def __init__(self, xs):
		self.xmlstream = xs
	def initialize(self):
		iq = xmlstream.IQ(self.xmlstream, "set")
		iq['id'] = self.xmlstream.sid
		q = iq.addElement('query', 'jabber:iq:auth')
		q.addElement('username', content = self.xmlstream.authenticator.jid)
		q.addElement('digest', content = sha.new(magicHash(self.xmlstream.authenticator.password, self.xmlstream.sid)).hexdigest())
		q.addElement('resource', content  = 't')
		d = iq.send()
		d.addCallback(self._authreply)
		d.addErrBack(self._authfail)
 
	def _authreply(self, el):
		print el.toXml()
		reactor.callLater(40, ping, self.xmlstream)
 
	def _authfail(self, el):
		print el.toXml()
 
class TlenAuthenticator(xmlstream.ConnectAuthenticator):
	def __init__(self, jid, password, host):
		xmlstream.ConnectAuthenticator.__init__(self, host)
		self.jid = jid
		self.password = password
 
	def associateWithStream(self, xs):
		xs.version = (0, 0)
		xmlstream.ConnectAuthenticator.associateWithStream(self, xs)
 
		inits = [(TlenAuthInitializer, True)]
		for initClass, required in inits:
			init = initClass(xs)
			init.required = required
			xs.initializers.append(init)
 
class TlenStream(xmlstream.XmlStream):
	def sendHeader(self):
		rootElem = domish.Element((None, 's'))
		rootElem['v'] = '8'
		rootElem['t'] = '06000106'
		self.rootElem = rootElem
		self.send(rootElem.toXml(prefixes=self.prefixes, closeElement=0))
		self._headerSent = True
		print rootElem.toXml(prefixes=self.prefixes, closeElement=0)
 
	def sendFooter(self):
		self.send('</s>')
 
	def onDocumentStart(self, rootelem):
		print rootelem
		xmlstream.XmlStream.onDocumentStart(self, rootelem)
		if rootelem.hasAttribute("i"):
			self.sid = rootelem["i"]
		self.authenticator.streamStarted()
 
class TlenStreamFactory(xmlstream.XmlStreamFactory):
    def __init__(self, authenticator):
        xmlstream.XmlStreamFactory.__init__(self, authenticator)
        self.authenticator = authenticator
 
 
    def buildProtocol(self, _):
        self.resetDelay()
        # Create the stream and register all the bootstrap observers
        xs = TlenStream(self.authenticator)
        xs.factory = self
        for event, fn in self.bootstraps: xs.addObserver(event, fn)
        return xs
 
def lg(el):
	print 'all>',el
def err(el):
	print 'err>', el
factory = TlenStreamFactory(TlenAuthenticator('sefator', 'heslo','s1.tlen.pl' ))
factory.addBootstrap('/*', lg)
 
reactor.connectTCP('s1.tlen.pl', 443, factory)
reactor.run()