mirror of
https://github.com/jech/galene.git
synced 2024-12-22 15:25:48 +01:00
86eeb3d8cf
When a user sends a file to oneself (which is only possible as a chat command), then the two file transfer data structures have the same id, which causes confusion. We used to detect this case too late, detect it earlier. Thanks to J.-J. Sarton for the report.
2296 lines
62 KiB
JavaScript
2296 lines
62 KiB
JavaScript
// Copyright (c) 2020 by Juliusz Chroboczek.
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
'use strict';
|
|
|
|
/**
|
|
* toHex formats an array as a hexadecimal string.
|
|
*
|
|
* @param {number[]|Uint8Array} array - the array to format
|
|
* @returns {string} - the hexadecimal representation of array
|
|
*/
|
|
function toHex(array) {
|
|
let a = new Uint8Array(array);
|
|
function hex(x) {
|
|
let h = x.toString(16);
|
|
if(h.length < 2)
|
|
h = '0' + h;
|
|
return h;
|
|
}
|
|
return a.reduce((x, y) => x + hex(y), '');
|
|
}
|
|
|
|
/**
|
|
* newRandomId returns a random string of 32 hex digits (16 bytes).
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
function newRandomId() {
|
|
let a = new Uint8Array(16);
|
|
crypto.getRandomValues(a);
|
|
return toHex(a);
|
|
}
|
|
|
|
let localIdCounter = 0;
|
|
|
|
/**
|
|
* newLocalId returns a string that is unique in this session.
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
function newLocalId() {
|
|
let id = `${localIdCounter}`
|
|
localIdCounter++;
|
|
return id;
|
|
}
|
|
|
|
/**
|
|
* @typedef {Object} user
|
|
* @property {string} username
|
|
* @property {Array<string>} permissions
|
|
* @property {Object<string,any>} data
|
|
* @property {Object<string,Object<string,boolean>>} streams
|
|
*/
|
|
|
|
/**
|
|
* ServerConnection encapsulates a websocket connection to the server and
|
|
* all the associated streams.
|
|
* @constructor
|
|
*/
|
|
function ServerConnection() {
|
|
/**
|
|
* The id of this connection.
|
|
*
|
|
* @type {string}
|
|
* @const
|
|
*/
|
|
this.id = newRandomId();
|
|
/**
|
|
* The group that we have joined, or null if we haven't joined yet.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.group = null;
|
|
/**
|
|
* The username we joined as.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.username = null;
|
|
/**
|
|
* The set of users in this group, including ourself.
|
|
*
|
|
* @type {Object<string,user>}
|
|
*/
|
|
this.users = {};
|
|
/**
|
|
* The underlying websocket.
|
|
*
|
|
* @type {WebSocket}
|
|
*/
|
|
this.socket = null;
|
|
/**
|
|
* The negotiated protocol version.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.version = null;
|
|
/**
|
|
* The set of all up streams, indexed by their id.
|
|
*
|
|
* @type {Object<string,Stream>}
|
|
*/
|
|
this.up = {};
|
|
/**
|
|
* The set of all down streams, indexed by their id.
|
|
*
|
|
* @type {Object<string,Stream>}
|
|
*/
|
|
this.down = {};
|
|
/**
|
|
* The ICE configuration used by all associated streams.
|
|
*
|
|
* @type {RTCConfiguration}
|
|
*/
|
|
this.rtcConfiguration = null;
|
|
/**
|
|
* The permissions granted to this connection.
|
|
*
|
|
* @type {Array<string>}
|
|
*/
|
|
this.permissions = [];
|
|
/**
|
|
* userdata is a convenient place to attach data to a ServerConnection.
|
|
* It is not used by the library.
|
|
*
|
|
* @type {Object<unknown,unknown>}
|
|
*/
|
|
this.userdata = {};
|
|
/**
|
|
* The time at which we last received a message from the server.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
this.lastServerMessage = null;
|
|
/**
|
|
* The interval handler which checks for liveness.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
this.pingHandler = null;
|
|
|
|
/* Callbacks */
|
|
|
|
/**
|
|
* onconnected is called when the connection has been established
|
|
*
|
|
* @type{(this: ServerConnection) => void}
|
|
*/
|
|
this.onconnected = null;
|
|
/**
|
|
* onerror is called whenever a fatal error occurs. The stream will
|
|
* then be closed, and onclose called normally.
|
|
*
|
|
* @type{(this: ServerConnection, error: unknown) => void}
|
|
*/
|
|
this.onerror = null;
|
|
/**
|
|
* onclose is called when the connection is closed
|
|
*
|
|
* @type{(this: ServerConnection, code: number, reason: string) => void}
|
|
*/
|
|
this.onclose = null;
|
|
/**
|
|
* onpeerconnection is called before we establish a new peer connection.
|
|
* It may either return null, or a new RTCConfiguration that overrides
|
|
* the value obtained from the server.
|
|
*
|
|
* @type{(this: ServerConnection) => RTCConfiguration}
|
|
*/
|
|
this.onpeerconnection = null;
|
|
/**
|
|
* onuser is called whenever a user in the group changes. The users
|
|
* array has already been updated.
|
|
*
|
|
* @type{(this: ServerConnection, id: string, kind: string) => void}
|
|
*/
|
|
this.onuser = null;
|
|
/**
|
|
* onjoined is called whenever we join or leave a group or whenever the
|
|
* permissions we have in a group change.
|
|
*
|
|
* kind is one of 'join', 'fail', 'change' or 'leave'.
|
|
*
|
|
* @type{(this: ServerConnection, kind: string, group: string, permissions: Array<string>, status: Object<string,any>, data: Object<string,any>, error: string, message: string) => void}
|
|
*/
|
|
this.onjoined = null;
|
|
/**
|
|
* ondownstream is called whenever a new down stream is added. It
|
|
* should set up the stream's callbacks; actually setting up the UI
|
|
* should be done in the stream's ondowntrack callback.
|
|
*
|
|
* @type{(this: ServerConnection, stream: Stream) => void}
|
|
*/
|
|
this.ondownstream = null;
|
|
/**
|
|
* onchat is called whenever a new chat message is received.
|
|
*
|
|
* @type {(this: ServerConnection, id: string, source: string, dest: string, username: string, time: Date, privileged: boolean, history: boolean, kind: string, message: string) => void}
|
|
*/
|
|
this.onchat = null;
|
|
/**
|
|
* onusermessage is called when an application-specific message is
|
|
* received. Id is null when the message originated at the server,
|
|
* a user-id otherwise.
|
|
*
|
|
* 'kind' is typically one of 'error', 'warning', 'info' or 'mute'. If
|
|
* 'id' is non-null, 'privileged' indicates whether the message was
|
|
* sent by an operator.
|
|
*
|
|
* @type {(this: ServerConnection, id: string, dest: string, username: string, time: Date, privileged: boolean, kind: string, error: string, message: unknown) => void}
|
|
*/
|
|
this.onusermessage = null;
|
|
/**
|
|
* The set of files currently being transferred.
|
|
*
|
|
* @type {Object<string,TransferredFile>}
|
|
*/
|
|
this.transferredFiles = {};
|
|
/**
|
|
* onfiletransfer is called whenever a peer offers a file transfer.
|
|
*
|
|
* If the transfer is accepted, it should set up the file transfer
|
|
* callbacks and return immediately. It may also throw an exception
|
|
* in order to reject the file transfer.
|
|
*
|
|
* @type {(this: ServerConnection, f: TransferredFile) => void}
|
|
*/
|
|
this.onfiletransfer = null;
|
|
}
|
|
|
|
/**
|
|
* @typedef {Object} message
|
|
* @property {string} type
|
|
* @property {Array<string>} [version]
|
|
* @property {string} [kind]
|
|
* @property {string} [error]
|
|
* @property {string} [id]
|
|
* @property {string} [replace]
|
|
* @property {string} [source]
|
|
* @property {string} [dest]
|
|
* @property {string} [username]
|
|
* @property {string} [password]
|
|
* @property {string} [token]
|
|
* @property {boolean} [privileged]
|
|
* @property {Array<string>} [permissions]
|
|
* @property {Object<string,any>} [status]
|
|
* @property {Object<string,any>} [data]
|
|
* @property {string} [group]
|
|
* @property {unknown} [value]
|
|
* @property {boolean} [noecho]
|
|
* @property {string|number} [time]
|
|
* @property {string} [sdp]
|
|
* @property {RTCIceCandidate} [candidate]
|
|
* @property {string} [label]
|
|
* @property {Object<string,Array<string>>|Array<string>} [request]
|
|
* @property {Object<string,any>} [rtcConfiguration]
|
|
*/
|
|
|
|
/**
|
|
* close forcibly closes a server connection. The onclose callback will
|
|
* be called when the connection is effectively closed.
|
|
*/
|
|
ServerConnection.prototype.close = function() {
|
|
this.socket && this.socket.close(1000, 'Close requested by client');
|
|
this.socket = null;
|
|
};
|
|
|
|
/**
|
|
* error forcibly closes a server connection and invokes the onerror
|
|
* callback. The onclose callback will be invoked when the connection
|
|
* is effectively closed.
|
|
*
|
|
* @param {any} e
|
|
*/
|
|
ServerConnection.prototype.error = function(e) {
|
|
if(this.onerror)
|
|
this.onerror.call(this, e);
|
|
this.close();
|
|
};
|
|
|
|
/**
|
|
* send sends a message to the server.
|
|
* @param {message} m - the message to send.
|
|
*/
|
|
ServerConnection.prototype.send = function(m) {
|
|
if(!this.socket || this.socket.readyState !== this.socket.OPEN) {
|
|
// send on a closed socket doesn't throw
|
|
throw(new Error('Connection is not open'));
|
|
}
|
|
return this.socket.send(JSON.stringify(m));
|
|
};
|
|
|
|
/**
|
|
* connect connects to the server.
|
|
*
|
|
* @param {string} url - The URL to connect to.
|
|
* @function
|
|
*/
|
|
ServerConnection.prototype.connect = function(url) {
|
|
let sc = this;
|
|
if(sc.socket)
|
|
throw new Error("Attempting to connect stale connection");
|
|
|
|
sc.socket = new WebSocket(url);
|
|
|
|
this.pingHandler = setInterval(e => {
|
|
if(!sc.lastServerMessage) {
|
|
sc.error(new Error('Timeout'));
|
|
return;
|
|
}
|
|
let d = new Date().valueOf() - sc.lastServerMessage;
|
|
if(d > 65000) {
|
|
sc.error(new Error('Timeout'));
|
|
return;
|
|
}
|
|
if(sc.version && d >= 15000)
|
|
sc.send({type: 'ping'});
|
|
}, 10000);
|
|
|
|
this.socket.onerror = function(e) {
|
|
if(sc.onerror)
|
|
sc.onerror.call(sc, new Error('Socket error: ' + e));
|
|
};
|
|
this.socket.onopen = function(e) {
|
|
try {
|
|
sc.send({
|
|
type: 'handshake',
|
|
version: ['2'],
|
|
id: sc.id,
|
|
});
|
|
} catch(e) {
|
|
sc.error(e);
|
|
return;
|
|
}
|
|
};
|
|
this.socket.onclose = function(e) {
|
|
sc.permissions = [];
|
|
for(let id in sc.up) {
|
|
let c = sc.up[id];
|
|
c.close();
|
|
}
|
|
for(let id in sc.down) {
|
|
let c = sc.down[id];
|
|
c.close();
|
|
}
|
|
for(let id in sc.users) {
|
|
delete(sc.users[id]);
|
|
if(sc.onuser)
|
|
sc.onuser.call(sc, id, 'delete');
|
|
}
|
|
if(sc.group && sc.onjoined)
|
|
sc.onjoined.call(sc, 'leave', sc.group, [], {}, {}, '', '');
|
|
sc.group = null;
|
|
sc.username = null;
|
|
if(sc.pingHandler) {
|
|
clearInterval(sc.pingHandler);
|
|
sc.pingHandler = null;
|
|
}
|
|
if(sc.onclose)
|
|
sc.onclose.call(sc, e.code, e.reason);
|
|
};
|
|
this.socket.onmessage = function(e) {
|
|
let m;
|
|
try {
|
|
m = JSON.parse(e.data);
|
|
} catch(e) {
|
|
sc.error(e);
|
|
return;
|
|
}
|
|
if(m.type !== 'handshake' && !sc.version) {
|
|
sc.error(new Error("Server didn't send handshake"));
|
|
return;
|
|
}
|
|
sc.lastServerMessage = new Date().valueOf();
|
|
switch(m.type) {
|
|
case 'handshake': {
|
|
if((m.version instanceof Array) && m.version.includes('2')) {
|
|
sc.version = '2';
|
|
} else {
|
|
sc.version = null;
|
|
sc.error(new Error(`Unknown protocol version ${m.version}`));
|
|
return;
|
|
}
|
|
if(sc.onconnected)
|
|
sc.onconnected.call(sc);
|
|
break;
|
|
}
|
|
case 'offer':
|
|
sc.gotOffer(m.id, m.label, m.source, m.username,
|
|
m.sdp, m.replace);
|
|
break;
|
|
case 'answer':
|
|
sc.gotAnswer(m.id, m.sdp);
|
|
break;
|
|
case 'renegotiate':
|
|
sc.gotRenegotiate(m.id);
|
|
break;
|
|
case 'close':
|
|
sc.gotClose(m.id);
|
|
break;
|
|
case 'abort':
|
|
sc.gotAbort(m.id);
|
|
break;
|
|
case 'ice':
|
|
sc.gotRemoteIce(m.id, m.candidate);
|
|
break;
|
|
case 'joined':
|
|
if(m.kind === 'leave' || m.kind === 'fail') {
|
|
for(let id in sc.users) {
|
|
delete(sc.users[id]);
|
|
if(sc.onuser)
|
|
sc.onuser.call(sc, id, 'delete');
|
|
}
|
|
sc.username = null;
|
|
sc.permissions = [];
|
|
sc.rtcConfiguration = null;
|
|
} else if(m.kind === 'join' || m.kind == 'change') {
|
|
if(m.kind === 'join' && sc.group) {
|
|
throw new Error('Joined multiple groups');
|
|
} else if(m.kind === 'change' && m.group != sc.group) {
|
|
console.warn('join(change) for inconsistent group');
|
|
break;
|
|
}
|
|
sc.group = m.group;
|
|
sc.username = m.username;
|
|
sc.permissions = m.permissions || [];
|
|
sc.rtcConfiguration = m.rtcConfiguration || null;
|
|
}
|
|
if(sc.onjoined)
|
|
sc.onjoined.call(sc, m.kind, m.group,
|
|
m.permissions || [],
|
|
m.status, m.data,
|
|
m.error || null, m.value || null);
|
|
break;
|
|
case 'user':
|
|
switch(m.kind) {
|
|
case 'add':
|
|
if(m.id in sc.users)
|
|
console.warn(`Duplicate user ${m.id} ${m.username}`);
|
|
sc.users[m.id] = {
|
|
username: m.username,
|
|
permissions: m.permissions || [],
|
|
data: m.data || {},
|
|
streams: {},
|
|
};
|
|
break;
|
|
case 'change':
|
|
if(!(m.id in sc.users)) {
|
|
console.warn(`Unknown user ${m.id} ${m.username}`);
|
|
sc.users[m.id] = {
|
|
username: m.username,
|
|
permissions: m.permissions || [],
|
|
data: m.data || {},
|
|
streams: {},
|
|
};
|
|
} else {
|
|
sc.users[m.id].username = m.username;
|
|
sc.users[m.id].permissions = m.permissions || [];
|
|
sc.users[m.id].data = m.data || {};
|
|
}
|
|
break;
|
|
case 'delete':
|
|
if(!(m.id in sc.users))
|
|
console.warn(`Unknown user ${m.id} ${m.username}`);
|
|
for(let t in sc.transferredFiles) {
|
|
let f = sc.transferredFiles[t];
|
|
if(f.userid === m.id)
|
|
f.fail('user has gone away');
|
|
}
|
|
delete(sc.users[m.id]);
|
|
break;
|
|
default:
|
|
console.warn(`Unknown user action ${m.kind}`);
|
|
return;
|
|
}
|
|
if(sc.onuser)
|
|
sc.onuser.call(sc, m.id, m.kind);
|
|
break;
|
|
case 'chat':
|
|
case 'chathistory':
|
|
if(sc.onchat)
|
|
sc.onchat.call(
|
|
sc, m.id, m.source, m.dest, m.username, parseTime(m.time),
|
|
m.privileged, m.type === 'chathistory', m.kind,
|
|
'' + m.value,
|
|
);
|
|
break;
|
|
case 'usermessage':
|
|
if(m.kind === 'filetransfer')
|
|
sc.fileTransfer(m.source, m.username, m.value);
|
|
else if(sc.onusermessage)
|
|
sc.onusermessage.call(
|
|
sc, m.source, m.dest, m.username, parseTime(m.time),
|
|
m.privileged, m.kind, m.error, m.value,
|
|
);
|
|
break;
|
|
case 'ping':
|
|
sc.send({
|
|
type: 'pong',
|
|
});
|
|
break;
|
|
case 'pong':
|
|
/* nothing */
|
|
break;
|
|
default:
|
|
console.warn('Unexpected server message', m.type);
|
|
return;
|
|
}
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Protocol version 1 uses integers for dates, later versions use dates in
|
|
* ISO 8601 format. This function takes a date in either format and
|
|
* returns a Date object.
|
|
*
|
|
* @param {string|number} value
|
|
* @returns {Date}
|
|
*/
|
|
function parseTime(value) {
|
|
if(!value)
|
|
return null;
|
|
try {
|
|
return new Date(value);
|
|
} catch(e) {
|
|
console.warn(`Couldn't parse ${value}:`, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* join requests to join a group. The onjoined callback will be called
|
|
* when we've effectively joined.
|
|
*
|
|
* @param {string} group - The name of the group to join.
|
|
* @param {string} username - the username to join as.
|
|
* @param {string|Object} credentials - password or authServer.
|
|
* @param {Object<string,any>} [data] - the initial associated data.
|
|
*/
|
|
ServerConnection.prototype.join = async function(group, username, credentials, data) {
|
|
let m = {
|
|
type: 'join',
|
|
kind: 'join',
|
|
group: group,
|
|
};
|
|
if(typeof username !== 'undefined' && username !== null)
|
|
m.username = username;
|
|
|
|
if((typeof credentials) === 'string') {
|
|
m.password = credentials;
|
|
} else {
|
|
switch(credentials.type) {
|
|
case 'password':
|
|
m.password = credentials.password;
|
|
break;
|
|
case 'token':
|
|
m.token = credentials.token;
|
|
break;
|
|
case 'authServer':
|
|
let r = await fetch(credentials.authServer, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify({
|
|
location: credentials.location,
|
|
username: username,
|
|
password: credentials.password,
|
|
}),
|
|
});
|
|
if(!r.ok)
|
|
throw new Error(
|
|
`The authorisation server said ${r.status} ${r.statusText}`,
|
|
);
|
|
if(r.status === 204) {
|
|
// no data, fallback to password auth
|
|
m.password = credentials.password;
|
|
break;
|
|
}
|
|
let ctype = r.headers.get("Content-Type");
|
|
if(!ctype)
|
|
throw new Error(
|
|
"The authorisation server didn't return a content type",
|
|
);
|
|
let semi = ctype.indexOf(";");
|
|
if(semi >= 0)
|
|
ctype = ctype.slice(0, semi);
|
|
ctype = ctype.trim();
|
|
switch(ctype.toLowerCase()) {
|
|
case 'application/jwt':
|
|
let data = await r.text();
|
|
if(!data)
|
|
throw new Error(
|
|
"The authorisation server returned empty token",
|
|
);
|
|
m.token = data;
|
|
break;
|
|
default:
|
|
throw new Error(`The authorisation server returned ${ctype}`);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error(`Unknown credentials type ${credentials.type}`);
|
|
}
|
|
}
|
|
|
|
if(data)
|
|
m.data = data;
|
|
|
|
this.send(m);
|
|
};
|
|
|
|
/**
|
|
* leave leaves a group. The onjoined callback will be called when we've
|
|
* effectively left.
|
|
*
|
|
* @param {string} group - The name of the group to join.
|
|
*/
|
|
ServerConnection.prototype.leave = function(group) {
|
|
this.send({
|
|
type: 'join',
|
|
kind: 'leave',
|
|
group: group,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* request sets the list of requested tracks
|
|
*
|
|
* @param {Object<string,Array<string>>} what
|
|
* - A dictionary that maps labels to a sequence of 'audio', 'video'
|
|
* or 'video-low. An entry with an empty label '' provides the default.
|
|
*/
|
|
ServerConnection.prototype.request = function(what) {
|
|
this.send({
|
|
type: 'request',
|
|
request: what,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* findByLocalId finds an active connection with the given localId.
|
|
* It returns null if none was find.
|
|
*
|
|
* @param {string} localId
|
|
* @returns {Stream}
|
|
*/
|
|
ServerConnection.prototype.findByLocalId = function(localId) {
|
|
if(!localId)
|
|
return null;
|
|
|
|
let sc = this;
|
|
|
|
for(let id in sc.up) {
|
|
let s = sc.up[id];
|
|
if(s.localId === localId)
|
|
return s;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* getRTCConfiguration returns the RTCConfiguration that should be used
|
|
* with this peer connection. This usually comes from the server, but may
|
|
* be overridden by the onpeerconnection callback.
|
|
*
|
|
* @returns {RTCConfiguration}
|
|
*/
|
|
ServerConnection.prototype.getRTCConfiguration = function() {
|
|
if(this.onpeerconnection) {
|
|
let conf = this.onpeerconnection.call(this);
|
|
if(conf !== null)
|
|
return conf;
|
|
}
|
|
return this.rtcConfiguration;
|
|
}
|
|
|
|
/**
|
|
* newUpStream requests the creation of a new up stream.
|
|
*
|
|
* @param {string} [localId]
|
|
* - The local id of the stream to create. If a stream already exists with
|
|
* the same local id, it is replaced with the new stream.
|
|
* @returns {Stream}
|
|
*/
|
|
ServerConnection.prototype.newUpStream = function(localId) {
|
|
let sc = this;
|
|
let id = newRandomId();
|
|
if(sc.up[id])
|
|
throw new Error('Eek!');
|
|
|
|
if(typeof RTCPeerConnection === 'undefined')
|
|
throw new Error("This browser doesn't support WebRTC");
|
|
|
|
|
|
let pc = new RTCPeerConnection(sc.getRTCConfiguration());
|
|
if(!pc)
|
|
throw new Error("Couldn't create peer connection");
|
|
|
|
let oldId = null;
|
|
if(localId) {
|
|
let old = sc.findByLocalId(localId);
|
|
oldId = old && old.id;
|
|
if(old)
|
|
old.close(true);
|
|
}
|
|
|
|
let c = new Stream(this, id, localId || newLocalId(), pc, true);
|
|
if(oldId)
|
|
c.replace = oldId;
|
|
sc.up[id] = c;
|
|
|
|
pc.onnegotiationneeded = async e => {
|
|
await c.negotiate();
|
|
};
|
|
|
|
pc.onicecandidate = e => {
|
|
if(!e.candidate)
|
|
return;
|
|
c.gotLocalIce(e.candidate);
|
|
};
|
|
|
|
pc.oniceconnectionstatechange = e => {
|
|
if(c.onstatus)
|
|
c.onstatus.call(c, pc.iceConnectionState);
|
|
if(pc.iceConnectionState === 'failed')
|
|
c.restartIce();
|
|
};
|
|
|
|
pc.ontrack = console.error;
|
|
return c;
|
|
};
|
|
|
|
/**
|
|
* chat sends a chat message to the server. The server will normally echo
|
|
* the message back to the client.
|
|
*
|
|
* @param {string} kind
|
|
* - The kind of message, either '', 'me' or an application-specific type.
|
|
* @param {string} dest - The id to send the message to, empty for broadcast.
|
|
* @param {string} value - The text of the message.
|
|
*/
|
|
ServerConnection.prototype.chat = function(kind, dest, value) {
|
|
this.send({
|
|
type: 'chat',
|
|
source: this.id,
|
|
dest: dest,
|
|
username: this.username,
|
|
kind: kind,
|
|
value: value,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* userAction sends a request to act on a user.
|
|
*
|
|
* @param {string} kind - One of "op", "unop", "kick", "present", "unpresent".
|
|
* @param {string} dest - The id of the user to act upon.
|
|
* @param {any} [value] - An action-dependent parameter.
|
|
*/
|
|
ServerConnection.prototype.userAction = function(kind, dest, value) {
|
|
this.send({
|
|
type: 'useraction',
|
|
source: this.id,
|
|
dest: dest,
|
|
username: this.username,
|
|
kind: kind,
|
|
value: value,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* userMessage sends an application-specific message to a user.
|
|
* This is similar to a chat message, but is not saved in the chat history.
|
|
*
|
|
* @param {string} kind - The kind of application-specific message.
|
|
* @param {string} dest - The id to send the message to, empty for broadcast.
|
|
* @param {unknown} [value] - An optional parameter.
|
|
* @param {boolean} [noecho] - If set, don't echo back the message to the sender.
|
|
*/
|
|
ServerConnection.prototype.userMessage = function(kind, dest, value, noecho) {
|
|
this.send({
|
|
type: 'usermessage',
|
|
source: this.id,
|
|
dest: dest,
|
|
username: this.username,
|
|
kind: kind,
|
|
value: value,
|
|
noecho: noecho,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* groupAction sends a request to act on the current group.
|
|
*
|
|
* @param {string} kind
|
|
* @param {any} [data]
|
|
*/
|
|
ServerConnection.prototype.groupAction = function(kind, data) {
|
|
this.send({
|
|
type: 'groupaction',
|
|
source: this.id,
|
|
kind: kind,
|
|
username: this.username,
|
|
value: data,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* gotOffer is called when we receive an offer from the server. Don't call this.
|
|
*
|
|
* @param {string} id
|
|
* @param {string} label
|
|
* @param {string} source
|
|
* @param {string} username
|
|
* @param {string} sdp
|
|
* @param {string} replace
|
|
* @function
|
|
*/
|
|
ServerConnection.prototype.gotOffer = async function(id, label, source, username, sdp, replace) {
|
|
let sc = this;
|
|
|
|
if(sc.up[id]) {
|
|
console.error("Duplicate connection id");
|
|
sc.send({
|
|
type: 'abort',
|
|
id: id,
|
|
});
|
|
return;
|
|
}
|
|
|
|
let oldLocalId = null;
|
|
|
|
if(replace) {
|
|
let old = sc.down[replace];
|
|
if(old) {
|
|
oldLocalId = old.localId;
|
|
old.close(true);
|
|
} else
|
|
console.error("Replacing unknown stream");
|
|
}
|
|
|
|
let c = sc.down[id];
|
|
if(c && oldLocalId)
|
|
console.error("Replacing duplicate stream");
|
|
|
|
if(!c) {
|
|
let pc;
|
|
try {
|
|
pc = new RTCPeerConnection(sc.getRTCConfiguration());
|
|
} catch(e) {
|
|
console.error(e);
|
|
sc.send({
|
|
type: 'abort',
|
|
id: id,
|
|
});
|
|
return;
|
|
}
|
|
c = new Stream(this, id, oldLocalId || newLocalId(), pc, false);
|
|
c.label = label;
|
|
sc.down[id] = c;
|
|
|
|
c.pc.onicecandidate = function(e) {
|
|
if(!e.candidate)
|
|
return;
|
|
c.gotLocalIce(e.candidate);
|
|
};
|
|
|
|
pc.oniceconnectionstatechange = e => {
|
|
if(c.onstatus)
|
|
c.onstatus.call(c, pc.iceConnectionState);
|
|
if(pc.iceConnectionState === 'failed') {
|
|
sc.send({
|
|
type: 'renegotiate',
|
|
id: id,
|
|
});
|
|
}
|
|
};
|
|
|
|
c.pc.ontrack = function(e) {
|
|
if(e.streams.length < 1) {
|
|
console.error("Got track with no stream");
|
|
return;
|
|
}
|
|
c.stream = e.streams[0];
|
|
let changed = recomputeUserStreams(sc, source);
|
|
if(c.ondowntrack) {
|
|
c.ondowntrack.call(
|
|
c, e.track, e.transceiver, e.streams[0],
|
|
);
|
|
}
|
|
if(changed && sc.onuser)
|
|
sc.onuser.call(sc, source, "change");
|
|
};
|
|
}
|
|
|
|
c.source = source;
|
|
c.username = username;
|
|
|
|
if(sc.ondownstream)
|
|
sc.ondownstream.call(sc, c);
|
|
|
|
try {
|
|
await c.pc.setRemoteDescription({
|
|
type: 'offer',
|
|
sdp: sdp,
|
|
});
|
|
|
|
await c.flushRemoteIceCandidates();
|
|
|
|
let answer = await c.pc.createAnswer();
|
|
if(!answer)
|
|
throw new Error("Didn't create answer");
|
|
await c.pc.setLocalDescription(answer);
|
|
this.send({
|
|
type: 'answer',
|
|
id: id,
|
|
sdp: c.pc.localDescription.sdp,
|
|
});
|
|
} catch(e) {
|
|
try {
|
|
if(c.onerror)
|
|
c.onerror.call(c, e);
|
|
} finally {
|
|
c.abort();
|
|
}
|
|
return;
|
|
}
|
|
|
|
c.localDescriptionSent = true;
|
|
c.flushLocalIceCandidates();
|
|
if(c.onnegotiationcompleted)
|
|
c.onnegotiationcompleted.call(c);
|
|
};
|
|
|
|
/**
|
|
* gotAnswer is called when we receive an answer from the server. Don't
|
|
* call this.
|
|
*
|
|
* @param {string} id
|
|
* @param {string} sdp
|
|
* @function
|
|
*/
|
|
ServerConnection.prototype.gotAnswer = async function(id, sdp) {
|
|
let c = this.up[id];
|
|
if(!c)
|
|
throw new Error('unknown up stream');
|
|
try {
|
|
await c.pc.setRemoteDescription({
|
|
type: 'answer',
|
|
sdp: sdp,
|
|
});
|
|
} catch(e) {
|
|
try {
|
|
if(c.onerror)
|
|
c.onerror.call(c, e);
|
|
} finally {
|
|
c.close();
|
|
}
|
|
return;
|
|
}
|
|
await c.flushRemoteIceCandidates();
|
|
if(c.onnegotiationcompleted)
|
|
c.onnegotiationcompleted.call(c);
|
|
};
|
|
|
|
/**
|
|
* gotRenegotiate is called when we receive a renegotiation request from
|
|
* the server. Don't call this.
|
|
*
|
|
* @param {string} id
|
|
* @function
|
|
*/
|
|
ServerConnection.prototype.gotRenegotiate = function(id) {
|
|
let c = this.up[id];
|
|
if(!c)
|
|
throw new Error('unknown up stream');
|
|
c.restartIce();
|
|
};
|
|
|
|
/**
|
|
* gotClose is called when we receive a close request from the server.
|
|
* Don't call this.
|
|
*
|
|
* @param {string} id
|
|
*/
|
|
ServerConnection.prototype.gotClose = function(id) {
|
|
let c = this.down[id];
|
|
if(!c) {
|
|
console.warn('unknown down stream', id);
|
|
return;
|
|
}
|
|
c.close();
|
|
};
|
|
|
|
/**
|
|
* gotAbort is called when we receive an abort message from the server.
|
|
* Don't call this.
|
|
*
|
|
* @param {string} id
|
|
*/
|
|
ServerConnection.prototype.gotAbort = function(id) {
|
|
let c = this.up[id];
|
|
if(!c)
|
|
throw new Error('unknown up stream');
|
|
c.close();
|
|
};
|
|
|
|
/**
|
|
* gotRemoteIce is called when we receive an ICE candidate from the server.
|
|
* Don't call this.
|
|
*
|
|
* @param {string} id
|
|
* @param {RTCIceCandidate} candidate
|
|
* @function
|
|
*/
|
|
ServerConnection.prototype.gotRemoteIce = async function(id, candidate) {
|
|
let c = this.up[id];
|
|
if(!c)
|
|
c = this.down[id];
|
|
if(!c)
|
|
throw new Error('unknown stream');
|
|
if(c.pc.remoteDescription)
|
|
await c.pc.addIceCandidate(candidate).catch(console.warn);
|
|
else
|
|
c.remoteIceCandidates.push(candidate);
|
|
};
|
|
|
|
/**
|
|
* Stream encapsulates a MediaStream, a set of tracks.
|
|
*
|
|
* A stream is said to go "up" if it is from the client to the server, and
|
|
* "down" otherwise.
|
|
*
|
|
* @param {ServerConnection} sc
|
|
* @param {string} id
|
|
* @param {string} localId
|
|
* @param {RTCPeerConnection} pc
|
|
*
|
|
* @constructor
|
|
*/
|
|
function Stream(sc, id, localId, pc, up) {
|
|
/**
|
|
* The associated ServerConnection.
|
|
*
|
|
* @type {ServerConnection}
|
|
* @const
|
|
*/
|
|
this.sc = sc;
|
|
/**
|
|
* The id of this stream.
|
|
*
|
|
* @type {string}
|
|
* @const
|
|
*/
|
|
this.id = id;
|
|
/**
|
|
* The local id of this stream.
|
|
*
|
|
* @type {string}
|
|
* @const
|
|
*/
|
|
this.localId = localId;
|
|
/**
|
|
* Indicates whether the stream is in the client->server direction.
|
|
*
|
|
* @type {boolean}
|
|
* @const
|
|
*/
|
|
this.up = up;
|
|
/**
|
|
* For down streams, the id of the client that created the stream.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.source = null;
|
|
/**
|
|
* For down streams, the username of the client who created the stream.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.username = null;
|
|
/**
|
|
* The associated RTCPeerConnection. This is null before the stream
|
|
* is connected, and may change over time.
|
|
*
|
|
* @type {RTCPeerConnection}
|
|
*/
|
|
this.pc = pc;
|
|
/**
|
|
* The associated MediaStream. This is null before the stream is
|
|
* connected, and may change over time.
|
|
*
|
|
* @type {MediaStream}
|
|
*/
|
|
this.stream = null;
|
|
/**
|
|
* The label assigned by the originator to this stream.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.label = null;
|
|
/**
|
|
* The id of the stream that we are currently replacing.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.replace = null;
|
|
/**
|
|
* Indicates whether we have already sent a local description.
|
|
*
|
|
* @type {boolean}
|
|
*/
|
|
this.localDescriptionSent = false;
|
|
/**
|
|
* Buffered local ICE candidates. This will be flushed by
|
|
* flushLocalIceCandidates after we send a local description.
|
|
*
|
|
* @type {RTCIceCandidate[]}
|
|
*/
|
|
this.localIceCandidates = [];
|
|
/**
|
|
* Buffered remote ICE candidates. This will be flushed by
|
|
* flushRemoteIceCandidates when we get a remote SDP description.
|
|
*
|
|
* @type {RTCIceCandidate[]}
|
|
*/
|
|
this.remoteIceCandidates = [];
|
|
/**
|
|
* The statistics last computed by the stats handler. This is
|
|
* a dictionary indexed by track id, with each value a dictionary of
|
|
* statistics.
|
|
*
|
|
* @type {Object<string,unknown>}
|
|
*/
|
|
this.stats = {};
|
|
/**
|
|
* The id of the periodic handler that computes statistics, as
|
|
* returned by setInterval.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
this.statsHandler = null;
|
|
/**
|
|
* userdata is a convenient place to attach data to a Stream.
|
|
* It is not used by the library.
|
|
*
|
|
* @type{Object<unknown,unknown>}
|
|
*/
|
|
this.userdata = {};
|
|
|
|
/* Callbacks */
|
|
|
|
/**
|
|
* onclose is called when the stream is closed. Replace will be true
|
|
* if the stream is being replaced by another one with the same id.
|
|
*
|
|
* @type{(this: Stream, replace: boolean) => void}
|
|
*/
|
|
this.onclose = null;
|
|
/**
|
|
* onerror is called whenever a fatal error occurs. The stream will
|
|
* then be closed, and onclose called normally.
|
|
*
|
|
* @type{(this: Stream, error: unknown) => void}
|
|
*/
|
|
this.onerror = null;
|
|
/**
|
|
* onnegotiationcompleted is called whenever negotiation or
|
|
* renegotiation has completed.
|
|
*
|
|
* @type{(this: Stream) => void}
|
|
*/
|
|
this.onnegotiationcompleted = null;
|
|
/**
|
|
* ondowntrack is called whenever a new track is added to a stream.
|
|
* If the stream parameter differs from its previous value, then it
|
|
* indicates that the old stream has been discarded.
|
|
*
|
|
* @type{(this: Stream, track: MediaStreamTrack, transceiver: RTCRtpTransceiver, stream: MediaStream) => void}
|
|
*/
|
|
this.ondowntrack = null;
|
|
/**
|
|
* onstatus is called whenever the status of the stream changes.
|
|
*
|
|
* @type{(this: Stream, status: string) => void}
|
|
*/
|
|
this.onstatus = null;
|
|
/**
|
|
* onstats is called when we have new statistics about the connection
|
|
*
|
|
* @type{(this: Stream, stats: Object<unknown,unknown>) => void}
|
|
*/
|
|
this.onstats = null;
|
|
}
|
|
|
|
/**
|
|
* setStream sets the stream of an upwards connection.
|
|
*
|
|
* @param {MediaStream} stream
|
|
*/
|
|
Stream.prototype.setStream = function(stream) {
|
|
let c = this;
|
|
c.stream = stream;
|
|
let changed = recomputeUserStreams(c.sc, c.sc.id);
|
|
if(changed && c.sc.onuser)
|
|
c.sc.onuser.call(c.sc, c.sc.id, "change");
|
|
}
|
|
|
|
/**
|
|
* close closes a stream.
|
|
*
|
|
* For streams in the up direction, this may be called at any time. For
|
|
* streams in the down direction, this will be called automatically when
|
|
* the server signals that it is closing a stream.
|
|
*
|
|
* @param {boolean} [replace]
|
|
* - true if the stream is being replaced by another one with the same id
|
|
*/
|
|
Stream.prototype.close = function(replace) {
|
|
let c = this;
|
|
|
|
if(!c.sc) {
|
|
console.warn('Closing closed stream');
|
|
return;
|
|
}
|
|
|
|
if(c.statsHandler) {
|
|
clearInterval(c.statsHandler);
|
|
c.statsHandler = null;
|
|
}
|
|
|
|
c.pc.close();
|
|
|
|
if(c.up && !replace && c.localDescriptionSent) {
|
|
try {
|
|
c.sc.send({
|
|
type: 'close',
|
|
id: c.id,
|
|
});
|
|
} catch(e) {
|
|
}
|
|
}
|
|
|
|
let userid;
|
|
if(c.up) {
|
|
userid = c.sc.id;
|
|
if(c.sc.up[c.id] === c)
|
|
delete(c.sc.up[c.id]);
|
|
else
|
|
console.warn('Closing unknown stream');
|
|
} else {
|
|
userid = c.source;
|
|
if(c.sc.down[c.id] === c)
|
|
delete(c.sc.down[c.id]);
|
|
else
|
|
console.warn('Closing unknown stream');
|
|
}
|
|
let changed = recomputeUserStreams(c.sc, userid);
|
|
if(changed && c.sc.onuser)
|
|
c.sc.onuser.call(c.sc, userid, "change");
|
|
|
|
if(c.onclose)
|
|
c.onclose.call(c, replace);
|
|
|
|
c.sc = null;
|
|
};
|
|
|
|
/**
|
|
* recomputeUserStreams recomputes the user.streams array for a given user.
|
|
* It returns true if anything changed.
|
|
*
|
|
* @param {ServerConnection} sc
|
|
* @param {string} id
|
|
* @returns {boolean}
|
|
*/
|
|
function recomputeUserStreams(sc, id) {
|
|
let user = sc.users[id];
|
|
if(!user) {
|
|
console.warn("recomputing streams for unknown user");
|
|
return false;
|
|
}
|
|
|
|
let streams = id === sc.id ? sc.up : sc.down;
|
|
let old = user.streams;
|
|
user.streams = {};
|
|
for(id in streams) {
|
|
let c = streams[id];
|
|
if(!c.stream)
|
|
continue;
|
|
if(!user.streams[c.label])
|
|
user.streams[c.label] = {};
|
|
c.stream.getTracks().forEach(t => {
|
|
user.streams[c.label][t.kind] = true;
|
|
});
|
|
}
|
|
|
|
return JSON.stringify(old) != JSON.stringify(user.streams);
|
|
}
|
|
|
|
/**
|
|
* abort requests that the server close a down stream.
|
|
*/
|
|
Stream.prototype.abort = function() {
|
|
let c = this;
|
|
if(c.up)
|
|
throw new Error("Abort called on an up stream");
|
|
c.sc.send({
|
|
type: 'abort',
|
|
id: c.id,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* gotLocalIce is Called when we get a local ICE candidate. Don't call this.
|
|
*
|
|
* @param {RTCIceCandidate} candidate
|
|
* @function
|
|
*/
|
|
Stream.prototype.gotLocalIce = function(candidate) {
|
|
let c = this;
|
|
if(c.localDescriptionSent)
|
|
c.sc.send({type: 'ice',
|
|
id: c.id,
|
|
candidate: candidate,
|
|
});
|
|
else
|
|
c.localIceCandidates.push(candidate);
|
|
};
|
|
|
|
/**
|
|
* flushLocalIceCandidates flushes any buffered local ICE candidates.
|
|
* It is called when we send an offer.
|
|
*
|
|
* @function
|
|
*/
|
|
Stream.prototype.flushLocalIceCandidates = function () {
|
|
let c = this;
|
|
let candidates = c.localIceCandidates;
|
|
c.localIceCandidates = [];
|
|
candidates.forEach(candidate => {
|
|
try {
|
|
c.sc.send({type: 'ice',
|
|
id: c.id,
|
|
candidate: candidate,
|
|
});
|
|
} catch(e) {
|
|
console.warn(e);
|
|
}
|
|
});
|
|
c.localIceCandidates = [];
|
|
};
|
|
|
|
/**
|
|
* flushRemoteIceCandidates flushes any buffered remote ICE candidates. It is
|
|
* called automatically when we get a remote description.
|
|
*
|
|
* @function
|
|
*/
|
|
Stream.prototype.flushRemoteIceCandidates = async function () {
|
|
let c = this;
|
|
let candidates = c.remoteIceCandidates;
|
|
c.remoteIceCandidates = [];
|
|
/** @type {Array.<Promise<void>>} */
|
|
let promises = [];
|
|
candidates.forEach(candidate => {
|
|
promises.push(c.pc.addIceCandidate(candidate).catch(console.warn));
|
|
});
|
|
return await Promise.all(promises);
|
|
};
|
|
|
|
/**
|
|
* negotiate negotiates or renegotiates an up stream. It is called
|
|
* automatically when required. If the client requires renegotiation, it
|
|
* is probably better to call restartIce which will cause negotiate to be
|
|
* called asynchronously.
|
|
*
|
|
* @function
|
|
* @param {boolean} [restartIce] - Whether to restart ICE.
|
|
*/
|
|
Stream.prototype.negotiate = async function (restartIce) {
|
|
let c = this;
|
|
if(!c.up)
|
|
throw new Error('not an up stream');
|
|
|
|
let options = {};
|
|
if(restartIce)
|
|
options = {iceRestart: true};
|
|
let offer = await c.pc.createOffer(options);
|
|
if(!offer)
|
|
throw(new Error("Didn't create offer"));
|
|
await c.pc.setLocalDescription(offer);
|
|
|
|
c.sc.send({
|
|
type: 'offer',
|
|
source: c.sc.id,
|
|
username: c.sc.username,
|
|
kind: this.localDescriptionSent ? 'renegotiate' : '',
|
|
id: c.id,
|
|
replace: this.replace,
|
|
label: c.label,
|
|
sdp: c.pc.localDescription.sdp,
|
|
});
|
|
this.localDescriptionSent = true;
|
|
this.replace = null;
|
|
c.flushLocalIceCandidates();
|
|
};
|
|
|
|
/**
|
|
* restartIce causes an ICE restart on a stream. For up streams, it is
|
|
* called automatically when ICE signals that the connection has failed,
|
|
* but may also be called by the application. For down streams, it
|
|
* requests that the server perform an ICE restart. In either case,
|
|
* it returns immediately, negotiation will happen asynchronously.
|
|
*/
|
|
|
|
Stream.prototype.restartIce = function () {
|
|
let c = this;
|
|
if(!c.up) {
|
|
c.sc.send({
|
|
type: 'renegotiate',
|
|
id: c.id,
|
|
});
|
|
return;
|
|
}
|
|
|
|
if('restartIce' in c.pc) {
|
|
try {
|
|
c.pc.restartIce();
|
|
return;
|
|
} catch(e) {
|
|
console.warn(e);
|
|
}
|
|
}
|
|
|
|
// negotiate is async, but this returns immediately.
|
|
c.negotiate(true);
|
|
};
|
|
|
|
/**
|
|
* request sets the list of tracks. If this is not called, or called with
|
|
* a null argument, then the default is provided by ServerConnection.request.
|
|
*
|
|
* @param {Array<string>} what - a sequence of 'audio', 'video' or 'video-low'.
|
|
*/
|
|
Stream.prototype.request = function(what) {
|
|
let c = this;
|
|
c.sc.send({
|
|
type: 'requestStream',
|
|
id: c.id,
|
|
request: what,
|
|
});
|
|
};
|
|
|
|
/**
|
|
* updateStats is called periodically, if requested by setStatsInterval,
|
|
* in order to recompute stream statistics and invoke the onstats handler.
|
|
*
|
|
* @function
|
|
*/
|
|
Stream.prototype.updateStats = async function() {
|
|
let c = this;
|
|
let old = c.stats;
|
|
/** @type{Object<string,unknown>} */
|
|
let stats = {};
|
|
|
|
let transceivers = c.pc.getTransceivers();
|
|
for(let i = 0; i < transceivers.length; i++) {
|
|
let t = transceivers[i];
|
|
let stid = t.sender.track && t.sender.track.id;
|
|
let rtid = t.receiver.track && t.receiver.track.id;
|
|
|
|
let report = null;
|
|
if(stid) {
|
|
try {
|
|
report = await t.sender.getStats();
|
|
} catch(e) {
|
|
}
|
|
}
|
|
|
|
if(report) {
|
|
for(let r of report.values()) {
|
|
if(stid && r.type === 'outbound-rtp') {
|
|
let id = stid;
|
|
// Firefox doesn't implement rid, use ssrc
|
|
// to discriminate simulcast tracks.
|
|
id = id + '-' + r.ssrc;
|
|
if(!('bytesSent' in r))
|
|
continue;
|
|
if(!stats[id])
|
|
stats[id] = {};
|
|
stats[id][r.type] = {};
|
|
stats[id][r.type].timestamp = r.timestamp;
|
|
stats[id][r.type].bytesSent = r.bytesSent;
|
|
if(old[id] && old[id][r.type])
|
|
stats[id][r.type].rate =
|
|
((r.bytesSent - old[id][r.type].bytesSent) * 1000 /
|
|
(r.timestamp - old[id][r.type].timestamp)) * 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
report = null;
|
|
if(rtid) {
|
|
try {
|
|
report = await t.receiver.getStats();
|
|
} catch(e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
if(report) {
|
|
for(let r of report.values()) {
|
|
if(rtid && r.type === 'inbound-rtp') {
|
|
if(!('totalAudioEnergy' in r))
|
|
continue;
|
|
if(!stats[rtid])
|
|
stats[rtid] = {};
|
|
stats[rtid][r.type] = {};
|
|
stats[rtid][r.type].timestamp = r.timestamp;
|
|
stats[rtid][r.type].totalAudioEnergy = r.totalAudioEnergy;
|
|
if(old[rtid] && old[rtid][r.type])
|
|
stats[rtid][r.type].audioEnergy =
|
|
(r.totalAudioEnergy - old[rtid][r.type].totalAudioEnergy) * 1000 /
|
|
(r.timestamp - old[rtid][r.type].timestamp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
c.stats = stats;
|
|
|
|
if(c.onstats)
|
|
c.onstats.call(c, c.stats);
|
|
};
|
|
|
|
/**
|
|
* setStatsInterval sets the interval in milliseconds at which the onstats
|
|
* handler will be called. This is only useful for up streams.
|
|
*
|
|
* @param {number} ms - The interval in milliseconds.
|
|
*/
|
|
Stream.prototype.setStatsInterval = function(ms) {
|
|
let c = this;
|
|
if(c.statsHandler) {
|
|
clearInterval(c.statsHandler);
|
|
c.statsHandler = null;
|
|
}
|
|
|
|
if(ms <= 0)
|
|
return;
|
|
|
|
c.statsHandler = setInterval(() => {
|
|
c.updateStats();
|
|
}, ms);
|
|
};
|
|
|
|
|
|
/**
|
|
* A file in the process of being transferred.
|
|
* These are stored in the ServerConnection.transferredFiles dictionary.
|
|
*
|
|
* State transitions:
|
|
* @example
|
|
* '' -> inviting -> connecting -> connected -> done -> closed
|
|
* any -> cancelled -> closed
|
|
*
|
|
*
|
|
* @parm {ServerConnection} sc
|
|
* @parm {string} userid
|
|
* @parm {string} rid
|
|
* @parm {boolean} up
|
|
* @parm {string} username
|
|
* @parm {string} mimetype
|
|
* @parm {number} size
|
|
* @constructor
|
|
*/
|
|
function TransferredFile(sc, userid, id, up, username, name, mimetype, size) {
|
|
/**
|
|
* The server connection this file is associated with.
|
|
*
|
|
* @type {ServerConnection}
|
|
*/
|
|
this.sc = sc;
|
|
/** The id of the remote peer.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.userid = userid;
|
|
/**
|
|
* The id of this file transfer.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.id = id;
|
|
/**
|
|
* The negotiated file-transfer protocol version.
|
|
*
|
|
* This is the version of the file-transfer protocol, and is not
|
|
* necessarily equal to the version of the Galene protocol used by the
|
|
* server connection.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.version = null;
|
|
/**
|
|
* True if this is an upload.
|
|
*
|
|
* @type {boolean}
|
|
*/
|
|
this.up = up;
|
|
/**
|
|
* The state of this file transfer. See the description of the
|
|
* constructor for possible state transitions.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.state = '';
|
|
/**
|
|
* The username of the remote peer.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.username = username;
|
|
/**
|
|
* The name of the file being transferred.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.name = name;
|
|
/**
|
|
* The MIME type of the file being transferred.
|
|
*
|
|
* @type {string}
|
|
*/
|
|
this.mimetype = mimetype;
|
|
/**
|
|
* The size in bytes of the file being transferred.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
this.size = size;
|
|
/**
|
|
* The file being uploaded. Unused for downloads.
|
|
*
|
|
* @type {File}
|
|
*/
|
|
this.file = null;
|
|
/**
|
|
* The peer connection used for the transfer.
|
|
*
|
|
* @type {RTCPeerConnection}
|
|
*/
|
|
this.pc = null;
|
|
/**
|
|
* The datachannel used for the transfer.
|
|
*
|
|
* @type {RTCDataChannel}
|
|
*/
|
|
this.dc = null;
|
|
/**
|
|
* Buffered remote ICE candidates.
|
|
*
|
|
* @type {Array<RTCIceCandidateInit>}
|
|
*/
|
|
this.candidates = [];
|
|
/**
|
|
* The data received to date, stored as a list of blobs or array buffers,
|
|
* depending on what the browser supports.
|
|
*
|
|
* @type {Array<Blob|ArrayBuffer>}
|
|
*/
|
|
this.data = [];
|
|
/**
|
|
* The total size of the data received to date.
|
|
*
|
|
* @type {number}
|
|
*/
|
|
this.datalen = 0;
|
|
/**
|
|
* The main filetransfer callback.
|
|
*
|
|
* This is called whenever the state of the transfer changes,
|
|
* but may also be called multiple times in a single state, for example
|
|
* in order to display a progress bar. Call this.cancel in order
|
|
* to cancel the transfer.
|
|
*
|
|
* @type {(this: TransferredFile, type: string, [data]: string) => void}
|
|
*/
|
|
this.onevent = null;
|
|
}
|
|
|
|
/**
|
|
* The full id of this file transfer, used as a key in the transferredFiles
|
|
* dictionary.
|
|
*/
|
|
TransferredFile.prototype.fullid = function() {
|
|
return this.userid + '-' + this.id;
|
|
};
|
|
|
|
/**
|
|
* Retrieve a transferred file from the transferredFiles dictionary.
|
|
*
|
|
* @param {string} userid
|
|
* @param {string} fileid
|
|
* @returns {TransferredFile}
|
|
*/
|
|
ServerConnection.prototype.getTransferredFile = function(userid, fileid) {
|
|
return this.transferredFiles[userid + '-' + fileid];
|
|
};
|
|
|
|
/**
|
|
* Close a file transfer and remove it from the transferredFiles dictionary.
|
|
* Do not call this, call 'cancel' instead.
|
|
*/
|
|
TransferredFile.prototype.close = function() {
|
|
let f = this;
|
|
if(f.state === 'closed')
|
|
return;
|
|
if(f.state !== 'done' && f.state !== 'cancelled')
|
|
console.warn(
|
|
`TransferredFile.close called in unexpected state ${f.state}`,
|
|
);
|
|
if(f.dc) {
|
|
f.dc.onclose = null;
|
|
f.dc.onerror = null;
|
|
f.dc.onmessage = null;
|
|
}
|
|
if(f.pc)
|
|
f.pc.close();
|
|
f.dc = null;
|
|
f.pc = null;
|
|
f.data = [];
|
|
f.datalen = 0;
|
|
delete(f.sc.transferredFiles[f.fullid()]);
|
|
f.event('closed');
|
|
}
|
|
|
|
/**
|
|
* Buffer a chunk of data received during a file transfer.
|
|
* Do not call this, it is called automatically when data is received.
|
|
*
|
|
* @param {Blob|ArrayBuffer} data
|
|
*/
|
|
TransferredFile.prototype.bufferData = function(data) {
|
|
let f = this;
|
|
if(f.up)
|
|
throw new Error('buffering data in the wrong direction');
|
|
if(data instanceof Blob) {
|
|
f.datalen += data.size;
|
|
} else if(data instanceof ArrayBuffer) {
|
|
f.datalen += data.byteLength;
|
|
} else {
|
|
throw new Error('unexpected type for received data');
|
|
}
|
|
f.data.push(data);
|
|
}
|
|
|
|
/**
|
|
* Retreive the data buffered during a file transfer. Don't call this.
|
|
*
|
|
* @returns {Blob}
|
|
*/
|
|
TransferredFile.prototype.getBufferedData = function() {
|
|
let f = this;
|
|
if(f.up)
|
|
throw new Error('buffering data in wrong direction');
|
|
let blob = new Blob(f.data, {type: f.mimetype});
|
|
if(blob.size != f.datalen)
|
|
throw new Error('Inconsistent data size');
|
|
f.data = [];
|
|
f.datalen = 0;
|
|
return blob;
|
|
}
|
|
|
|
/**
|
|
* Set the file's state, and call the onevent callback.
|
|
*
|
|
* This calls the callback even if the state didn't change, which is
|
|
* useful if the client needs to display a progress bar.
|
|
*
|
|
* @param {string} state
|
|
* @param {any} [data]
|
|
*/
|
|
TransferredFile.prototype.event = function(state, data) {
|
|
let f = this;
|
|
f.state = state;
|
|
if(f.onevent)
|
|
f.onevent.call(f, state, data);
|
|
}
|
|
|
|
/**
|
|
* Send a cancel message for a file transfer.
|
|
*
|
|
* Don't call this, call TransferredFile.cancel instead.
|
|
*
|
|
* @param {ServerConnection} sc
|
|
* @param {string} userid
|
|
* @param {string} id
|
|
* @param {string|Error} [message]
|
|
*/
|
|
function sendFileCancel(sc, userid, id, message) {
|
|
let m = {
|
|
type: 'cancel',
|
|
id: id,
|
|
};
|
|
if(message)
|
|
m.message = message.toString();
|
|
sc.userMessage('filetransfer', userid, m);
|
|
}
|
|
|
|
|
|
/**
|
|
* Cancel a file transfer.
|
|
*
|
|
* Depending on the state, this will either forcibly close the connection,
|
|
* send a handshake, or do nothing. It will set the state to cancelled.
|
|
*
|
|
* @param {string|Error} [message]
|
|
*/
|
|
TransferredFile.prototype.cancel = function(message) {
|
|
let f = this;
|
|
if(f.state === 'closed')
|
|
return;
|
|
if(f.state !== '' && f.state !== 'done' && f.state !== 'cancelled')
|
|
sendFileCancel(f.sc, f.userid, f.id, message);
|
|
if(f.state !== 'done' && f.state !== 'cancelled')
|
|
f.event('cancelled', message);
|
|
f.close();
|
|
}
|
|
|
|
/**
|
|
* Forcibly terminate a file transfer.
|
|
*
|
|
* This is like cancel, but will not attempt to handshake.
|
|
* Use cancel instead of this, unless you know what you are doing.
|
|
*
|
|
* @param {string|Error} [data]
|
|
*/
|
|
TransferredFile.prototype.fail = function(data) {
|
|
let f = this;
|
|
if(f.state === 'done' || f.state === 'cancelled' || f.state === 'closed')
|
|
return;
|
|
f.event('cancelled', data);
|
|
f.close();
|
|
}
|
|
|
|
/**
|
|
* Initiate a file upload.
|
|
*
|
|
* This will cause the onfiletransfer callback to be called, at which
|
|
* point you should set up the onevent callback.
|
|
*
|
|
* @param {string} id
|
|
* @param {File} file
|
|
*/
|
|
ServerConnection.prototype.sendFile = function(id, file) {
|
|
let sc = this;
|
|
let fileid = newRandomId();
|
|
let user = sc.users[id];
|
|
if(!user)
|
|
throw new Error('offering upload to unknown user');
|
|
let f = new TransferredFile(
|
|
sc, id, fileid, true, user.username, file.name, file.type, file.size,
|
|
);
|
|
f.file = file;
|
|
|
|
try {
|
|
if(sc.onfiletransfer)
|
|
sc.onfiletransfer.call(sc, f);
|
|
else
|
|
throw new Error('this client does not implement file transfer');
|
|
} catch(e) {
|
|
f.cancel(e);
|
|
return;
|
|
}
|
|
|
|
if(f.state === 'closed') {
|
|
// the client cancelled the transfer
|
|
return;
|
|
}
|
|
|
|
sc.transferredFiles[f.fullid()] = f;
|
|
sc.userMessage('filetransfer', id, {
|
|
type: 'invite',
|
|
version: ["1"],
|
|
id: fileid,
|
|
name: f.name,
|
|
size: f.size,
|
|
mimetype: f.mimetype,
|
|
});
|
|
f.event('inviting');
|
|
}
|
|
|
|
/**
|
|
* Receive a file.
|
|
*
|
|
* Call this after the onfiletransfer callback has yielded an incoming
|
|
* file (up field set to false). If you wish to reject the file transfer,
|
|
* call cancel instead.
|
|
*/
|
|
TransferredFile.prototype.receive = async function() {
|
|
let f = this;
|
|
if(f.up)
|
|
throw new Error('Receiving in wrong direction');
|
|
if(f.pc)
|
|
throw new Error('Download already in progress');
|
|
let pc = new RTCPeerConnection(f.sc.getRTCConfiguration());
|
|
if(!pc) {
|
|
let err = new Error("Couldn't create peer connection");
|
|
f.fail(err);
|
|
return;
|
|
}
|
|
f.pc = pc;
|
|
f.event('connecting');
|
|
|
|
f.candidates = [];
|
|
pc.onsignalingstatechange = function(e) {
|
|
if(pc.signalingState === 'stable') {
|
|
f.candidates.forEach(c => pc.addIceCandidate(c).catch(console.warn));
|
|
f.candidates = [];
|
|
}
|
|
};
|
|
pc.onicecandidate = function(e) {
|
|
f.sc.userMessage('filetransfer', f.userid, {
|
|
type: 'ice',
|
|
id: f.id,
|
|
candidate: e.candidate,
|
|
});
|
|
};
|
|
f.dc = pc.createDataChannel('file');
|
|
f.data = [];
|
|
f.datalen = 0;
|
|
f.dc.onclose = function(e) {
|
|
f.cancel('remote peer closed connection');
|
|
};
|
|
f.dc.onmessage = function(e) {
|
|
f.receiveData(e.data).catch(e => f.cancel(e));
|
|
};
|
|
f.dc.onerror = function(e) {
|
|
/** @ts-ignore */
|
|
let err = e.error;
|
|
f.cancel(err)
|
|
};
|
|
let offer = await pc.createOffer();
|
|
if(!offer) {
|
|
f.cancel(new Error("Couldn't create offer"));
|
|
return;
|
|
}
|
|
await pc.setLocalDescription(offer);
|
|
f.sc.userMessage('filetransfer', f.userid, {
|
|
type: 'offer',
|
|
version: [f.version],
|
|
id: f.id,
|
|
sdp: pc.localDescription.sdp,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Negotiate a file transfer on the sender side.
|
|
* Don't call this, it is called automatically we receive an offer.
|
|
*
|
|
* @param {string} sdp
|
|
*/
|
|
TransferredFile.prototype.answer = async function(sdp) {
|
|
let f = this;
|
|
if(!f.up)
|
|
throw new Error('Sending file in wrong direction');
|
|
if(f.pc)
|
|
throw new Error('Transfer already in progress');
|
|
let pc = new RTCPeerConnection(f.sc.getRTCConfiguration());
|
|
if(!pc) {
|
|
let err = new Error("Couldn't create peer connection");
|
|
f.fail(err);
|
|
return;
|
|
}
|
|
f.pc = pc;
|
|
f.event('connecting');
|
|
|
|
f.candidates = [];
|
|
pc.onicecandidate = function(e) {
|
|
f.sc.userMessage('filetransfer', f.userid, {
|
|
type: 'ice',
|
|
id: f.id,
|
|
candidate: e.candidate,
|
|
});
|
|
};
|
|
pc.onsignalingstatechange = function(e) {
|
|
if(pc.signalingState === 'stable') {
|
|
f.candidates.forEach(c => pc.addIceCandidate(c).catch(console.warn));
|
|
f.candidates = [];
|
|
}
|
|
};
|
|
pc.ondatachannel = function(e) {
|
|
if(f.dc) {
|
|
f.cancel(new Error('Duplicate datachannel'));
|
|
return;
|
|
}
|
|
f.dc = /** @type{RTCDataChannel} */(e.channel);
|
|
f.dc.onclose = function(e) {
|
|
f.cancel('remote peer closed connection');
|
|
};
|
|
f.dc.onerror = function(e) {
|
|
/** @ts-ignore */
|
|
let err = e.error;
|
|
f.cancel(err);
|
|
}
|
|
f.dc.onmessage = function(e) {
|
|
if(e.data === 'done' && f.datalen === f.size) {
|
|
f.event('done');
|
|
f.dc.onclose = null;
|
|
f.dc.onerror = null;
|
|
f.close();
|
|
} else {
|
|
f.cancel(new Error('unexpected data from receiver'));
|
|
}
|
|
}
|
|
f.send().catch(e => f.cancel(e));
|
|
};
|
|
|
|
await pc.setRemoteDescription({
|
|
type: 'offer',
|
|
sdp: sdp,
|
|
});
|
|
|
|
let answer = await pc.createAnswer();
|
|
if(!answer)
|
|
throw new Error("Couldn't create answer");
|
|
await pc.setLocalDescription(answer);
|
|
f.sc.userMessage('filetransfer', f.userid, {
|
|
type: 'answer',
|
|
id: f.id,
|
|
sdp: pc.localDescription.sdp,
|
|
});
|
|
|
|
f.event('connected');
|
|
}
|
|
|
|
/**
|
|
* Transfer file data. Don't call this, it is called automatically
|
|
* after negotiation completes.
|
|
*/
|
|
TransferredFile.prototype.send = async function() {
|
|
let f = this;
|
|
if(!f.up)
|
|
throw new Error('sending in wrong direction');
|
|
let r = f.file.stream().getReader();
|
|
|
|
f.dc.bufferedAmountLowThreshold = 65536;
|
|
|
|
/** @param {Uint8Array} a */
|
|
async function write(a) {
|
|
while(f.dc.bufferedAmount > f.dc.bufferedAmountLowThreshold) {
|
|
await new Promise((resolve, reject) => {
|
|
if(!f.dc) {
|
|
reject(new Error('File is closed.'));
|
|
return;
|
|
}
|
|
f.dc.onbufferedamountlow = function(e) {
|
|
if(!f.dc) {
|
|
reject(new Error('File is closed.'));
|
|
return;
|
|
}
|
|
f.dc.onbufferedamountlow = null;
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
f.dc.send(a);
|
|
f.datalen += a.length;
|
|
// we're already in the connected state, but invoke callbacks to
|
|
// that the application can display progress
|
|
f.event('connected');
|
|
}
|
|
|
|
while(true) {
|
|
let v = await r.read();
|
|
if(v.done)
|
|
break;
|
|
let data = v.value;
|
|
if(!(data instanceof Uint8Array))
|
|
throw new Error('Unexpected type for chunk');
|
|
/* Base SCTP only supports up to 16kB data chunks. There are
|
|
extensions to handle larger chunks, but they don't interoperate
|
|
between browsers, so we chop the file into small pieces. */
|
|
if(data.length <= 16384) {
|
|
await write(data);
|
|
} else {
|
|
for(let i = 0; i < v.value.length; i += 16384) {
|
|
let d = data.subarray(i, Math.min(i + 16384, data.length));
|
|
await write(d);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called after we receive an answer. Don't call this.
|
|
*
|
|
* @param {string} sdp
|
|
*/
|
|
TransferredFile.prototype.receiveFile = async function(sdp) {
|
|
let f = this;
|
|
if(f.up)
|
|
throw new Error('Receiving in wrong direction');
|
|
await f.pc.setRemoteDescription({
|
|
type: 'answer',
|
|
sdp: sdp,
|
|
});
|
|
f.event('connected');
|
|
}
|
|
|
|
/**
|
|
* Called whenever we receive a chunk of data. Don't call this.
|
|
*
|
|
* @param {Blob|ArrayBuffer} data
|
|
*/
|
|
TransferredFile.prototype.receiveData = async function(data) {
|
|
let f = this;
|
|
if(f.up)
|
|
throw new Error('Receiving in wrong direction');
|
|
f.bufferData(data);
|
|
|
|
if(f.datalen < f.size) {
|
|
f.event('connected');
|
|
return;
|
|
}
|
|
|
|
f.dc.onmessage = null;
|
|
|
|
if(f.datalen != f.size) {
|
|
f.cancel('extra data at end of file');
|
|
return;
|
|
}
|
|
|
|
let blob = f.getBufferedData();
|
|
if(blob.size != f.size) {
|
|
f.cancel("inconsistent data size (this shouldn't happen)");
|
|
return;
|
|
}
|
|
f.event('done', blob);
|
|
|
|
// we've received the whole file. Send the final handshake, but don't
|
|
// complain if the peer has closed the channel in the meantime.
|
|
await new Promise((resolve, reject) => {
|
|
let timer = setTimeout(function(e) { resolve(); }, 2000);
|
|
f.dc.onclose = function(e) {
|
|
clearTimeout(timer);
|
|
resolve();
|
|
};
|
|
f.dc.onerror = function(e) {
|
|
clearTimeout(timer);
|
|
resolve();
|
|
};
|
|
f.dc.send('done');
|
|
});
|
|
|
|
f.close();
|
|
}
|
|
|
|
/**
|
|
* fileTransfer handles a usermessage of kind 'filetransfer'. Don't call
|
|
* this, it is called automatically as needed.
|
|
*
|
|
* @param {string} id
|
|
* @param {string} username
|
|
* @param {object} message
|
|
*/
|
|
ServerConnection.prototype.fileTransfer = function(id, username, message) {
|
|
let sc = this;
|
|
switch(message.type) {
|
|
case 'invite': {
|
|
/** @type {string} */
|
|
let version;
|
|
if((message.version instanceof Array) && message.version.includes('1')) {
|
|
version = '1';
|
|
} else {
|
|
sendFileCancel(sc, id, message.id,
|
|
`Unknown protocol version ${message.version}; ` +
|
|
'perhaps you need to upgrade your client ?');
|
|
return;
|
|
}
|
|
|
|
let f = new TransferredFile(
|
|
sc, id, message.id, false, username,
|
|
message.name, message.mimetype, message.size,
|
|
);
|
|
f.version = version;
|
|
f.state = 'inviting';
|
|
|
|
let fid = f.fullid();
|
|
if(fid in sc.transferredFiles) {
|
|
sendFileCancel(sc, id, message.id,
|
|
'Duplicate file transfer id; ' +
|
|
'perhaps you have tried to send a file to yourself?');
|
|
return;
|
|
}
|
|
|
|
|
|
try {
|
|
if(sc.onfiletransfer)
|
|
sc.onfiletransfer.call(sc, f);
|
|
else {
|
|
f.cancel('this client does not implement file transfer');
|
|
return;
|
|
}
|
|
} catch(e) {
|
|
f.cancel(e);
|
|
return;
|
|
}
|
|
|
|
sc.transferredFiles[fid] = f;
|
|
break;
|
|
}
|
|
case 'offer': {
|
|
let f = sc.getTransferredFile(id, message.id);
|
|
if(!f) {
|
|
console.error(`Unexpected ${message.type} for file transfer`);
|
|
return;
|
|
}
|
|
if((message.version instanceof Array) && message.version.includes('1')) {
|
|
f.version = '1';
|
|
} else {
|
|
f.cancel(`Unknown protocol version ${message.version}; ` +
|
|
'perhaps you need to upgrade your client ?'
|
|
);
|
|
return;
|
|
}
|
|
f.answer(message.sdp).catch(e => f.cancel(e));
|
|
break;
|
|
}
|
|
case 'answer': {
|
|
let f = sc.getTransferredFile(id, message.id);
|
|
if(!f) {
|
|
console.error(`Unexpected ${message.type} for file transfer`);
|
|
return;
|
|
}
|
|
f.receiveFile(message.sdp).catch(e => f.cancel(e));
|
|
break;
|
|
}
|
|
case 'ice':
|
|
{
|
|
let f = sc.getTransferredFile(id, message.id);
|
|
if(!f || !f.pc) {
|
|
console.warn(`Unexpected ${message.type} for file transfer`);
|
|
return;
|
|
}
|
|
if(f.pc.signalingState === 'stable')
|
|
f.pc.addIceCandidate(message.candidate).catch(console.warn);
|
|
else
|
|
f.candidates.push(message.candidate);
|
|
break;
|
|
}
|
|
case 'cancel': {
|
|
let f = sc.getTransferredFile(id, message.id);
|
|
if(!f) {
|
|
console.error(`Unexpected ${message.type} for file transfer`);
|
|
return;
|
|
}
|
|
f.event('cancelled', message.message || null);
|
|
f.close();
|
|
break;
|
|
}
|
|
case 'upice':
|
|
case 'downice':
|
|
case 'reject':
|
|
case 'abort': {
|
|
let f = sc.getTransferredFile(id, message.id);
|
|
if(f)
|
|
f.cancel(`Obsolete file transfer message ${message.type};` +
|
|
' please upgrade your client');
|
|
return;
|
|
}
|
|
default:
|
|
console.error(`Unknown filetransfer message ${message.type}`);
|
|
break;
|
|
}
|
|
}
|