def test(q, bus, conn, stream, bytestream_cls, address_type, access_control,
access_control_param):
if bytestream_cls in [BytestreamS5BRelay, BytestreamS5BRelayBugged]:
# disable SOCKS5 relay tests because proxy can't be used with muc
# contacts atm
return
iq_event = q.expect('stream-iq',
to=None,
query_ns='vcard-temp',
query_name='vCard')
acknowledge_iq(stream, iq_event.stanza)
t.check_conn_properties(q, conn)
bob_handle = conn.get_contact_handle_sync('[email protected]/bob')
address = t.create_server(q, address_type)
def new_chan_predicate(e):
types = []
for _, props in e.args[0]:
types.append(props[cs.CHANNEL_TYPE])
return cs.CHANNEL_TYPE_STREAM_TUBE in types
def find_stream_tube(channels):
for path, props in channels:
if props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE:
return path, props
return None, None
# offer a stream tube to another room (new API)
address = t.create_server(q, address_type, block_reading=True)
request = {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_STREAM_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: '*****@*****.**',
cs.STREAM_TUBE_SERVICE: 'newecho',
}
_, new_tube_path, new_tube_props = \
join_muc(q, bus, conn, stream, '*****@*****.**', request)
e = q.expect('dbus-signal',
signal='NewChannels',
predicate=new_chan_predicate)
path, prop = find_stream_tube(e.args[0])
assert prop[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert prop[cs.INITIATOR_ID] == '[email protected]/test'
assert prop[cs.REQUESTED] == True
assert prop[cs.TARGET_HANDLE_TYPE] == cs.HT_ROOM
assert prop[cs.TARGET_ID] == '*****@*****.**'
assert prop[cs.STREAM_TUBE_SERVICE] == 'newecho'
# check that the tube channel is in the channels list
all_channels = conn.Get(cs.CONN_IFACE_REQUESTS,
'Channels',
dbus_interface=cs.PROPERTIES_IFACE,
byte_arrays=True)
assertContains((path, prop), all_channels)
tube_chan = wrap_channel(bus.get_object(conn.bus_name, path), 'StreamTube')
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE,
dbus_interface=cs.PROPERTIES_IFACE)
assert tube_props['State'] == cs.TUBE_CHANNEL_STATE_NOT_OFFERED
# offer the tube
call_async(q, tube_chan.StreamTube, 'Offer', address_type, address,
access_control, {'foo': 'bar'})
stream_event, _, status_event = q.expect_many(
EventPattern('stream-presence',
to='[email protected]/test',
predicate=lambda e: t.presence_contains_tube(e)),
EventPattern('dbus-return', method='Offer'),
EventPattern('dbus-signal',
signal='TubeChannelStateChanged',
args=[cs.TUBE_CHANNEL_STATE_OPEN]))
tube_self_handle = tube_chan.Properties.Get(cs.CHANNEL_IFACE_GROUP,
'SelfHandle')
assert conn.inspect_contact_sync(
tube_self_handle) == '[email protected]/test'
presence = stream_event.stanza
tubes_nodes = xpath.queryForNodes(
'/presence/tubes[@xmlns="%s"]' % ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
stream_tube_id = 666
tube_nodes = xpath.queryForNodes('/tubes/tube', tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube['type'] == 'stream'
assert not tube.hasAttribute('initiator')
assert tube['service'] == 'newecho'
assert not tube.hasAttribute('stream-id')
assert not tube.hasAttribute('dbus-name')
stream_tube_id = int(tube['id'])
params = {}
parameter_nodes = xpath.queryForNodes('/tube/parameters/parameter', tube)
for node in parameter_nodes:
assert node['name'] not in params
params[node['name']] = (node['type'], str(node))
assert params == {'foo': ('str', 'bar')}
bob_handle = conn.get_contact_handle_sync('[email protected]/bob')
bytestream = connect_to_tube(stream, q, bytestream_cls,
'*****@*****.**', stream_tube_id)
iq_event, socket_event, conn_event = q.expect_many(
EventPattern('stream-iq', iq_type='result'),
EventPattern('socket-connected'),
EventPattern('dbus-signal',
signal='NewRemoteConnection',
interface=cs.CHANNEL_TYPE_STREAM_TUBE))
handle, access, conn_id = conn_event.args
assert handle == bob_handle
protocol = socket_event.protocol
# start to read from the transport so we can read the control byte
protocol.transport.startReading()
t.check_new_connection_access(q, access_control, access, protocol)
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES,
iq_event.stanza)
assert len(tube) == 1
use_tube(q, bytestream, protocol, conn_id)
tube_chan.Channel.Close()
q.expect_many(EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
t.cleanup()
def test(q, bus, conn, stream):
vcard_event, roster_event = q.expect_many(
EventPattern('stream-iq',
to=None,
query_ns='vcard-temp',
query_name='vCard'),
EventPattern('stream-iq', query_ns=ns.ROSTER))
acknowledge_iq(stream, vcard_event.stanza)
# Send a roster with one member, Joe.
roster = roster_event.stanza
roster['type'] = 'result'
item = roster_event.query.addElement('item')
item['jid'] = 'joe@localhost'
item['subscription'] = 'both'
stream.send(roster)
# Send Joe's presence.
presence = domish.Element(('jabber:client', 'presence'))
presence['from'] = 'joe@localhost/Joe'
presence['to'] = 'test@localhost/Resource'
c = presence.addElement('c')
c['xmlns'] = 'http://jabber.org/protocol/caps'
c['node'] = 'http://example.com/IDontSupportTubes'
c['ver'] = '1.0'
stream.send(presence)
# Gabble discoes Joe, because it doesn't know his client's caps
event = q.expect('stream-iq',
iq_type='get',
query_ns='http://jabber.org/protocol/disco#info',
to='joe@localhost/Joe')
assert event.query['node'] == 'http://example.com/IDontSupportTubes#1.0'
# Send a "Joe doesn't have any caps" response.
result = event.stanza
result['type'] = 'result'
stream.send(result)
# Ensure Joe's caps have been received.
# FIXME: we shouldn't need to do this, the tubes code should wait for the
# caps to appear, just like the StreamedMedia channel does.
sync_stream(q, stream)
address = t.create_server(q, cs.SOCKET_ADDRESS_TYPE_IPV4)
# Now we try making new-style DBusTube and StreamTube channels, and calling
# the relevant Offer method on them; this should fail with NotAvailable.
# FIXME: I think this should be NotCapable
st_path, _ = conn.Requests.CreateChannel(
props(cs.CHANNEL_TYPE_STREAM_TUBE,
{cs.STREAM_TUBE_SERVICE: "newecho"}))
st_chan = bus.get_object(conn.bus_name, st_path)
st = dbus.Interface(st_chan, cs.CHANNEL_TYPE_STREAM_TUBE)
call_async(q, st, 'Offer', cs.SOCKET_ADDRESS_TYPE_IPV4, address,
cs.SOCKET_ACCESS_CONTROL_LOCALHOST, {})
e = q.expect('dbus-error', method='Offer').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
dt_path, _ = conn.Requests.CreateChannel(
props(cs.CHANNEL_TYPE_DBUS_TUBE,
{cs.DBUS_TUBE_SERVICE_NAME: "com.newecho"}))
dt_chan = bus.get_object(conn.bus_name, dt_path)
dt = dbus.Interface(dt_chan, cs.CHANNEL_TYPE_DBUS_TUBE)
call_async(q, dt, 'Offer', {}, cs.SOCKET_ACCESS_CONTROL_CREDENTIALS)
e = q.expect('dbus-error', method='Offer').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
t.cleanup()
def test(q, bus, conn, stream, bytestream_cls, address_type, access_control, access_control_param):
if bytestream_cls in [BytestreamS5BRelay, BytestreamS5BRelayBugged]:
# disable SOCKS5 relay tests because proxy can't be used with muc
# contacts atm
return
conn.Connect()
_, iq_event = q.expect_many(
EventPattern("dbus-signal", signal="StatusChanged", args=[cs.CONN_STATUS_CONNECTED, cs.CSR_REQUESTED]),
EventPattern("stream-iq", to=None, query_ns="vcard-temp", query_name="vCard"),
)
acknowledge_iq(stream, iq_event.stanza)
self_handle = conn.GetSelfHandle()
self_name = conn.InspectHandles(cs.HT_CONTACT, [self_handle])[0]
t.check_conn_properties(q, conn)
room_handle, tubes_chan, tubes_iface = get_muc_tubes_channel(q, bus, conn, stream, "*****@*****.**")
tubes_self_handle = tubes_chan.GetSelfHandle(dbus_interface=cs.CHANNEL_IFACE_GROUP)
bob_handle = conn.RequestHandles(cs.HT_CONTACT, ["[email protected]/bob"])[0]
address = t.create_server(q, address_type)
# offer stream tube (old API) using an Unix socket
call_async(
q,
tubes_iface,
"OfferStreamTube",
"echo",
sample_parameters,
address_type,
address,
access_control,
access_control_param,
)
new_tube_event, stream_event, _, new_channels_event = q.expect_many(
EventPattern("dbus-signal", signal="NewTube"),
EventPattern("stream-presence", to="[email protected]/test"),
EventPattern("dbus-return", method="OfferStreamTube"),
EventPattern("dbus-signal", signal="NewChannels"),
)
# handle new_tube_event
stream_tube_id = new_tube_event.args[0]
assert new_tube_event.args[1] == tubes_self_handle
assert new_tube_event.args[2] == 1 # Stream
assert new_tube_event.args[3] == "echo"
assert new_tube_event.args[4] == sample_parameters
assert new_tube_event.args[5] == cs.TUBE_CHANNEL_STATE_OPEN
# handle stream_event
# We announce our newly created tube in our muc presence
presence = stream_event.stanza
x_nodes = xpath.queryForNodes('/presence/x[@xmlns="http://jabber.org/' 'protocol/muc"]', presence)
assert x_nodes is not None
assert len(x_nodes) == 1
tubes_nodes = xpath.queryForNodes('/presence/tubes[@xmlns="%s"]' % ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
tube_nodes = xpath.queryForNodes("/tubes/tube", tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube["type"] == "stream"
assert not tube.hasAttribute("initiator")
assert tube["service"] == "echo"
assert not tube.hasAttribute("stream-id")
assert not tube.hasAttribute("dbus-name")
assert tube["id"] == str(stream_tube_id)
params = {}
parameter_nodes = xpath.queryForNodes("/tube/parameters/parameter", tube)
for node in parameter_nodes:
assert node["name"] not in params
params[node["name"]] = (node["type"], str(node))
assert params == {"ay": ("bytes", "aGVsbG8="), "s": ("str", "hello"), "i": ("int", "-123"), "u": ("uint", "123")}
# tube is also announced using new API
channels = new_channels_event.args[0]
assert len(channels) == 1
path, props = channels[0]
assert props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert props[cs.INITIATOR_HANDLE] == tubes_self_handle
assert props[cs.INITIATOR_ID] == "[email protected]/test"
assert props[cs.INTERFACES] == [cs.CHANNEL_IFACE_GROUP, cs.CHANNEL_IFACE_TUBE]
assert props[cs.REQUESTED] == True
assert props[cs.TARGET_HANDLE] == room_handle
assert props[cs.TARGET_ID] == "*****@*****.**"
assert props[cs.STREAM_TUBE_SERVICE] == "echo"
tube_chan = bus.get_object(conn.bus_name, path)
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE, dbus_interface=cs.PROPERTIES_IFACE, byte_arrays=True)
assert tube_props["Parameters"] == sample_parameters
assert tube_props["State"] == cs.TUBE_CHANNEL_STATE_OPEN
tubes = tubes_iface.ListTubes(byte_arrays=True)
assert tubes == [
(stream_tube_id, tubes_self_handle, 1, "echo", sample_parameters, cs.TUBE_CHANNEL_STATE_OPEN) # Stream
]
assert len(tubes) == 1, unwrap(tubes)
expected_tube = (
stream_tube_id,
tubes_self_handle,
cs.TUBE_TYPE_STREAM,
"echo",
sample_parameters,
cs.TUBE_STATE_OPEN,
)
t.check_tube_in_tubes(expected_tube, tubes)
# FIXME: if we use an unknown JID here, everything fails
# (the code uses lookup where it should use ensure)
bytestream = connect_to_tube(stream, q, bytestream_cls, "*****@*****.**", stream_tube_id)
iq_event, socket_event, _, conn_event = q.expect_many(
EventPattern("stream-iq", iq_type="result"),
EventPattern("socket-connected"),
EventPattern(
"dbus-signal",
signal="StreamTubeNewConnection",
args=[stream_tube_id, bob_handle],
interface=cs.CHANNEL_TYPE_TUBES,
),
EventPattern("dbus-signal", signal="NewRemoteConnection", interface=cs.CHANNEL_TYPE_STREAM_TUBE),
)
protocol = socket_event.protocol
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES, iq_event.stanza)
assert len(tube) == 1
handle, access, conn_id = conn_event.args
assert handle == bob_handle
use_tube(q, bytestream, protocol, conn_id)
# offer a stream tube to another room (new API)
address = t.create_server(q, address_type, block_reading=True)
request = {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_STREAM_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: "*****@*****.**",
cs.STREAM_TUBE_SERVICE: "newecho",
}
_, _, new_tube_path, new_tube_props = join_muc(q, bus, conn, stream, "*****@*****.**", request)
# first text and tubes channels are announced
event = q.expect("dbus-signal", signal="NewChannels")
channels = event.args[0]
assert len(channels) == 2
path1, prop1 = channels[0]
path2, prop2 = channels[1]
assert sorted([prop1[cs.CHANNEL_TYPE], prop2[cs.CHANNEL_TYPE]]) == [cs.CHANNEL_TYPE_TEXT, cs.CHANNEL_TYPE_TUBES]
got_text, got_tubes = False, False
for path, props in channels:
if props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TEXT:
got_text = True
elif props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TUBES:
got_tubes = True
else:
assert False
assert props[cs.INITIATOR_HANDLE] == self_handle
assert props[cs.INITIATOR_ID] == self_name
assert cs.CHANNEL_IFACE_GROUP in props[cs.INTERFACES]
assert props[cs.TARGET_ID] == "*****@*****.**"
assert props[cs.REQUESTED] == False
assert (got_text, got_tubes) == (True, True)
# now the tube channel is announced
# FIXME: in this case, all channels should probably be announced together
event = q.expect("dbus-signal", signal="NewChannels")
channels = event.args[0]
assert len(channels) == 1
path, prop = channels[0]
assert prop[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert prop[cs.INITIATOR_ID] == "[email protected]/test"
assert prop[cs.REQUESTED] == True
assert prop[cs.TARGET_HANDLE_TYPE] == cs.HT_ROOM
assert prop[cs.TARGET_ID] == "*****@*****.**"
assert prop[cs.STREAM_TUBE_SERVICE] == "newecho"
# check that the tube channel is in the channels list
all_channels = conn.Get(cs.CONN_IFACE_REQUESTS, "Channels", dbus_interface=cs.PROPERTIES_IFACE, byte_arrays=True)
assertContains((path, prop), all_channels)
tube_chan = bus.get_object(conn.bus_name, path)
stream_tube_iface = dbus.Interface(tube_chan, cs.CHANNEL_TYPE_STREAM_TUBE)
chan_iface = dbus.Interface(tube_chan, cs.CHANNEL)
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE, dbus_interface=cs.PROPERTIES_IFACE)
assert tube_props["State"] == cs.TUBE_CHANNEL_STATE_NOT_OFFERED
# offer the tube
call_async(q, stream_tube_iface, "Offer", address_type, address, access_control, {"foo": "bar"})
new_tube_event, stream_event, _, status_event = q.expect_many(
EventPattern("dbus-signal", signal="NewTube"),
EventPattern("stream-presence", to="[email protected]/test"),
EventPattern("dbus-return", method="Offer"),
EventPattern("dbus-signal", signal="TubeChannelStateChanged", args=[cs.TUBE_CHANNEL_STATE_OPEN]),
)
tube_self_handle = tube_chan.GetSelfHandle(dbus_interface=cs.CHANNEL_IFACE_GROUP)
assert conn.InspectHandles(cs.HT_CONTACT, [tube_self_handle]) == ["[email protected]/test"]
# handle new_tube_event
stream_tube_id = new_tube_event.args[0]
assert new_tube_event.args[2] == 1 # Stream
assert new_tube_event.args[3] == "newecho"
assert new_tube_event.args[4] == {"foo": "bar"}
assert new_tube_event.args[5] == cs.TUBE_CHANNEL_STATE_OPEN
presence = stream_event.stanza
x_nodes = xpath.queryForNodes('/presence/x[@xmlns="http://jabber.org/' 'protocol/muc"]', presence)
assert x_nodes is not None
assert len(x_nodes) == 1
tubes_nodes = xpath.queryForNodes('/presence/tubes[@xmlns="%s"]' % ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
tube_nodes = xpath.queryForNodes("/tubes/tube", tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube["type"] == "stream"
assert not tube.hasAttribute("initiator")
assert tube["service"] == "newecho"
assert not tube.hasAttribute("stream-id")
assert not tube.hasAttribute("dbus-name")
assert tube["id"] == str(stream_tube_id)
params = {}
parameter_nodes = xpath.queryForNodes("/tube/parameters/parameter", tube)
for node in parameter_nodes:
assert node["name"] not in params
params[node["name"]] = (node["type"], str(node))
assert params == {"foo": ("str", "bar")}
bob_handle = conn.RequestHandles(cs.HT_CONTACT, ["[email protected]/bob"])[0]
bytestream = connect_to_tube(stream, q, bytestream_cls, "*****@*****.**", stream_tube_id)
iq_event, socket_event, conn_event = q.expect_many(
EventPattern("stream-iq", iq_type="result"),
EventPattern("socket-connected"),
EventPattern("dbus-signal", signal="NewRemoteConnection", interface=cs.CHANNEL_TYPE_STREAM_TUBE),
)
handle, access, conn_id = conn_event.args
assert handle == bob_handle
protocol = socket_event.protocol
# start to read from the transport so we can read the control byte
protocol.transport.startReading()
t.check_new_connection_access(q, access_control, access, protocol)
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES, iq_event.stanza)
assert len(tube) == 1
use_tube(q, bytestream, protocol, conn_id)
chan_iface.Close()
q.expect_many(EventPattern("dbus-signal", signal="Closed"), EventPattern("dbus-signal", signal="ChannelClosed"))
def test(q, bus, conn, stream, bytestream_cls,
address_type, access_control, access_control_param):
if bytestream_cls in [BytestreamS5BRelay, BytestreamS5BRelayBugged]:
# disable SOCKS5 relay tests because proxy can't be used with muc
# contacts atm
return
iq_event = q.expect('stream-iq', to=None, query_ns='vcard-temp',
query_name='vCard')
acknowledge_iq(stream, iq_event.stanza)
t.check_conn_properties(q, conn)
bob_handle = conn.get_contact_handle_sync('[email protected]/bob')
address = t.create_server(q, address_type)
def new_chan_predicate(e):
types = []
for _, props in e.args[0]:
types.append(props[cs.CHANNEL_TYPE])
return cs.CHANNEL_TYPE_STREAM_TUBE in types
def find_stream_tube(channels):
for path, props in channels:
if props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE:
return path, props
return None, None
# offer a stream tube to another room (new API)
address = t.create_server(q, address_type, block_reading=True)
request = {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_STREAM_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: '*****@*****.**',
cs.STREAM_TUBE_SERVICE: 'newecho',
}
_, new_tube_path, new_tube_props = \
join_muc(q, bus, conn, stream, '*****@*****.**', request)
e = q.expect('dbus-signal', signal='NewChannels',
predicate=new_chan_predicate)
path, prop = find_stream_tube(e.args[0])
assert prop[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert prop[cs.INITIATOR_ID] == '[email protected]/test'
assert prop[cs.REQUESTED] == True
assert prop[cs.TARGET_HANDLE_TYPE] == cs.HT_ROOM
assert prop[cs.TARGET_ID] == '*****@*****.**'
assert prop[cs.STREAM_TUBE_SERVICE] == 'newecho'
# check that the tube channel is in the channels list
all_channels = conn.Get(cs.CONN_IFACE_REQUESTS, 'Channels',
dbus_interface=cs.PROPERTIES_IFACE, byte_arrays=True)
assertContains((path, prop), all_channels)
tube_chan = wrap_channel(bus.get_object(conn.bus_name, path), 'StreamTube')
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE, dbus_interface=cs.PROPERTIES_IFACE)
assert tube_props['State'] == cs.TUBE_CHANNEL_STATE_NOT_OFFERED
# offer the tube
call_async(q, tube_chan.StreamTube, 'Offer', address_type, address, access_control, {'foo': 'bar'})
stream_event, _, status_event = q.expect_many(
EventPattern('stream-presence', to='[email protected]/test', predicate=lambda e: t.presence_contains_tube(e)),
EventPattern('dbus-return', method='Offer'),
EventPattern('dbus-signal', signal='TubeChannelStateChanged', args=[cs.TUBE_CHANNEL_STATE_OPEN]))
tube_self_handle = tube_chan.Properties.Get(cs.CHANNEL_IFACE_GROUP, 'SelfHandle')
assert conn.inspect_contact_sync(tube_self_handle) == '[email protected]/test'
presence = stream_event.stanza
tubes_nodes = xpath.queryForNodes('/presence/tubes[@xmlns="%s"]'
% ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
stream_tube_id = 666
tube_nodes = xpath.queryForNodes('/tubes/tube', tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube['type'] == 'stream'
assert not tube.hasAttribute('initiator')
assert tube['service'] == 'newecho'
assert not tube.hasAttribute('stream-id')
assert not tube.hasAttribute('dbus-name')
stream_tube_id = int(tube['id'])
params = {}
parameter_nodes = xpath.queryForNodes('/tube/parameters/parameter', tube)
for node in parameter_nodes:
assert node['name'] not in params
params[node['name']] = (node['type'], str(node))
assert params == {'foo': ('str', 'bar')}
bob_handle = conn.get_contact_handle_sync('[email protected]/bob')
bytestream = connect_to_tube(stream, q, bytestream_cls, '*****@*****.**', stream_tube_id)
iq_event, socket_event, conn_event = q.expect_many(
EventPattern('stream-iq', iq_type='result'),
EventPattern('socket-connected'),
EventPattern('dbus-signal', signal='NewRemoteConnection',
interface=cs.CHANNEL_TYPE_STREAM_TUBE))
handle, access, conn_id = conn_event.args
assert handle == bob_handle
protocol = socket_event.protocol
# start to read from the transport so we can read the control byte
protocol.transport.startReading()
t.check_new_connection_access(q, access_control, access, protocol)
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES, iq_event.stanza)
assert len(tube) == 1
use_tube(q, bytestream, protocol, conn_id)
tube_chan.Channel.Close()
q.expect_many(
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
t.cleanup()
def test(q, bus, conn, stream, bytestream_cls,
address_type, access_control, access_control_param):
if bytestream_cls in [BytestreamS5BRelay, BytestreamS5BRelayBugged]:
# disable SOCKS5 relay tests because proxy can't be used with muc
# contacts atm
return
iq_event = q.expect('stream-iq', to=None, query_ns='vcard-temp',
query_name='vCard')
acknowledge_iq(stream, iq_event.stanza)
self_handle = conn.GetSelfHandle()
self_name = conn.InspectHandles(cs.HT_CONTACT, [self_handle])[0]
t.check_conn_properties(q, conn)
room_handle, tubes_chan, tubes_iface = get_muc_tubes_channel(q, bus, conn,
stream, '*****@*****.**')
tubes_self_handle = tubes_chan.GetSelfHandle(dbus_interface=cs.CHANNEL_IFACE_GROUP)
bob_handle = conn.RequestHandles(cs.HT_CONTACT, ['[email protected]/bob'])[0]
address = t.create_server(q, address_type)
# offer stream tube (old API) using an Unix socket
call_async(q, tubes_iface, 'OfferStreamTube',
'echo', sample_parameters, address_type, address,
access_control, access_control_param)
new_tube_event, stream_event, _, new_channels_event = q.expect_many(
EventPattern('dbus-signal', signal='NewTube'),
EventPattern('stream-presence', to='[email protected]/test'),
EventPattern('dbus-return', method='OfferStreamTube'),
EventPattern('dbus-signal', signal='NewChannels'))
# handle new_tube_event
stream_tube_id = new_tube_event.args[0]
assert new_tube_event.args[1] == tubes_self_handle
assert new_tube_event.args[2] == 1 # Stream
assert new_tube_event.args[3] == 'echo'
assert new_tube_event.args[4] == sample_parameters
assert new_tube_event.args[5] == cs.TUBE_CHANNEL_STATE_OPEN
# handle stream_event
# We announce our newly created tube in our muc presence
presence = stream_event.stanza
tubes_nodes = xpath.queryForNodes('/presence/tubes[@xmlns="%s"]'
% ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
tube_nodes = xpath.queryForNodes('/tubes/tube', tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube['type'] == 'stream'
assert not tube.hasAttribute('initiator')
assert tube['service'] == 'echo'
assert not tube.hasAttribute('stream-id')
assert not tube.hasAttribute('dbus-name')
assert tube['id'] == str(stream_tube_id)
params = {}
parameter_nodes = xpath.queryForNodes('/tube/parameters/parameter', tube)
for node in parameter_nodes:
assert node['name'] not in params
params[node['name']] = (node['type'], str(node))
assert params == {'ay': ('bytes', 'aGVsbG8='),
's': ('str', 'hello'),
'i': ('int', '-123'),
'u': ('uint', '123'),
}
# tube is also announced using new API
channels = new_channels_event.args[0]
assert len(channels) == 1
path, props = channels[0]
assert props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert props[cs.INITIATOR_HANDLE] == tubes_self_handle
assert props[cs.INITIATOR_ID] == '[email protected]/test'
assert props[cs.INTERFACES] == [cs.CHANNEL_IFACE_GROUP, cs.CHANNEL_IFACE_TUBE]
assert props[cs.REQUESTED] == True
assert props[cs.TARGET_HANDLE] == room_handle
assert props[cs.TARGET_ID] == '*****@*****.**'
assert props[cs.STREAM_TUBE_SERVICE] == 'echo'
tube_chan = bus.get_object(conn.bus_name, path)
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE, dbus_interface=cs.PROPERTIES_IFACE,
byte_arrays=True)
assert tube_props['Parameters'] == sample_parameters
assert tube_props['State'] == cs.TUBE_CHANNEL_STATE_OPEN
tubes = tubes_iface.ListTubes(byte_arrays=True)
assert tubes == [(
stream_tube_id,
tubes_self_handle,
1, # Stream
'echo',
sample_parameters,
cs.TUBE_CHANNEL_STATE_OPEN
)]
assert len(tubes) == 1, unwrap(tubes)
expected_tube = (stream_tube_id, tubes_self_handle, cs.TUBE_TYPE_STREAM,
'echo', sample_parameters, cs.TUBE_STATE_OPEN)
t.check_tube_in_tubes(expected_tube, tubes)
# FIXME: if we use an unknown JID here, everything fails
# (the code uses lookup where it should use ensure)
bytestream = connect_to_tube(stream, q, bytestream_cls, '*****@*****.**', stream_tube_id)
iq_event, socket_event, _, conn_event = q.expect_many(
EventPattern('stream-iq', iq_type='result'),
EventPattern('socket-connected'),
EventPattern('dbus-signal', signal='StreamTubeNewConnection',
args=[stream_tube_id, bob_handle], interface=cs.CHANNEL_TYPE_TUBES),
EventPattern('dbus-signal', signal='NewRemoteConnection',
interface=cs.CHANNEL_TYPE_STREAM_TUBE))
protocol = socket_event.protocol
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES, iq_event.stanza)
assert len(tube) == 1
handle, access, conn_id = conn_event.args
assert handle == bob_handle
use_tube(q, bytestream, protocol, conn_id)
# offer a stream tube to another room (new API)
address = t.create_server(q, address_type, block_reading=True)
request = {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_STREAM_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: '*****@*****.**',
cs.STREAM_TUBE_SERVICE: 'newecho',
}
_, _, new_tube_path, new_tube_props = \
join_muc(q, bus, conn, stream, '*****@*****.**', request)
# The order in which the NewChannels signals are fired is
# undefined -- it could be the (tubes, text) channels first, or it
# could be the tube channel first; so let's accept either order
# here.
first, second = q.expect_many(
EventPattern('dbus-signal', signal='NewChannels'),
EventPattern('dbus-signal', signal='NewChannels'))
# NewChannels signal with the text and tubes channels together.
def nc_textandtubes(event):
channels = event.args[0]
assert len(channels) == 2
path1, prop1 = channels[0]
path2, prop2 = channels[1]
assert sorted([prop1[cs.CHANNEL_TYPE], prop2[cs.CHANNEL_TYPE]]) == \
[cs.CHANNEL_TYPE_TEXT, cs.CHANNEL_TYPE_TUBES]
got_text, got_tubes = False, False
for path, props in channels:
if props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TEXT:
got_text = True
elif props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TUBES:
got_tubes = True
else:
assert False
assert props[cs.INITIATOR_HANDLE] == self_handle
assert props[cs.INITIATOR_ID] == self_name
assert cs.CHANNEL_IFACE_GROUP in props[cs.INTERFACES]
assert props[cs.TARGET_ID] == '*****@*****.**'
assert props[cs.REQUESTED] == False
assert (got_text, got_tubes) == (True, True)
# NewChannels signal with the tube channel.
def nc_tube(event):
# FIXME: in this case, all channels should probably be announced together
channels = event.args[0]
assert len(channels) == 1
path, prop = channels[0]
assert prop[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_STREAM_TUBE
assert prop[cs.INITIATOR_ID] == '[email protected]/test'
assert prop[cs.REQUESTED] == True
assert prop[cs.TARGET_HANDLE_TYPE] == cs.HT_ROOM
assert prop[cs.TARGET_ID] == '*****@*****.**'
assert prop[cs.STREAM_TUBE_SERVICE] == 'newecho'
return path, prop
if len(first.args[0]) == 1:
path, prop = nc_tube(first)
nc_textandtubes(second)
else:
nc_textandtubes(first)
path, prop = nc_tube(second)
# check that the tube channel is in the channels list
all_channels = conn.Get(cs.CONN_IFACE_REQUESTS, 'Channels',
dbus_interface=cs.PROPERTIES_IFACE, byte_arrays=True)
assertContains((path, prop), all_channels)
tube_chan = bus.get_object(conn.bus_name, path)
stream_tube_iface = dbus.Interface(tube_chan, cs.CHANNEL_TYPE_STREAM_TUBE)
chan_iface = dbus.Interface(tube_chan, cs.CHANNEL)
tube_props = tube_chan.GetAll(cs.CHANNEL_IFACE_TUBE, dbus_interface=cs.PROPERTIES_IFACE)
assert tube_props['State'] == cs.TUBE_CHANNEL_STATE_NOT_OFFERED
# offer the tube
call_async(q, stream_tube_iface, 'Offer', address_type, address, access_control, {'foo': 'bar'})
new_tube_event, stream_event, _, status_event = q.expect_many(
EventPattern('dbus-signal', signal='NewTube'),
EventPattern('stream-presence', to='[email protected]/test'),
EventPattern('dbus-return', method='Offer'),
EventPattern('dbus-signal', signal='TubeChannelStateChanged', args=[cs.TUBE_CHANNEL_STATE_OPEN]))
tube_self_handle = tube_chan.GetSelfHandle(dbus_interface=cs.CHANNEL_IFACE_GROUP)
assert conn.InspectHandles(cs.HT_CONTACT, [tube_self_handle]) == ['[email protected]/test']
# handle new_tube_event
stream_tube_id = new_tube_event.args[0]
assert new_tube_event.args[2] == 1 # Stream
assert new_tube_event.args[3] == 'newecho'
assert new_tube_event.args[4] == {'foo': 'bar'}
assert new_tube_event.args[5] == cs.TUBE_CHANNEL_STATE_OPEN
presence = stream_event.stanza
tubes_nodes = xpath.queryForNodes('/presence/tubes[@xmlns="%s"]'
% ns.TUBES, presence)
assert tubes_nodes is not None
assert len(tubes_nodes) == 1
tube_nodes = xpath.queryForNodes('/tubes/tube', tubes_nodes[0])
assert tube_nodes is not None
assert len(tube_nodes) == 1
for tube in tube_nodes:
assert tube['type'] == 'stream'
assert not tube.hasAttribute('initiator')
assert tube['service'] == 'newecho'
assert not tube.hasAttribute('stream-id')
assert not tube.hasAttribute('dbus-name')
assert tube['id'] == str(stream_tube_id)
params = {}
parameter_nodes = xpath.queryForNodes('/tube/parameters/parameter', tube)
for node in parameter_nodes:
assert node['name'] not in params
params[node['name']] = (node['type'], str(node))
assert params == {'foo': ('str', 'bar')}
bob_handle = conn.RequestHandles(cs.HT_CONTACT, ['[email protected]/bob'])[0]
bytestream = connect_to_tube(stream, q, bytestream_cls, '*****@*****.**', stream_tube_id)
iq_event, socket_event, conn_event = q.expect_many(
EventPattern('stream-iq', iq_type='result'),
EventPattern('socket-connected'),
EventPattern('dbus-signal', signal='NewRemoteConnection',
interface=cs.CHANNEL_TYPE_STREAM_TUBE))
handle, access, conn_id = conn_event.args
assert handle == bob_handle
protocol = socket_event.protocol
# start to read from the transport so we can read the control byte
protocol.transport.startReading()
t.check_new_connection_access(q, access_control, access, protocol)
# handle iq_event
bytestream.check_si_reply(iq_event.stanza)
tube = xpath.queryForNodes('/iq//si/tube[@xmlns="%s"]' % ns.TUBES, iq_event.stanza)
assert len(tube) == 1
use_tube(q, bytestream, protocol, conn_id)
chan_iface.Close()
q.expect_many(
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'))
def test(q, bus, conn, stream):
vcard_event, roster_event = q.expect_many(
EventPattern('stream-iq', to=None, query_ns='vcard-temp',
query_name='vCard'),
EventPattern('stream-iq', query_ns=ns.ROSTER))
acknowledge_iq(stream, vcard_event.stanza)
# Send a roster with one member, Joe.
roster = roster_event.stanza
roster['type'] = 'result'
item = roster_event.query.addElement('item')
item['jid'] = 'joe@localhost'
item['subscription'] = 'both'
stream.send(roster)
# Send Joe's presence.
presence = domish.Element(('jabber:client', 'presence'))
presence['from'] = 'joe@localhost/Joe'
presence['to'] = 'test@localhost/Resource'
c = presence.addElement('c')
c['xmlns'] = 'http://jabber.org/protocol/caps'
c['node'] = 'http://example.com/IDontSupportTubes'
c['ver'] = '1.0'
stream.send(presence)
# Gabble discoes Joe, because it doesn't know his client's caps
event = q.expect('stream-iq', iq_type='get',
query_ns='http://jabber.org/protocol/disco#info',
to='joe@localhost/Joe')
assert event.query['node'] == 'http://example.com/IDontSupportTubes#1.0'
# Send a "Joe doesn't have any caps" response.
result = event.stanza
result['type'] = 'result'
stream.send(result)
# Ensure Joe's caps have been received.
# FIXME: we shouldn't need to do this, the tubes code should wait for the
# caps to appear, just like the StreamedMedia channel does.
sync_stream(q, stream)
requests = dbus.Interface(conn, cs.CONN_IFACE_REQUESTS)
# First, we make an old-style Tubes channel, which should work; calling
# OfferStreamTube or OfferDBusTube on it, however, should fail with
# NotAvailable
path, _ = requests.CreateChannel(props(cs.CHANNEL_TYPE_TUBES))
tubes = make_channel_proxy(conn, path, 'Channel.Type.Tubes')
call_async(q, tubes, 'OfferDBusTube', 'com.example.monkeys', {})
e = q.expect('dbus-error', method='OfferDBusTube').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
address = t.create_server(q, cs.SOCKET_ADDRESS_TYPE_IPV4)
call_async(q, tubes, 'OfferStreamTube', 'echo', {},
cs.SOCKET_ADDRESS_TYPE_IPV4, address,
cs.SOCKET_ACCESS_CONTROL_LOCALHOST, "")
e = q.expect('dbus-error', method='OfferStreamTube').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
# Now we try making new-style DBusTube and StreamTube channels, and calling
# the relevant Offer method on them; this should fail with NotAvailable.
# FIXME: I think this should be NotCapable
st_path, _ = requests.CreateChannel(props(cs.CHANNEL_TYPE_STREAM_TUBE,
{cs.STREAM_TUBE_SERVICE: "newecho"}))
st_chan = bus.get_object(conn.bus_name, st_path)
st = dbus.Interface(st_chan, cs.CHANNEL_TYPE_STREAM_TUBE)
call_async(q, st, 'Offer', cs.SOCKET_ADDRESS_TYPE_IPV4,
address, cs.SOCKET_ACCESS_CONTROL_LOCALHOST, {})
e = q.expect('dbus-error', method='Offer').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
dt_path, _ = requests.CreateChannel(props(cs.CHANNEL_TYPE_DBUS_TUBE,
{ cs.DBUS_TUBE_SERVICE_NAME: "com.newecho" }))
dt_chan = bus.get_object(conn.bus_name, dt_path)
dt = dbus.Interface(dt_chan, cs.CHANNEL_TYPE_DBUS_TUBE)
call_async(q, dt, 'Offer', {}, cs.SOCKET_ACCESS_CONTROL_CREDENTIALS)
e = q.expect('dbus-error', method='Offer').error
assert e.get_dbus_name() == cs.NOT_AVAILABLE, e.get_dbus_name()
