345 lines
13 KiB
HTML
345 lines
13 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>RTCDataChannel id attribute</title>
|
|
<script src=/resources/testharness.js></script>
|
|
<script src=/resources/testharnessreport.js></script>
|
|
<script src="RTCPeerConnection-helper.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
// Test is based on the following revision:
|
|
// https://rawgit.com/w3c/webrtc-pc/1cc5bfc3ff18741033d804c4a71f7891242fb5b3/webrtc.html
|
|
|
|
// This is the maximum number of streams, NOT the maximum stream ID (which is 65534)
|
|
// See: https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-13#section-6.2
|
|
const nStreams = 65535;
|
|
|
|
/*
|
|
6.1.
|
|
21. If the [[DataChannelId]] slot is null (due to no ID being passed into
|
|
createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
|
|
transport has already been negotiated, then initialize [[DataChannelId]] to a value
|
|
generated by the user agent, according to [RTCWEB-DATA-PROTOCOL] [...]
|
|
*/
|
|
promise_test(async (t) => {
|
|
const pc = new RTCPeerConnection;
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
const dc1 = pc.createDataChannel('');
|
|
const ids = new UniqueSet();
|
|
|
|
const offer = await pc.createOffer();
|
|
await pc.setLocalDescription(offer);
|
|
// Turn our own offer SDP into valid answer SDP by setting the DTLS role to
|
|
// "active".
|
|
const answer = {
|
|
type: 'answer',
|
|
sdp: pc.localDescription.sdp.replace('actpass', 'active')
|
|
};
|
|
await pc.setRemoteDescription(answer);
|
|
|
|
// Since the remote description had an 'active' DTLS role, we're the server
|
|
// and should use odd data channel IDs, according to rtcweb-data-channel.
|
|
assert_equals(dc1.id % 2, 1,
|
|
`Channel created by the DTLS server role must be odd (was ${dc1.id})`);
|
|
const dc2 = pc.createDataChannel('another');
|
|
assert_equals(dc2.id % 2, 1,
|
|
`Channel created by the DTLS server role must be odd (was ${dc2.id})`);
|
|
|
|
// Ensure IDs are unique
|
|
ids.add(dc1.id, `Channel ID ${dc1.id} should be unique`);
|
|
ids.add(dc2.id, `Channel ID ${dc2.id} should be unique`);
|
|
}, 'DTLS client uses odd data channel IDs');
|
|
|
|
promise_test(async (t) => {
|
|
const pc = new RTCPeerConnection;
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
const dc1 = pc.createDataChannel('');
|
|
const ids = new UniqueSet();
|
|
|
|
const offer = await pc.createOffer();
|
|
await pc.setLocalDescription(offer);
|
|
// Turn our own offer SDP into valid answer SDP by setting the DTLS role to
|
|
// 'passive'.
|
|
const answer = {
|
|
type: 'answer',
|
|
sdp: pc.localDescription.sdp.replace('actpass', 'passive')
|
|
};
|
|
await pc.setRemoteDescription(answer);
|
|
|
|
// Since the remote description had a 'passive' DTLS role, we're the client
|
|
// and should use even data channel IDs, according to rtcweb-data-channel.
|
|
assert_equals(dc1.id % 2, 0,
|
|
`Channel created by the DTLS client role must be even (was ${dc1.id})`);
|
|
const dc2 = pc.createDataChannel('another');
|
|
assert_equals(dc2.id % 2, 0,
|
|
`Channel created by the DTLS client role must be even (was ${dc1.id})`);
|
|
|
|
// Ensure IDs are unique
|
|
ids.add(dc1.id, `Channel ID ${dc1.id} should be unique`);
|
|
ids.add(dc2.id, `Channel ID ${dc2.id} should be unique`);
|
|
}, 'DTLS server uses even data channel IDs');
|
|
|
|
/*
|
|
Checks that the id is ignored if "negotiated" is false.
|
|
See section 6.1, createDataChannel step 13.
|
|
*/
|
|
promise_test(async (t) => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const dc1 = pc1.createDataChannel('', {
|
|
negotiated: false,
|
|
id: 42
|
|
});
|
|
dc1.onopen = t.step_func(() => {
|
|
dc1.send(':(');
|
|
});
|
|
|
|
const dc2 = pc2.createDataChannel('', {
|
|
negotiated: false,
|
|
id: 42
|
|
});
|
|
// ID should be null prior to negotiation.
|
|
assert_equals(dc1.id, null);
|
|
assert_equals(dc2.id, null);
|
|
|
|
exchangeIceCandidates(pc1, pc2);
|
|
await exchangeOfferAnswer(pc1, pc2);
|
|
// We should now have 2 datachannels with different IDs.
|
|
// At least one of the datachannels should not be 42.
|
|
// If one has the value 42, it's an accident; if both have,
|
|
// they are the same datachannel, and it's a bug.
|
|
assert_false(dc1.id == 42 && dc2.id == 42);
|
|
}, 'In-band negotiation with a specific ID should not work');
|
|
|
|
/*
|
|
Check if the implementation still follows the odd/even role correctly if we annoy it with
|
|
negotiated channels not following that rule.
|
|
|
|
Note: This test assumes that the implementation can handle a minimum of 40 data channels.
|
|
*/
|
|
promise_test(async (t) => {
|
|
// Takes the DTLS server role
|
|
const pc1 = new RTCPeerConnection();
|
|
// Takes the DTLS client role
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
exchangeIceCandidates(pc1, pc2);
|
|
const dcs = [];
|
|
const negotiatedDcs = [];
|
|
const ids = new UniqueSet();
|
|
|
|
// Create 10 DCEP-negotiated channels with pc1
|
|
// Note: These should not have any associated valid ID at this point
|
|
for (let i = 0; i < 10; ++i) {
|
|
const dc = pc1.createDataChannel('before-connection');
|
|
assert_equals(dc.id, null, 'Channel id must be null before DTLS role has been determined');
|
|
dcs.push(dc);
|
|
}
|
|
|
|
// Create 10 negotiated channels with pc1 violating the odd/even rule
|
|
for (let id = 0; id < 20; id += 2) {
|
|
const dc = pc1.createDataChannel(`negotiated-not-odd-${id}-before-connection`, {
|
|
negotiated: true,
|
|
id: id,
|
|
});
|
|
assert_equals(dc.id, id, 'Channel id must be set before DTLS role has been determined when negotiated is true');
|
|
negotiatedDcs.push([dc, id]);
|
|
ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
|
|
}
|
|
|
|
await exchangeOfferAnswer(pc1, pc2, {
|
|
offer: (offer) => {
|
|
// Ensure pc1 takes the server role
|
|
assert_true(offer.sdp.includes('actpass') || offer.sdp.includes('passive'),
|
|
'pc1 must take the DTLS server role');
|
|
return offer;
|
|
},
|
|
answer: (answer) => {
|
|
// Ensure pc2 takes the client role
|
|
// Note: It very likely will choose 'active' itself
|
|
answer.sdp = answer.sdp.replace('actpass', 'active');
|
|
assert_true(answer.sdp.includes('active'), 'pc2 must take the DTLS client role');
|
|
return answer;
|
|
},
|
|
});
|
|
|
|
for (const dc of dcs) {
|
|
assert_equals(dc.id % 2, 1,
|
|
`Channel created by the DTLS server role must be odd (was ${dc.id})`);
|
|
ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
|
|
}
|
|
|
|
// Create 10 channels with pc1
|
|
for (let i = 0; i < 10; ++i) {
|
|
const dc = pc1.createDataChannel('after-connection');
|
|
assert_equals(dc.id % 2, 1,
|
|
`Channel created by the DTLS server role must be odd (was ${dc.id})`);
|
|
dcs.push(dc);
|
|
ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
|
|
}
|
|
|
|
// Create 10 negotiated channels with pc1 violating the odd/even rule
|
|
for (let i = 0; i < 10; ++i) {
|
|
// Generate a valid even ID that has not been taken, yet.
|
|
let id = 20;
|
|
while (ids.has(id)) {
|
|
id += 2;
|
|
}
|
|
const dc = pc1.createDataChannel(`negotiated-not-odd-${i}-after-connection`, {
|
|
negotiated: true,
|
|
id: id,
|
|
});
|
|
negotiatedDcs.push([dc, id]);
|
|
ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
|
|
}
|
|
|
|
// Since we've added new channels, let's check again that the odd/even role is not violated
|
|
for (const dc of dcs) {
|
|
assert_equals(dc.id % 2, 1,
|
|
`Channel created by the DTLS server role must be odd (was ${dc.id})`);
|
|
}
|
|
|
|
// Let's also make sure the negotiated channels have kept their ID
|
|
for (const [dc, id] of negotiatedDcs) {
|
|
assert_equals(dc.id, id, 'Negotiated channels should keep their assigned ID');
|
|
}
|
|
}, 'Odd/even role should not be violated when mixing with negotiated channels');
|
|
|
|
/*
|
|
Create 32768 (client), 32767 (server) channels to make sure all ids are exhausted AFTER
|
|
establishing a peer connection.
|
|
|
|
6.1. createDataChannel
|
|
21. If the [[DataChannelId]] slot is null (due to no ID being passed into
|
|
createDataChannel, or [[Negotiated]] being false), and the DTLS role of the SCTP
|
|
transport has already been negotiated, then initialize [[DataChannelId]] to a value
|
|
generated by the user agent, according to [RTCWEB-DATA-PROTOCOL], and skip
|
|
to the next step. If no available ID could be generated, or if the value of the
|
|
[[DataChannelId]] slot is being used by an existing RTCDataChannel, throw an
|
|
OperationError exception.
|
|
*/
|
|
/*
|
|
TODO: Improve test coverage for RTCSctpTransport.maxChannels.
|
|
TODO: Improve test coverage for exhausting channel cases.
|
|
*/
|
|
|
|
/*
|
|
Create 32768 (client), 32767 (server) channels to make sure all ids are exhausted BEFORE
|
|
establishing a peer connection.
|
|
|
|
Be aware that late channel id assignment can currently fail in many places not covered by the
|
|
spec, see: https://github.com/w3c/webrtc-pc/issues/1818
|
|
|
|
4.4.1.6.
|
|
2.2.6. If description negotiates the DTLS role of the SCTP transport, and there is an
|
|
RTCDataChannel with a null id, then generate an ID according to [RTCWEB-DATA-PROTOCOL].
|
|
If no available ID could be generated, then run the following steps:
|
|
1. Let channel be the RTCDataChannel object for which an ID could not be generated.
|
|
2. Set channel's [[ReadyState]] slot to "closed".
|
|
3. Fire an event named error with an OperationError exception at channel.
|
|
4. Fire a simple event named close at channel.
|
|
*/
|
|
/* TEST DISABLED - it takes so long, it times out.
|
|
promise_test(async (t) => {
|
|
const resolver = new Resolver();
|
|
// Takes the DTLS server role
|
|
const pc1 = new RTCPeerConnection();
|
|
// Takes the DTLS client role
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
exchangeIceCandidates(pc1, pc2);
|
|
const dcs = [];
|
|
const ids = new UniqueSet();
|
|
let nExpected = 0;
|
|
let nActualCloses = 0;
|
|
let nActualErrors = 0;
|
|
|
|
const maybeDone = t.step_func(() => {
|
|
if (nExpected === nActualCloses && nExpected === nActualErrors) {
|
|
resolver.resolve();
|
|
}
|
|
});
|
|
|
|
// Create 65535+2 channels (since 65535 streams is a SHOULD, we may have less than that.)
|
|
// Create two extra channels to possibly trigger the steps in the description.
|
|
//
|
|
// Note: Following the spec strictly would assume that this cannot fail. But in reality it will
|
|
// fail because the implementation knows how many streams it supports. What it doesn't
|
|
// know is how many streams the other peer supports (e.g. what will be negotiated).
|
|
for (let i = 0; i < (nStreams + 2); ++i) {
|
|
let dc;
|
|
try {
|
|
const pc = i % 2 === 1 ? pc1 : pc2;
|
|
dc = pc.createDataChannel('this is going to be fun');
|
|
dc.onclose = t.step_func(() => {
|
|
++nActualCloses;
|
|
maybeDone();
|
|
});
|
|
dc.onerror = t.step_func((e) => {
|
|
assert_true(e instanceof RTCError, 'Expect error object to be instance of RTCError');
|
|
assert_equals(e.error, 'sctp-failure', "Expect error to be of type 'sctp-failure'");
|
|
++nActualErrors;
|
|
maybeDone();
|
|
});
|
|
} catch (e) {
|
|
assert_equals(e.name, 'OperationError', 'Fail on creation should throw OperationError');
|
|
break;
|
|
}
|
|
assert_equals(dc.id, null, 'Channel id must be null before DTLS role has been determined');
|
|
assert_not_equals(dc.readyState, 'closed',
|
|
'Channel may not be closed before connection establishment');
|
|
dcs.push([dc, i % 2 === 1]);
|
|
}
|
|
|
|
await exchangeOfferAnswer(pc1, pc2, {
|
|
offer: (offer) => {
|
|
// Ensure pc1 takes the server role
|
|
assert_true(offer.sdp.includes('actpass') || offer.sdp.includes('passive'),
|
|
'pc1 must take the DTLS server role');
|
|
return offer;
|
|
},
|
|
answer: (answer) => {
|
|
// Ensure pc2 takes the client role
|
|
// Note: It very likely will choose 'active' itself
|
|
answer.sdp = answer.sdp.replace('actpass', 'active');
|
|
assert_true(answer.sdp.includes('active'), 'pc2 must take the DTLS client role');
|
|
return answer;
|
|
},
|
|
});
|
|
|
|
// Since the spec does not define a specific order to which channels may fail if an ID could
|
|
// not be generated, any of the channels may be affected by the steps of the description.
|
|
for (const [dc, odd] of dcs) {
|
|
if (dc.readyState !== 'closed') {
|
|
assert_equals(dc.id % 2, odd ? 1 : 0,
|
|
`Channels created by the DTLS ${odd ? 'server' : 'client'} role must be
|
|
${odd ? 'odd' : 'even'} (was ${dc.id})`);
|
|
ids.add(dc.id, `Channel ID ${dc.id} should be unique`);
|
|
} else {
|
|
++nExpected;
|
|
}
|
|
}
|
|
|
|
// Try creating one further channel on both sides. The attempt should fail since all IDs are
|
|
// taken. If one ID is available, the implementation probably miscounts (or I did in the test).
|
|
assert_throws_dom('OperationError', () =>
|
|
pc1.createDataChannel('this is too exhausting!'));
|
|
assert_throws_dom('OperationError', () =>
|
|
pc2.createDataChannel('this is too exhausting!'));
|
|
|
|
maybeDone();
|
|
await resolver;
|
|
}, 'Channel ID exhaustion handling (before and after connection establishment)');
|
|
|
|
END DISABLED TEST */
|
|
|
|
</script>
|