<!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>
Codebase Browser
chromium