def initialize(self):
iq = client.IQ(self._xs, "set")
iq.addElement(("jabber:iq:register", "query"))
iq.query.addElement("username", content=self._jid_obj.user)
iq.query.addElement("password", content=self._password)
iq.addCallback(self._registerResultEvent)
iq.send()
def testUpload():
cmd = client.IQ(xs, 'set')
ch = cmd.addElement((xmlstream2.NS_MESSAGE_UPLOAD, 'upload'))
ch['node'] = 'kontalkbox'
media = ch.addElement((None, 'media'))
media['type'] = 'image/png'
cmd.send(self.network)
def sync(self, share, peerId=None, name=None):
if share is None:
repoId = None
uuid = None
version = 0
else:
peerId = share.conduit.peerId
repoId = share.repoId
collection = share.contents
name = collection.displayName
uuid = collection.itsUUID
version = share.remoteVersion
iq = client.IQ(self.xmlstream, "get")
iq.addElement(("jabber:x:chandler", "query"))
sync = iq.query.addElement('sync')
sync['fromRepoId'] = self._repoId.str64()
if repoId is not None:
sync['toRepoId'] = repoId.str64()
sync['name'] = name
if uuid is not None:
sync['uuid'] = uuid.str64()
sync['version'] = str(version)
reactor.callFromThread(iq.send, peerId)
self.worker.ops[iq['id']] = ('sync', name)
def validate(self, code, publickey, delay=0):
reg = client.IQ(self.client.xmlstream, 'set')
query = reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
form = query.addElement(('jabber:x:data', 'x'))
form['type'] = 'submit'
hidden = form.addElement((None, 'field'))
hidden['type'] = 'hidden'
hidden['var'] = 'FORM_TYPE'
hidden.addElement((None, 'value'),
content='http://kontalk.org/protocol/register#code')
vcode = form.addElement((None, 'field'))
vcode['type'] = 'text-single'
vcode['label'] = 'Validation code'
vcode['var'] = 'code'
vcode.addElement((None, 'value'), content=code)
pkey = form.addElement((None, 'field'))
pkey['type'] = 'text-single'
pkey['label'] = 'Public key'
pkey['var'] = 'publickey'
pkey.addElement((None, 'value'), content=publickey)
reg.send(self.client.network)
def keepAlive(self):
if not self.kaResponseTimer and self.xmlstream:
iq = client.IQ(self.xmlstream, "get")
iq["to"] = self.me.host
iq.addElement('ping', "urn:xmpp:ping")
iq.addCallback(self.reinitKeepAlive)
self.kaResponseTimer = reactor.callLater(30, self.reconnect)
iq.send()
def vcardSet(self, publickey=None):
if not publickey:
publickey = self.config['publickey']['key']
iq = client.IQ(self.client.xmlstream, 'set')
vcard = iq.addElement((xmlstream2.NS_XMPP_VCARD4, 'vcard'))
vcard_key = vcard.addElement((None, 'key'))
vcard_data = vcard_key.addElement((None, 'uri'))
vcard_data.addContent("data:application/pgp-keys;base64," + publickey)
iq.send(self.client.xmlstream.authenticator.jid.userhost())
def sendAuth(self, jid, passwd, callback, errback=None):
self.jid = jid
self.passwd = passwd
if errback:
self.xmlstream.addObserver(INVALID_USER_EVENT, errback)
self.xmlstream.addObserver(AUTH_FAILED_EVENT, errback)
if self.version != '1.0':
iq = client.IQ(self.xmlstream, "get")
iq.addElement(("jabber:iq:auth", "query"))
iq.query.addElement("username", content=jid.user)
iq.addCallback(callback)
iq.send()
def testValidate():
reg = client.IQ(xs, 'set')
query = reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
form = query.addElement(('jabber:x:data', 'x'))
form['type'] = 'submit'
hidden = form.addElement((None, 'field'))
hidden['type'] = 'hidden'
hidden['var'] = 'FORM_TYPE'
hidden.addElement((None, 'value'), content='http://kontalk.org/protocol/register#code')
code = form.addElement((None, 'field'))
code['type'] = 'text-single'
code['label'] = 'Validation code'
code['var'] = 'code'
code.addElement((None, 'value'), content='686129')
reg.send(self.network)
def register(self, delay=0):
reg = client.IQ(self.client.xmlstream, 'set')
query = reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
form = query.addElement(('jabber:x:data', 'x'))
form['type'] = 'submit'
hidden = form.addElement((None, 'field'))
hidden['type'] = 'hidden'
hidden['var'] = 'FORM_TYPE'
hidden.addElement((None, 'value'), content=xmlstream2.NS_IQ_REGISTER)
phone = form.addElement((None, 'field'))
phone['type'] = 'text-single'
phone['label'] = 'Phone number'
phone['var'] = 'phone'
phone.addElement((None, 'value'), content='+39123456')
reg.send(self.client.network)
def _bindResultEvent(self, iq):
if iq["type"] == "result":
self.bind = 1
if self.session == 1:
iq = client.IQ(self.xmlstream, "set")
iq.addElement((SESSION_XMLNS, "session"), content=self.jid)
iq.addCallback(self._sessionResultEvent)
iq.send()
return
else:
self.bind = 0
# TODO - make a BIND_FAILED_EVENT?
self.xmlstream.dispatch(self.xmlstream,
xmlstream.AUTH_FAILED_EVENT)
if self.bind == 1 and self.session == 1:
self.xmlstream.dispatch(self.xmlstream,
xmlstream.STREAM_AUTHD_EVENT)
else:
self.xmlstream.dispatch(iq, self.AUTH_FAILED_EVENT)
def authQueryResultEvent(self, iq, callback):
if iq["type"] == "result":
# Construct auth request
iq = client.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)
# Prefer digest over plaintext
if client.DigestAuthQry.matches(iq):
digest = xmlstream.hashPassword(self.xmlstream.sid, self.passwd)
iq.query.addElement("digest", content = digest)
else:
iq.query.addElement("password", content = self.passwd)
iq.addCallback(callback)
iq.send()
else:
# Check for 401 -- Invalid user
if iq.error["code"] == "401":
self.xmlstream.dispatch(iq, INVALID_USER_EVENT)
else:
self.xmlstream.dispatch(iq, AUTH_FAILED_EVENT)
def _processGet(self, view, iq, inResponseTo):
self.client.output("processing request")
to = iq['from']
id = iq['id']
responses = []
try:
for elem in iq.query.elements():
method = getattr(self, '_get_' + elem.name, None)
if method is not None:
responses.append(method(view, iq, elem.attributes))
else:
raise NotImplementedError, elem.name
except Exception, e:
iq = client.IQ(self.client.xmlstream, "error")
iq.addElement(("jabber:x:chandler", "query"))
cls = e.__class__
error = iq.query.addElement("error", None, traceback.format_exc())
error['class'] = "%s.%s" % (cls.__module__, cls.__name__)
error['args'] = ','.join(map(str, e.args))
responses = [iq]
def _execute():
iq = client.IQ(self.client.xmlstream, 'set')
cmd = iq.addElement((xmlstream2.NS_PROTO_COMMANDS, 'command'))
cmd['node'] = 'serverlist'
cmd['action'] = 'execute'
iq.send()
def registerRequest(self, delay=0):
reg = client.IQ(self.client.xmlstream, 'get')
reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
reg.send(self.client.network)
def testCommand():
cmd = client.IQ(xs, 'set')
ch = cmd.addElement((xmlstream2.NS_PROTO_COMMANDS, 'command'))
ch['node'] = 'serverlist'
ch['action'] = 'execute'
cmd.send(self.network)
def testRegisterRequest():
reg = client.IQ(xs, 'get')
reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
reg.send(self.network)
def authenticated(self, xs):
print "Authenticated."
xs.addObserver('/*', self.stanza, xs=xs)
xs.addObserver('/message', self.message, xs=xs)
presence = xmppim.AvailablePresence(statuses={None: 'status message'}, priority=0)
xs.send(presence)
ver = client.IQ(xs, 'get')
ver.addElement((xmlstream2.NS_IQ_VERSION, 'query'))
ver.send(self.network)
info = client.IQ(xs, 'get')
info.addElement((xmlstream2.NS_DISCO_INFO, 'query'))
info.send(self.network)
items = client.IQ(xs, 'get')
q = items.addElement((xmlstream2.NS_DISCO_ITEMS, 'query'))
q['node'] = xmlstream2.NS_PROTO_COMMANDS
items.send(self.network)
items = client.IQ(xs, 'get')
q = items.addElement((xmlstream2.NS_DISCO_ITEMS, 'query'))
q['node'] = xmlstream2.NS_MESSAGE_UPLOAD
items.send(self.network)
def testProbe():
if self.peer is not None:
userid, resource = util.split_userid(self.peer)
presence = xmppim.Presence(jid.JID(tuple=(userid, self.network, resource)), 'probe')
presence['id'] = util.rand_str(8)
xs.send(presence)
def testMassProbe():
global count, num
num = 400
count = 0
def _presence(stanza):
global count, num
count += 1
if count >= 400:
print 'received all presence'
xs.addObserver('/presence', _presence)
for n in range(num):
userid = util.rand_str(util.USERID_LENGTH, util.CHARSBOX_HEX_LOWERCASE)
presence = xmppim.Presence(jid.JID(tuple=(userid, self.network, None)), 'probe')
xs.send(presence)
def testRoster():
global count, num
num = 400
count = 0
def _presence(stanza):
global count, num
count += 1
if count >= 400:
print 'received all presence'
xs.addObserver('/presence', _presence)
_jid = jid.JID(tuple=(None, self.network, None))
r = domish.Element((None, 'iq'))
r.addUniqueId()
r['type'] = 'get'
q = r.addElement((xmppim.NS_ROSTER, 'query'))
for n in range(num):
_jid.user = util.rand_str(util.USERID_LENGTH, util.CHARSBOX_HEX_LOWERCASE)
item = q.addElement((None, 'item'))
item['jid'] = _jid.userhost()
xs.send(r)
if self.peer is not None:
_jid = util.userid_to_jid(self.peer, self.network)
r = domish.Element((None, 'iq'))
r['type'] = 'get'
r['id'] = util.rand_str(8)
q = r.addElement((xmppim.NS_ROSTER, 'query'))
item = q.addElement((None, 'item'))
item['jid'] = _jid.userhost()
xs.send(r)
def testSubscribe():
# subscription request
self.index = 0
if self.peer is not None:
userid, resource = util.split_userid(self.peer)
presence = xmppim.Presence(jid.JID(tuple=(userid, self.network, None)), 'subscribe')
presence['id'] = util.rand_str(8)
xs.send(presence)
else:
def pres():
self.index += 1
presence = xmppim.AvailablePresence(statuses={None: 'status message (%d)' % (self.index, )})
xs.send(presence)
LoopingCall(pres).start(2, False)
def testMessage():
jid = xs.authenticator.jid
message = domish.Element((None, 'message'))
message['id'] = 'kontalk' + util.rand_str(8, util.CHARSBOX_AZN_LOWERCASE)
message['type'] = 'chat'
if self.peer:
message['to'] = util.userid_to_jid(self.peer, self.network).full()
else:
message['to'] = jid.userhost()
message.addElement((None, 'body'), content='test message')
message.addElement(('urn:xmpp:server-receipts', 'request'))
xs.send(message)
#xs.sendFooter()
def testMsgLoop():
global counter
counter = 0
def _loop():
global counter
counter += 1
jid = xs.authenticator.jid
message = domish.Element((None, 'message'))
message['id'] = 'kontalk' + util.rand_str(8, util.CHARSBOX_AZN_LOWERCASE)
message['type'] = 'chat'
if self.peer:
message['to'] = util.userid_to_jid(self.peer, self.network).full()
else:
message['to'] = jid.userhost()
message.addElement((None, 'body'), content=('%d' % counter))
message.addElement(('urn:xmpp:server-receipts', 'request'))
xs.send(message)
LoopingCall(_loop).start(1)
def testRegisterRequest():
reg = client.IQ(xs, 'get')
reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
reg.send(self.network)
def testRegister():
reg = client.IQ(xs, 'set')
query = reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
form = query.addElement(('jabber:x:data', 'x'))
form['type'] = 'submit'
hidden = form.addElement((None, 'field'))
hidden['type'] = 'hidden'
hidden['var'] = 'FORM_TYPE'
hidden.addElement((None, 'value'), content=xmlstream2.NS_IQ_REGISTER)
phone = form.addElement((None, 'field'))
phone['type'] = 'text-single'
phone['label'] = 'Phone number'
phone['var'] = 'phone'
phone.addElement((None, 'value'), content='+39123456')
reg.send(self.network)
def testValidate():
reg = client.IQ(xs, 'set')
query = reg.addElement((xmlstream2.NS_IQ_REGISTER, 'query'))
form = query.addElement(('jabber:x:data', 'x'))
form['type'] = 'submit'
hidden = form.addElement((None, 'field'))
hidden['type'] = 'hidden'
hidden['var'] = 'FORM_TYPE'
hidden.addElement((None, 'value'), content='http://kontalk.org/protocol/register#code')
code = form.addElement((None, 'field'))
code['type'] = 'text-single'
code['label'] = 'Validation code'
code['var'] = 'code'
code.addElement((None, 'value'), content='686129')
reg.send(self.network)
def testCommand():
cmd = client.IQ(xs, 'set')
ch = cmd.addElement((xmlstream2.NS_PROTO_COMMANDS, 'command'))
ch['node'] = 'serverlist'
ch['action'] = 'execute'
cmd.send(self.network)
def testUpload():
cmd = client.IQ(xs, 'set')
ch = cmd.addElement((xmlstream2.NS_MESSAGE_UPLOAD, 'upload'))
ch['node'] = 'kontalkbox'
media = ch.addElement((None, 'media'))
media['type'] = 'image/png'
cmd.send(self.network)
def testBad():
receipt = domish.Element((None, 'message'))
receipt['id'] = util.rand_str(8)
receipt['type'] = 'chat'
receipt['to'] = self.peer + '@' + self.network
child = receipt.addElement(('urn:xmpp:server-receipts', 'received'))
#child['id'] = util.rand_str(40)
xs.send(receipt)
def _get_sync(self, view, iq, args):
try:
if 'toRepoId' in args and UUID(args['toRepoId']) != self._repoId:
raise RepositoryMismatchError, args['toRepoId']
view.refresh(None, None, False)
repoId = UUID(args['fromRepoId'])
name = args['name']
version = int(args.get('version', '0'))
uuid = args.get('uuid')
if uuid is not None:
uuid = UUID(uuid)
collection, name, uuid = self.findCollection(view, name, uuid)
share = self.findShare(view, collection, repoId, iq['from'])
iq = client.IQ(self.client.xmlstream, "result")
query = iq.addElement(("jabber:x:chandler", "query"))
sync = query.addElement('sync')
sync['name'] = name
changes = self.computeChanges(view, version, collection, share)
keys = set()
compressed = len(changes) > 16
if compressed:
builder = TreeBuilder()
dom = formats.ElementTreeDOM()
data = dom.openElement(builder, 'data')
else:
dom = DomishDOM()
data = dom.openElement(sync, 'data')
for key, (_changes, status) in changes.iteritems():
if key not in keys:
if status & CItem.DELETED:
dom.openElement(data,
'item',
uuid=key.str64(),
status='deleted')
else:
attrs = {'uuid': key.str64()}
if key in collection:
attrs['status'] = 'member'
item = dom.openElement(data, 'item', **attrs)
share.format.exportProcess(dom, key, item, changes,
keys)
dom.closeElement(data, 'item')
elif key in collection:
dom.openElement(data,
'item',
uuid=key.str64(),
status='member')
dom.closeElement(data, 'item')
dom.closeElement(data, 'data')
sync['fromRepoId'] = self._repoId.str64()
sync['toRepoId'] = repoId.str64()
sync['version'] = str(view.itsVersion)
sync['uuid'] = collection.itsUUID.str64()
if compressed:
sync['compressed'] = 'true'
out = StringIO()
ElementTree(builder.close()).write(out, 'utf-8')
sync.children.append(b64encode(compress(out.getvalue())))
out.close()
except:
view.cancel()
raise
share.localVersion = view.itsVersion + 1
share.established = True
share.ackPending = True
view.commit()
return iq
def _result_sync(self, view, iq, sync, args):
try:
view.refresh(None, None, False)
if 'toRepoId' in args and UUID(args['toRepoId']) != self._repoId:
raise RepositoryMismatchError, args['toRepoId']
repoId = UUID(args['fromRepoId'])
uuid = UUID(args['uuid'])
version = int(args['version'])
collection = view.find(uuid)
if collection is None:
collection = pim.SmartCollection(itsView=view,
_uuid=uuid,
displayName=args['name'])
schema.ns("osaf.app", view).sidebarCollection.add(collection)
# for now, grant READ to everyone
acl = ACL()
acl.append(
ACE(schema.ns('p2p', view).all.itsUUID, Permissions.READ))
collection.setACL(acl, 'p2p')
isNew = True
else:
isNew = False
share = self.findShare(view, collection, repoId, iq['from'])
format = share.format
if isNew:
share.localVersion = view.itsVersion + 1
else:
changes = self.computeChanges(view, share.localVersion,
collection, share)
if not changes:
share.localVersion = view.itsVersion + 1
if sync.attributes.get('compressed') == 'true':
dom = formats.ElementTreeDOM()
input = StringIO(decompress(b64decode(sync.children[0])))
data = ElementTree(file=input).getroot()
input.close()
else:
dom = DomishDOM()
data = sync.firstChildElement()
share.remoteVersion = version
view.deferDelete()
for itemElement in dom.iterElements(data):
attributes = dom.getAttributes(itemElement)
status = attributes.get('status')
if status == 'deleted':
item = view.findUUID(attributes['uuid'])
if item is not None:
item.delete()
else:
child = dom.getFirstChildElement(itemElement)
if child is not None:
item = format.importProcess(dom, child)
else:
item = view.findUUID(attributes['uuid'])
if status == 'member':
collection.inclusions.add(item)
# Kludge until masterEvents filter patch on bug 6970 is checked in
for item in collection.inclusions:
if pim.has_stamp(item, pim.EventStamp):
event = pim.EventStamp(item)
if event.rruleset is not None:
event.getMaster().getFirstOccurrence()
except:
view.cancel()
raise
share.established = True
view.commit()
self.client.output("'%s' synchronized" % (collection.displayName))
to = iq['from']
iq = client.IQ(self.client.xmlstream, 'result')
iq.addElement(('jabber:x:chandler', 'query'))
receipt = iq.query.addElement('receipt')
receipt['fromRepoId'] = self._repoId.str64()
receipt['toRepoId'] = repoId.str64()
receipt['uuid'] = collection.itsUUID.str64()
receipt['version'] = str(share.localVersion)
reactor.callFromThread(iq.send, to)
def _execute():
iq = client.IQ(self.client.xmlstream, 'get')
iq.addElement((xmlstream2.NS_IQ_BLOCKING, 'blocklist'))
iq.send()
def _execute():
iq = client.IQ(self.client.xmlstream, 'set')
block = iq.addElement((xmlstream2.NS_IQ_BLOCKING, 'block'))
item = block.addElement((None, 'item'))
item['jid'] = peer
iq.send()
def vcardGet(self, peer):
iq = client.IQ(self.client.xmlstream, 'get')
iq.addElement((xmlstream2.NS_XMPP_VCARD4, 'vcard'))
iq.send(peer)
def _featureParse(self, f):
self.bind = 0
self.session = 0
# TODO - check for tls
if self.success == 1:
for f in f.elements():
if f.name == "bind":
self.bind = 1
if f.name == "session":
self.session = 1
if self.bind:
iq = client.IQ(self.xmlstream, "set")
iq.addElement((BIND_XMLNS, "bind"))
iq.bind.addElement("resource", content=self.jid)
iq.addCallback(self._bindResultEvent)
iq.send()
else:
if f.starttls:
if SSL:
# look for required
#starttls = Element((TLS_XMLNS,"starttls"),TLS_XMLNS)
starttls = Element((None, "starttls"))
# why? --- should not be here!!!!!
starttls['xmlns'] = TLS_XMLNS
self.xmlstream.addOnetimeObserver("/proceed",
self._proceed)
self.xmlstream.addOnetimeObserver("/failue",
self._tlsError)
self.xmlstream.send(starttls)
else:
self.xmlstream.dispatch(f, self.AUTH_FAILED_EVENT)
else:
# Look for SASL
m = f.mechanisms
if m.uri == SASL_XMLNS:
ms = 'DIGEST-MD5'
for mech in m.elements():
ms = str(mech)
if ms == 'DIGEST-MD5':
break
if ms == 'PLAIN':
break
#auth = Element((SASL_XMLNS,"auth"),SASL_XMLNS,{'mechanism' : ms})
auth = Element((None, "auth"), attribs={'mechanism': ms})
# why?
auth['xmlns'] = SASL_XMLNS
# auth['mechanism'] = ms
if ms == 'DIGEST-MD5':
self.xmlstream.addOnetimeObserver(
"/challenge", self._saslStep1)
if ms == 'PLAIN':
# TODO add authzid
auth_str = ""
auth_str = auth_str + "\000"
auth_str = auth_str + self.username.encode('utf-8')
auth_str = auth_str + "\000"
auth_str = auth_str + self.password.encode('utf-8')
auth.addContent(binascii.b2a_base64(auth_str))
self.xmlstream.addOnetimeObserver(
"/success", self._saslSuccess)
self.xmlstream.addObserver("/failure", self._saslError)
self.xmlstream.send(auth)
else:
self.xmlstream.dispatch(f, self.AUTH_FAILED_EVENT)
