/**
* Copyright (C) 2021 Double Bastion LLC
*
* This file is part of Roundpin, which is licensed under the
* GNU Affero General Public License Version 3.0. The license terms
* are detailed in the "LICENSE.txt" file located in the root directory.
*
* The file content from below is identical with that of the
* original file "sip-0.11.6.js". The copyright notice for
* the original content follows:
/*!
*
* SIP version 0.11.6
* Copyright (c) 2014-2018 Junction Networks, Inc <http://www.onsip.com>
* Homepage: https://sipjs.com
* License: https://sipjs.com/license/
*
*
* ~~~SIP.js contains substantial portions of JsSIP under the following license~~~
* Homepage: http://jssip.net
* Copyright (c) 2012-2013 José Luis Millán - Versatica <http://www.versatica.com>
*
* 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.
*
* ~~~ end JsSIP license ~~~
*
*
*
*
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["SIP"] = factory();
else
root["SIP"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = __webpack_require__(1)(__webpack_require__(40));
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @name SIP
* @namespace
*/
module.exports = function (environment) {
var pkg = __webpack_require__(2), version = pkg.version, title = pkg.title;
var SIP = Object.defineProperties({}, {
version: {
get: function () { return version; }
},
name: {
get: function () { return title; }
}
});
__webpack_require__(3)(SIP, environment);
SIP.LoggerFactory = __webpack_require__(4)(environment.console);
SIP.EventEmitter = __webpack_require__(5)();
SIP.C = __webpack_require__(7)(SIP.name, SIP.version);
SIP.Exceptions = __webpack_require__(8);
SIP.Timers = __webpack_require__(9)(environment.timers);
SIP.Transport = __webpack_require__(10)(SIP);
__webpack_require__(11)(SIP);
__webpack_require__(12)(SIP);
__webpack_require__(13)(SIP);
__webpack_require__(14)(SIP);
__webpack_require__(15)(SIP);
__webpack_require__(16)(SIP);
__webpack_require__(18)(SIP);
__webpack_require__(19)(SIP);
SIP.SessionDescriptionHandler = __webpack_require__(20)(SIP.EventEmitter);
__webpack_require__(21)(SIP);
__webpack_require__(22)(SIP);
__webpack_require__(23)(SIP);
__webpack_require__(25)(SIP);
__webpack_require__(26)(SIP);
__webpack_require__(27)(SIP, environment);
__webpack_require__(32)(SIP);
SIP.DigestAuthentication = __webpack_require__(33)(SIP.Utils);
SIP.Grammar = __webpack_require__(36)(SIP);
SIP.Web = {
Modifiers: __webpack_require__(38)(SIP),
Simple: __webpack_require__(39)(SIP)
};
return SIP;
};
/***/ }),
/* 2 */
/***/ (function(module) {
module.exports = {"name":"sip.js","title":"SIP.js","description":"A simple, intuitive, and powerful JavaScript signaling library","version":"0.11.6","main":"dist/sip.js","browser":{"./src/environment.js":"./src/environment_browser.js"},"homepage":"https://sipjs.com","author":"OnSIP <developer@onsip.com> (https://sipjs.com/aboutus/)","contributors":[{"url":"https://github.com/onsip/SIP.js/blob/master/THANKS.md"}],"repository":{"type":"git","url":"https://github.com/onsip/SIP.js.git"},"keywords":["sip","websocket","webrtc","library","javascript"],"devDependencies":{"awesome-typescript-loader":"^5.2.1","eslint":"^5.4.0","jasmine-core":"^3.2.1","karma":"^3.0.0","karma-chrome-launcher":"^2.2.0","karma-cli":"^1.0.1","karma-jasmine":"^1.1.0","karma-jasmine-html-reporter":"^1.3.1","karma-mocha-reporter":"^2.2.5","karma-webpack":"^3.0.0","pegjs":"^0.10.0","pegjs-loader":"^0.5.4","typescript":"^3.0.3","webpack":"^4.19.0","webpack-cli":"^3.0.8"},"engines":{"node":">=6.0"},"license":"MIT","scripts":{"prebuild":"eslint src/*.js src/**/*.js","build-dev":"webpack --progress --env.buildType dev","build-prod":"webpack --progress --env.buildType prod","copy-dist-files":"cp dist/sip.js dist/sip-$npm_package_version.js && cp dist/sip.min.js dist/sip-$npm_package_version.min.js","build":"npm run build-dev && npm run build-prod && npm run copy-dist-files","browserTest":"sleep 2 && open http://0.0.0.0:9876/debug.html & karma start --reporters kjhtml --no-single-run","commandLineTest":"karma start --reporters mocha --browsers ChromeHeadless --single-run","buildAndTest":"npm run build && npm run commandLineTest","buildAndBrowserTest":"npm run build && npm run browserTest"},"dependencies":{"crypto-js":"^3.1.9-1"},"optionalDependencies":{"promiscuous":"^0.6.0"}};
/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview Utils
*/
module.exports = function (SIP, environment) {
var Utils;
Utils = {
Promise: environment.Promise,
defer: function defer() {
var deferred = {};
deferred.promise = new Utils.Promise(function (resolve, reject) {
deferred.resolve = resolve;
deferred.reject = reject;
});
return deferred;
},
reducePromises: function reducePromises(arr, val) {
return arr.reduce(function (acc, fn) {
acc = acc.then(fn);
return acc;
}, SIP.Utils.Promise.resolve(val));
},
augment: function (object, constructor, args, override) {
var idx, proto;
// Add public properties from constructor's prototype onto object
proto = constructor.prototype;
for (idx in proto) {
if (override || object[idx] === undefined) {
object[idx] = proto[idx];
}
}
// Construct the object as though it were just created by constructor
constructor.apply(object, args);
},
defaultOptions: function (defaultOptions, overridingOptions) {
defaultOptions = defaultOptions || {};
overridingOptions = overridingOptions || {};
return Object.assign({}, defaultOptions, overridingOptions);
},
optionsOverride: function (options, winner, loser, isDeprecated, logger, defaultValue) {
if (isDeprecated && options[loser]) {
logger.warn(loser + ' is deprecated, please use ' + winner + ' instead');
}
if (options[winner] && options[loser]) {
logger.warn(winner + ' overriding ' + loser);
}
options[winner] = options[winner] || options[loser] || defaultValue;
},
str_utf8_length: function (string) {
return encodeURIComponent(string).replace(/%[A-F\d]{2}/g, 'U').length;
},
generateFakeSDP: function (body) {
if (!body) {
return;
}
var start = body.indexOf('o=');
var end = body.indexOf('\r\n', start);
return 'v=0\r\n' + body.slice(start, end) + '\r\ns=-\r\nt=0 0\r\nc=IN IP4 0.0.0.0';
},
isFunction: function (fn) {
if (fn !== undefined) {
return Object.prototype.toString.call(fn) === '[object Function]';
}
else {
return false;
}
},
isDecimal: function (num) {
return !isNaN(num) && (parseFloat(num) === parseInt(num, 10));
},
createRandomToken: function (size, base) {
var i, r, token = '';
base = base || 32;
for (i = 0; i < size; i++) {
r = Math.random() * base | 0;
token += r.toString(base);
}
return token;
},
newTag: function () {
return SIP.Utils.createRandomToken(SIP.UA.C.TAG_LENGTH);
},
// http://stackoverflow.com/users/109538/broofa
newUUID: function () {
var UUID = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
return UUID;
},
hostType: function (host) {
if (!host) {
return;
}
else {
host = SIP.Grammar.parse(host, 'host');
if (host !== -1) {
return host.host_type;
}
}
},
/**
* Normalize SIP URI.
* NOTE: It does not allow a SIP URI without username.
* Accepts 'sip', 'sips' and 'tel' URIs and convert them into 'sip'.
* Detects the domain part (if given) and properly hex-escapes the user portion.
* If the user portion has only 'tel' number symbols the user portion is clean of 'tel' visual separators.
* @private
* @param {String} target
* @param {String} [domain]
*/
normalizeTarget: function (target, domain) {
var uri, target_array, target_user, target_domain;
// If no target is given then raise an error.
if (!target) {
return;
// If a SIP.URI instance is given then return it.
}
else if (target instanceof SIP.URI) {
return target;
// If a string is given split it by '@':
// - Last fragment is the desired domain.
// - Otherwise append the given domain argument.
}
else if (typeof target === 'string') {
target_array = target.split('@');
switch (target_array.length) {
case 1:
if (!domain) {
return;
}
target_user = target;
target_domain = domain;
break;
case 2:
target_user = target_array[0];
target_domain = target_array[1];
break;
default:
target_user = target_array.slice(0, target_array.length - 1).join('@');
target_domain = target_array[target_array.length - 1];
}
// Remove the URI scheme (if present).
target_user = target_user.replace(/^(sips?|tel):/i, '');
// Remove 'tel' visual separators if the user portion just contains 'tel' number symbols.
if (/^[\-\.\(\)]*\+?[0-9\-\.\(\)]+$/.test(target_user)) {
target_user = target_user.replace(/[\-\.\(\)]/g, '');
}
// Build the complete SIP URI.
target = SIP.C.SIP + ':' + SIP.Utils.escapeUser(target_user) + '@' + target_domain;
// Finally parse the resulting URI.
uri = SIP.URI.parse(target);
return uri;
}
else {
return;
}
},
/**
* Hex-escape a SIP URI user.
* @private
* @param {String} user
*/
escapeUser: function (user) {
// Don't hex-escape ':' (%3A), '+' (%2B), '?' (%3F"), '/' (%2F).
return encodeURIComponent(decodeURIComponent(user)).replace(/%3A/ig, ':').replace(/%2B/ig, '+').replace(/%3F/ig, '?').replace(/%2F/ig, '/');
},
headerize: function (string) {
var exceptions = {
'Call-Id': 'Call-ID',
'Cseq': 'CSeq',
'Min-Se': 'Min-SE',
'Rack': 'RAck',
'Rseq': 'RSeq',
'Www-Authenticate': 'WWW-Authenticate'
}, name = string.toLowerCase().replace(/_/g, '-').split('-'), hname = '', parts = name.length, part;
for (part = 0; part < parts; part++) {
if (part !== 0) {
hname += '-';
}
hname += name[part].charAt(0).toUpperCase() + name[part].substring(1);
}
if (exceptions[hname]) {
hname = exceptions[hname];
}
return hname;
},
sipErrorCause: function (status_code) {
var cause;
for (cause in SIP.C.SIP_ERROR_CAUSES) {
if (SIP.C.SIP_ERROR_CAUSES[cause].indexOf(status_code) !== -1) {
return SIP.C.causes[cause];
}
}
return SIP.C.causes.SIP_FAILURE_CODE;
},
getReasonPhrase: function getReasonPhrase(code, specific) {
return specific || SIP.C.REASON_PHRASE[code] || '';
},
getReasonHeaderValue: function getReasonHeaderValue(code, reason) {
reason = SIP.Utils.getReasonPhrase(code, reason);
return 'SIP;cause=' + code + ';text="' + reason + '"';
},
getCancelReason: function getCancelReason(code, reason) {
if (code && code < 200 || code > 699) {
throw new TypeError('Invalid status_code: ' + code);
}
else if (code) {
return SIP.Utils.getReasonHeaderValue(code, reason);
}
},
buildStatusLine: function buildStatusLine(code, reason) {
code = code || null;
reason = reason || null;
// Validate code and reason values
if (!code || (code < 100 || code > 699)) {
throw new TypeError('Invalid status_code: ' + code);
}
else if (reason && typeof reason !== 'string' && !(reason instanceof String)) {
throw new TypeError('Invalid reason_phrase: ' + reason);
}
reason = Utils.getReasonPhrase(code, reason);
return 'SIP/2.0 ' + code + ' ' + reason + '\r\n';
},
/**
* Generate a random Test-Net IP (http://tools.ietf.org/html/rfc5735)
* @private
*/
getRandomTestNetIP: function () {
function getOctet(from, to) {
return Math.floor(Math.random() * (to - from + 1) + from);
}
return '192.0.2.' + getOctet(1, 254);
}
};
SIP.Utils = Utils;
};
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var levels = {
'error': 0,
'warn': 1,
'log': 2,
'debug': 3
};
module.exports = function (console) {
var LoggerFactory = function () {
var logger, level = 2, builtinEnabled = true, connector = null;
this.loggers = {};
logger = this.getLogger('sip.loggerfactory');
Object.defineProperties(this, {
builtinEnabled: {
get: function () { return builtinEnabled; },
set: function (value) {
if (typeof value === 'boolean') {
builtinEnabled = value;
}
else {
logger.error('invalid "builtinEnabled" parameter value: ' + JSON.stringify(value));
}
}
},
level: {
get: function () { return level; },
set: function (value) {
if (value >= 0 && value <= 3) {
level = value;
}
else if (value > 3) {
level = 3;
}
else if (levels.hasOwnProperty(value)) {
level = levels[value];
}
else {
logger.error('invalid "level" parameter value: ' + JSON.stringify(value));
}
}
},
connector: {
get: function () { return connector; },
set: function (value) {
if (value === null || value === "" || value === undefined) {
connector = null;
}
else if (typeof value === 'function') {
connector = value;
}
else {
logger.error('invalid "connector" parameter value: ' + JSON.stringify(value));
}
}
}
});
};
LoggerFactory.prototype.print = function (target, category, label, content) {
if (typeof content === 'string') {
var prefix = [new Date(), category];
if (label) {
prefix.push(label);
}
content = prefix.concat(content).join(' | ');
}
target.call(console, content);
};
function Logger(logger, category, label) {
this.logger = logger;
this.category = category;
this.label = label;
}
Object.keys(levels).forEach(function (targetName) {
Logger.prototype[targetName] = function (content) {
this.logger[targetName](this.category, this.label, content);
};
LoggerFactory.prototype[targetName] = function (category, label, content) {
if (this.level >= levels[targetName]) {
if (this.builtinEnabled) {
this.print(console[targetName], category, label, content);
}
if (this.connector) {
this.connector(targetName, category, label, content);
}
}
};
});
LoggerFactory.prototype.getLogger = function (category, label) {
var logger;
if (label && this.level === 3) {
return new Logger(this, category, label);
}
else if (this.loggers[category]) {
return this.loggers[category];
}
else {
logger = new Logger(this, category);
this.loggers[category] = logger;
return logger;
}
};
return LoggerFactory;
};
/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var NodeEventEmitter = __webpack_require__(6).EventEmitter;
module.exports = function () {
// Don't use `new SIP.EventEmitter()` for inheriting.
// Use Object.create(SIP.EventEmitter.prototoype);
function EventEmitter() {
NodeEventEmitter.call(this);
}
EventEmitter.prototype = Object.create(NodeEventEmitter.prototype, {
constructor: {
value: EventEmitter,
enumerable: false,
writable: true,
configurable: true
}
});
return EventEmitter;
};
/***/ }),
/* 6 */
/***/ (function(module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
//
// 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.
function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
// At least give some kind of context to the user
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
err.context = er;
throw err;
}
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
args = Array.prototype.slice.call(arguments, 1);
handler.apply(this, args);
}
} else if (isObject(handler)) {
args = Array.prototype.slice.call(arguments, 1);
listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];
// Check for listener leak
if (isObject(this._events[type]) && !this._events[type].warned) {
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}
if (m && m > 0 && this._events[type].length > m) {
this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
console.trace();
}
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}
g.listener = listener;
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);
} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}
if (this._events.removeListener)
this.emit('removeListener', type, listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;
if (!this._events)
return this;
// not listening for removeListener, no need to emit
if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}
listeners = this._events[type];
if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else if (listeners) {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];
return this;
};
EventEmitter.prototype.listeners = function(type) {
var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};
EventEmitter.prototype.listenerCount = function(type) {
if (this._events) {
var evlistener = this._events[type];
if (isFunction(evlistener))
return 1;
else if (evlistener)
return evlistener.length;
}
return 0;
};
EventEmitter.listenerCount = function(emitter, type) {
return emitter.listenerCount(type);
};
function isFunction(arg) {
return typeof arg === 'function';
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isUndefined(arg) {
return arg === void 0;
}
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Constants
*/
/**
* SIP Constants.
* @augments SIP
*/
module.exports = function (name, version) {
return {
USER_AGENT: name + '/' + version,
// SIP scheme
SIP: 'sip',
SIPS: 'sips',
// End and Failure causes
causes: {
// Generic error causes
CONNECTION_ERROR: 'Connection Error',
REQUEST_TIMEOUT: 'Request Timeout',
SIP_FAILURE_CODE: 'SIP Failure Code',
INTERNAL_ERROR: 'Internal Error',
// SIP error causes
BUSY: 'Busy',
REJECTED: 'Rejected',
REDIRECTED: 'Redirected',
UNAVAILABLE: 'Unavailable',
NOT_FOUND: 'Not Found',
ADDRESS_INCOMPLETE: 'Address Incomplete',
INCOMPATIBLE_SDP: 'Incompatible SDP',
AUTHENTICATION_ERROR: 'Authentication Error',
DIALOG_ERROR: 'Dialog Error',
// Session error causes
WEBRTC_NOT_SUPPORTED: 'WebRTC Not Supported',
WEBRTC_ERROR: 'WebRTC Error',
CANCELED: 'Canceled',
NO_ANSWER: 'No Answer',
EXPIRES: 'Expires',
NO_ACK: 'No ACK',
NO_PRACK: 'No PRACK',
USER_DENIED_MEDIA_ACCESS: 'User Denied Media Access',
BAD_MEDIA_DESCRIPTION: 'Bad Media Description',
RTP_TIMEOUT: 'RTP Timeout'
},
supported: {
UNSUPPORTED: 'none',
SUPPORTED: 'supported',
REQUIRED: 'required'
},
SIP_ERROR_CAUSES: {
REDIRECTED: [300, 301, 302, 305, 380],
BUSY: [486, 600],
REJECTED: [403, 603],
NOT_FOUND: [404, 604],
UNAVAILABLE: [480, 410, 408, 430],
ADDRESS_INCOMPLETE: [484],
INCOMPATIBLE_SDP: [488, 606],
AUTHENTICATION_ERROR: [401, 407]
},
// SIP Methods
ACK: 'ACK',
BYE: 'BYE',
CANCEL: 'CANCEL',
INFO: 'INFO',
INVITE: 'INVITE',
MESSAGE: 'MESSAGE',
NOTIFY: 'NOTIFY',
OPTIONS: 'OPTIONS',
REGISTER: 'REGISTER',
UPDATE: 'UPDATE',
SUBSCRIBE: 'SUBSCRIBE',
PUBLISH: 'PUBLISH',
REFER: 'REFER',
PRACK: 'PRACK',
/* SIP Response Reasons
* DOC: http://www.iana.org/assignments/sip-parameters
* Copied from https://github.com/versatica/OverSIP/blob/master/lib/oversip/sip/constants.rb#L7
*/
REASON_PHRASE: {
100: 'Trying',
180: 'Ringing',
181: 'Call Is Being Forwarded',
182: 'Queued',
183: 'Session Progress',
199: 'Early Dialog Terminated',
200: 'OK',
202: 'Accepted',
204: 'No Notification',
300: 'Multiple Choices',
301: 'Moved Permanently',
302: 'Moved Temporarily',
305: 'Use Proxy',
380: 'Alternative Service',
400: 'Bad Request',
401: 'Unauthorized',
402: 'Payment Required',
403: 'Forbidden',
404: 'Not Found',
405: 'Method Not Allowed',
406: 'Not Acceptable',
407: 'Proxy Authentication Required',
408: 'Request Timeout',
410: 'Gone',
412: 'Conditional Request Failed',
413: 'Request Entity Too Large',
414: 'Request-URI Too Long',
415: 'Unsupported Media Type',
416: 'Unsupported URI Scheme',
417: 'Unknown Resource-Priority',
420: 'Bad Extension',
421: 'Extension Required',
422: 'Session Interval Too Small',
423: 'Interval Too Brief',
428: 'Use Identity Header',
429: 'Provide Referrer Identity',
430: 'Flow Failed',
433: 'Anonymity Disallowed',
436: 'Bad Identity-Info',
437: 'Unsupported Certificate',
438: 'Invalid Identity Header',
439: 'First Hop Lacks Outbound Support',
440: 'Max-Breadth Exceeded',
469: 'Bad Info Package',
470: 'Consent Needed',
478: 'Unresolvable Destination',
480: 'Temporarily Unavailable',
481: 'Call/Transaction Does Not Exist',
482: 'Loop Detected',
483: 'Too Many Hops',
484: 'Address Incomplete',
485: 'Ambiguous',
486: 'Busy Here',
487: 'Request Terminated',
488: 'Not Acceptable Here',
489: 'Bad Event',
491: 'Request Pending',
493: 'Undecipherable',
494: 'Security Agreement Required',
500: 'Internal Server Error',
501: 'Not Implemented',
502: 'Bad Gateway',
503: 'Service Unavailable',
504: 'Server Time-out',
505: 'Version Not Supported',
513: 'Message Too Large',
580: 'Precondition Failure',
600: 'Busy Everywhere',
603: 'Decline',
604: 'Does Not Exist Anywhere',
606: 'Not Acceptable'
},
/* SIP Option Tags
* DOC: http://www.iana.org/assignments/sip-parameters/sip-parameters.xhtml#sip-parameters-4
*/
OPTION_TAGS: {
'100rel': true,
199: true,
answermode: true,
'early-session': true,
eventlist: true,
explicitsub: true,
'from-change': true,
'geolocation-http': true,
'geolocation-sip': true,
gin: true,
gruu: true,
histinfo: true,
ice: true,
join: true,
'multiple-refer': true,
norefersub: true,
nosub: true,
outbound: true,
path: true,
policy: true,
precondition: true,
pref: true,
privacy: true,
'recipient-list-invite': true,
'recipient-list-message': true,
'recipient-list-subscribe': true,
replaces: true,
'resource-priority': true,
'sdp-anat': true,
'sec-agree': true,
tdialog: true,
timer: true,
uui: true // RFC 7433
},
dtmfType: {
INFO: 'info',
RTP: 'rtp'
}
};
};
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview Exceptions
*/
/**
* SIP Exceptions.
* @augments SIP
*/
module.exports = {
ConfigurationError: (function () {
var exception = function (parameter, value) {
this.code = 1;
this.name = 'CONFIGURATION_ERROR';
this.parameter = parameter;
this.value = value;
this.message = (!this.value) ? 'Missing parameter: ' + this.parameter : 'Invalid value ' + JSON.stringify(this.value) + ' for parameter "' + this.parameter + '"';
};
exception.prototype = new Error();
return exception;
}()),
InvalidStateError: (function () {
var exception = function (status) {
this.code = 2;
this.name = 'INVALID_STATE_ERROR';
this.status = status;
this.message = 'Invalid status: ' + status;
};
exception.prototype = new Error();
return exception;
}()),
NotSupportedError: (function () {
var exception = function (message) {
this.code = 3;
this.name = 'NOT_SUPPORTED_ERROR';
this.message = message;
};
exception.prototype = new Error();
return exception;
}()),
// Deprecated
GetDescriptionError: (function () {
var exception = function (message) {
this.code = 4;
this.name = 'GET_DESCRIPTION_ERROR';
this.message = message;
};
exception.prototype = new Error();
return exception;
}()),
RenegotiationError: (function () {
var exception = function (message) {
this.code = 5;
this.name = 'RENEGOTIATION_ERROR';
this.message = message;
};
exception.prototype = new Error();
return exception;
}()),
MethodParameterError: (function () {
var exception = function (method, parameter, value) {
this.code = 6;
this.name = 'METHOD_PARAMETER_ERROR';
this.method = method;
this.parameter = parameter;
this.value = value;
this.message = (!this.value) ? 'Missing parameter: ' + this.parameter : 'Invalid value ' + JSON.stringify(this.value) + ' for parameter "' + this.parameter + '"';
};
exception.prototype = new Error();
return exception;
}()),
TransportError: (function () {
var exception = function (message) {
this.code = 7;
this.name = 'TRANSPORT_ERROR';
this.message = message;
};
exception.prototype = new Error();
return exception;
}()),
SessionDescriptionHandlerError: (function () {
var exception = function (method, error, message) {
this.code = 8;
this.name = 'SESSION_DESCRIPTION_HANDLER_ERROR';
this.method = method;
this.error = error;
this.message = message || 'Error with Session Description Handler';
};
exception.prototype = new Error();
return exception;
}()),
};
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP TIMERS
*/
/**
* @augments SIP
*/
var T1 = 500, T2 = 4000, T4 = 5000;
module.exports = function (timers) {
var Timers = {
T1: T1,
T2: T2,
T4: T4,
TIMER_B: 64 * T1,
TIMER_D: 0 * T1,
TIMER_F: 64 * T1,
TIMER_H: 64 * T1,
TIMER_I: 0 * T1,
TIMER_J: 0 * T1,
TIMER_K: 0 * T4,
TIMER_L: 64 * T1,
TIMER_M: 64 * T1,
TIMER_N: 64 * T1,
PROVISIONAL_RESPONSE_INTERVAL: 60000 // See RFC 3261 Section 13.3.1.1
};
['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval']
.forEach(function (name) {
// can't just use timers[name].bind(timers) since it bypasses jasmine's
// clock-mocking
Timers[name] = function () {
return timers[name].apply(timers, arguments);
};
});
return Timers;
};
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* eslint-disable */
/**
* @fileoverview Transport
*/
/* Transport
* @class Abstract transport layer parent class
* @param {Logger} logger
* @param {Object} [options]
*/
module.exports = function (SIP) {
var Transport = function (logger, options) { };
Transport.prototype = Object.create(SIP.EventEmitter.prototype, {
/**
* Returns the promise designated by the child layer then emits a connected event. Automatically emits an event upon resolution, unless overrideEvent is set. If you override the event in this fashion, you should emit it in your implementation of connectPromise
* @param {Object} [options]
* @returns {Promise}
*/
connect: { writable: true, value: function connect(options) {
options = options || {};
return this.connectPromise(options).then(function (data) { !data.overrideEvent && this.emit('connected'); }.bind(this));
} },
/**
* Called by connect, must return a promise
* promise must resolve to an object. object supports 1 parameter: overrideEvent - Boolean
* @abstract
* @private
* @param {Object} [options]
* @returns {Promise}
*/
connectPromise: { writable: true, value: function connectPromise(options) { } },
/**
* Returns true if the transport is connected
* @abstract
* @returns {Boolean}
*/
isConnected: { writable: true, value: function isConnected() { } },
/**
* Sends a message then emits a 'messageSent' event. Automatically emits an event upon resolution, unless data.overrideEvent is set. If you override the event in this fashion, you should emit it in your implementation of sendPromise
* @param {SIP.OutgoingRequest|String} msg
* @param {Object} options
* @returns {Promise}
*/
send: { writable: true, value: function send(msg, options) {
options = options || {};
return this.sendPromise(msg).then(function (data) { !data.overrideEvent && this.emit('messageSent', data.msg); }.bind(this));
} },
/**
* Called by send, must return a promise
* promise must resolve to an object. object supports 2 parameters: msg - string (mandatory) and overrideEvent - Boolean (optional)
* @abstract
* @private
* @param {SIP.OutgoingRequest|String} msg
* @param {Object} [options]
* @returns {Promise}
*/
sendPromise: { writable: true, value: function sendPromise(msg, options) { } },
/**
* To be called when a message is received
* @abstract
* @param {Event} e
*/
onMessage: { writable: true, value: function onMessage(e) { } },
/**
* Returns the promise designated by the child layer then emits a disconnected event. Automatically emits an event upon resolution, unless overrideEvent is set. If you override the event in this fashion, you should emit it in your implementation of disconnectPromise
* @param {Object} [options]
* @returns {Promise}
*/
disconnect: { writable: true, value: function disconnect(options) {
options = options || {};
return this.disconnectPromise(options).then(function (data) { !data.overrideEvent && this.emit('disconnected'); }.bind(this));
} },
/**
* Called by disconnect, must return a promise
* promise must resolve to an object. object supports 1 parameter: overrideEvent - Boolean
* @abstract
* @private
* @param {Object} [options]
* @returns {Promise}
*/
disconnectPromise: { writable: true, value: function disconnectPromise(options) { } },
afterConnected: { writable: true, value: function afterConnected(callback) {
if (this.isConnected()) {
callback();
}
else {
this.once('connected', callback);
}
} },
/**
* Returns a promise which resolves once the UA is connected. DEPRECATION WARNING: just use afterConnected()
* @returns {Promise}
*/
waitForConnected: { writable: true, value: function waitForConnected() {
console.warn("DEPRECATION WARNING Transport.waitForConnected(): use afterConnected() instead");
return new SIP.Utils.Promise(function (resolve) {
this.afterConnected(resolve);
}.bind(this));
} },
});
return Transport;
};
/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Message Parser
*/
/**
* Extract and parse every header of a SIP message.
* @augments SIP
* @namespace
*/
module.exports = function (SIP) {
var Parser;
function getHeader(data, headerStart) {
var
// 'start' position of the header.
start = headerStart,
// 'end' position of the header.
end = 0,
// 'partial end' position of the header.
partialEnd = 0;
//End of message.
if (data.substring(start, start + 2).match(/(^\r\n)/)) {
return -2;
}
while (end === 0) {
// Partial End of Header.
partialEnd = data.indexOf('\r\n', start);
// 'indexOf' returns -1 if the value to be found never occurs.
if (partialEnd === -1) {
return partialEnd;
}
if (!data.substring(partialEnd + 2, partialEnd + 4).match(/(^\r\n)/) && data.charAt(partialEnd + 2).match(/(^\s+)/)) {
// Not the end of the message. Continue from the next position.
start = partialEnd + 2;
}
else {
end = partialEnd;
}
}
return end;
}
function parseHeader(message, data, headerStart, headerEnd) {
var header, idx, length, parsed, hcolonIndex = data.indexOf(':', headerStart), headerName = data.substring(headerStart, hcolonIndex).trim(), headerValue = data.substring(hcolonIndex + 1, headerEnd).trim();
// If header-field is well-known, parse it.
switch (headerName.toLowerCase()) {
case 'via':
case 'v':
message.addHeader('via', headerValue);
if (message.getHeaders('via').length === 1) {
parsed = message.parseHeader('Via');
if (parsed) {
message.via = parsed;
message.via_branch = parsed.branch;
}
}
else {
parsed = 0;
}
break;
case 'from':
case 'f':
message.setHeader('from', headerValue);
parsed = message.parseHeader('from');
if (parsed) {
message.from = parsed;
message.from_tag = parsed.getParam('tag');
}
break;
case 'to':
case 't':
message.setHeader('to', headerValue);
parsed = message.parseHeader('to');
if (parsed) {
message.to = parsed;
message.to_tag = parsed.getParam('tag');
}
break;
case 'record-route':
parsed = SIP.Grammar.parse(headerValue, 'Record_Route');
if (parsed === -1) {
parsed = undefined;
break;
}
length = parsed.length;
for (idx = 0; idx < length; idx++) {
header = parsed[idx];
message.addHeader('record-route', headerValue.substring(header.position, header.offset));
message.headers['Record-Route'][message.getHeaders('record-route').length - 1].parsed = header.parsed;
}
break;
case 'call-id':
case 'i':
message.setHeader('call-id', headerValue);
parsed = message.parseHeader('call-id');
if (parsed) {
message.call_id = headerValue;
}
break;
case 'contact':
case 'm':
parsed = SIP.Grammar.parse(headerValue, 'Contact');
if (parsed === -1) {
parsed = undefined;
break;
}
length = parsed.length;
for (idx = 0; idx < length; idx++) {
header = parsed[idx];
message.addHeader('contact', headerValue.substring(header.position, header.offset));
message.headers['Contact'][message.getHeaders('contact').length - 1].parsed = header.parsed;
}
break;
case 'content-length':
case 'l':
message.setHeader('content-length', headerValue);
parsed = message.parseHeader('content-length');
break;
case 'content-type':
case 'c':
message.setHeader('content-type', headerValue);
parsed = message.parseHeader('content-type');
break;
case 'cseq':
message.setHeader('cseq', headerValue);
parsed = message.parseHeader('cseq');
if (parsed) {
message.cseq = parsed.value;
}
if (message instanceof SIP.IncomingResponse) {
message.method = parsed.method;
}
break;
case 'max-forwards':
message.setHeader('max-forwards', headerValue);
parsed = message.parseHeader('max-forwards');
break;
case 'www-authenticate':
message.setHeader('www-authenticate', headerValue);
parsed = message.parseHeader('www-authenticate');
break;
case 'proxy-authenticate':
message.setHeader('proxy-authenticate', headerValue);
parsed = message.parseHeader('proxy-authenticate');
break;
case 'refer-to':
case 'r':
message.setHeader('refer-to', headerValue);
parsed = message.parseHeader('refer-to');
if (parsed) {
message.refer_to = parsed;
}
break;
default:
// Do not parse this header.
message.setHeader(headerName, headerValue);
parsed = 0;
}
if (parsed === undefined) {
return {
error: 'error parsing header "' + headerName + '"'
};
}
else {
return true;
}
}
/** Parse SIP Message
* @function
* @param {String} message SIP message.
* @param {Object} logger object.
* @returns {SIP.IncomingRequest|SIP.IncomingResponse|undefined}
*/
Parser = {};
Parser.parseMessage = function (data, ua) {
var message, firstLine, contentLength, bodyStart, parsed, headerStart = 0, headerEnd = data.indexOf('\r\n'), logger = ua.getLogger('sip.parser');
if (headerEnd === -1) {
logger.warn('no CRLF found, not a SIP message, discarded');
return;
}
// Parse first line. Check if it is a Request or a Reply.
firstLine = data.substring(0, headerEnd);
parsed = SIP.Grammar.parse(firstLine, 'Request_Response');
if (parsed === -1) {
logger.warn('error parsing first line of SIP message: "' + firstLine + '"');
return;
}
else if (!parsed.status_code) {
message = new SIP.IncomingRequest(ua);
message.method = parsed.method;
message.ruri = parsed.uri;
}
else {
message = new SIP.IncomingResponse(ua);
message.status_code = parsed.status_code;
message.reason_phrase = parsed.reason_phrase;
}
message.data = data;
headerStart = headerEnd + 2;
/* Loop over every line in data. Detect the end of each header and parse
* it or simply add to the headers collection.
*/
while (true) {
headerEnd = getHeader(data, headerStart);
// The SIP message has normally finished.
if (headerEnd === -2) {
bodyStart = headerStart + 2;
break;
}
// data.indexOf returned -1 due to a malformed message.
else if (headerEnd === -1) {
logger.error('malformed message');
return;
}
parsed = parseHeader(message, data, headerStart, headerEnd);
if (parsed !== true) {
logger.error(parsed.error);
return;
}
headerStart = headerEnd + 2;
}
/* RFC3261 18.3.
* If there are additional bytes in the transport packet
* beyond the end of the body, they MUST be discarded.
*/
if (message.hasHeader('content-length')) {
contentLength = message.getHeader('content-length');
message.body = data.substr(bodyStart, contentLength);
}
else {
message.body = data.substring(bodyStart);
}
return message;
};
SIP.Parser = Parser;
};
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Message
*/
module.exports = function (SIP) {
var OutgoingRequest, IncomingMessage, IncomingRequest, IncomingResponse;
function getSupportedHeader(request) {
var allowUnregistered = request.ua.configuration.hackAllowUnregisteredOptionTags;
var optionTags = [];
var optionTagSet = {};
if (request.method === SIP.C.REGISTER) {
optionTags.push('path', 'gruu');
}
else if (request.method === SIP.C.INVITE &&
(request.ua.contact.pub_gruu || request.ua.contact.temp_gruu)) {
optionTags.push('gruu');
}
if (request.ua.configuration.rel100 === SIP.C.supported.SUPPORTED) {
optionTags.push('100rel');
}
if (request.ua.configuration.replaces === SIP.C.supported.SUPPORTED) {
optionTags.push('replaces');
}
optionTags.push('outbound');
optionTags = optionTags.concat(request.ua.configuration.extraSupported);
optionTags = optionTags.filter(function (optionTag) {
var registered = SIP.C.OPTION_TAGS[optionTag];
var unique = !optionTagSet[optionTag];
optionTagSet[optionTag] = true;
return (registered || allowUnregistered) && unique;
});
return 'Supported: ' + optionTags.join(', ') + '\r\n';
}
/**
* @augments SIP
* @class Class for outgoing SIP request.
* @param {String} method request method
* @param {String} ruri request uri
* @param {SIP.UA} ua
* @param {Object} params parameters that will have priority over ua.configuration parameters:
* <br>
* - cseq, call_id, from_tag, from_uri, from_displayName, to_uri, to_tag, route_set
* @param {Object} [headers] extra headers
* @param {String} [body]
*/
OutgoingRequest = function (method, ruri, ua, params, extraHeaders, body) {
var to, from, call_id, cseq, to_uri, from_uri;
params = params || {};
// Mandatory parameters check
if (!method || !ruri || !ua) {
return null;
}
this.logger = ua.getLogger('sip.sipmessage');
this.ua = ua;
this.headers = {};
this.method = method;
this.ruri = ruri;
this.body = body;
this.extraHeaders = (extraHeaders || []).slice();
this.statusCode = params.status_code;
this.reasonPhrase = params.reason_phrase;
// Fill the Common SIP Request Headers
// Route
if (params.route_set) {
this.setHeader('route', params.route_set);
}
else if (ua.configuration.usePreloadedRoute) {
this.setHeader('route', ua.transport.server.sip_uri);
}
// Via
// Empty Via header. Will be filled by the client transaction.
this.setHeader('via', '');
// Max-Forwards
this.setHeader('max-forwards', SIP.UA.C.MAX_FORWARDS);
// To
to_uri = params.to_uri || ruri;
to = (params.to_displayName || params.to_displayName === 0) ? '"' + params.to_displayName + '" ' : '';
to += '<' + (to_uri && to_uri.toRaw ? to_uri.toRaw() : to_uri) + '>';
to += params.to_tag ? ';tag=' + params.to_tag : '';
this.to = new SIP.NameAddrHeader.parse(to);
this.setHeader('to', to);
// From
from_uri = params.from_uri || ua.configuration.uri;
if (params.from_displayName || params.from_displayName === 0) {
from = '"' + params.from_displayName + '" ';
}
else if (ua.configuration.displayName) {
from = '"' + ua.configuration.displayName + '" ';
}
else {
from = '';
}
from += '<' + (from_uri && from_uri.toRaw ? from_uri.toRaw() : from_uri) + '>;tag=';
from += params.from_tag || SIP.Utils.newTag();
this.from = new SIP.NameAddrHeader.parse(from);
this.setHeader('from', from);
// Call-ID
call_id = params.call_id || (ua.configuration.sipjsId + SIP.Utils.createRandomToken(15));
this.call_id = call_id;
this.setHeader('call-id', call_id);
// CSeq
cseq = params.cseq || Math.floor(Math.random() * 10000);
this.cseq = cseq;
this.setHeader('cseq', cseq + ' ' + method);
};
OutgoingRequest.prototype = {
/**
* Replace the the given header by the given value.
* @param {String} name header name
* @param {String | Array} value header value
*/
setHeader: function (name, value) {
this.headers[SIP.Utils.headerize(name)] = (value instanceof Array) ? value : [value];
},
/**
* Get the value of the given header name at the given position.
* @param {String} name header name
* @returns {String|undefined} Returns the specified header, undefined if header doesn't exist.
*/
getHeader: function (name) {
var regexp, idx, length = this.extraHeaders.length, header = this.headers[SIP.Utils.headerize(name)];
if (header) {
if (header[0]) {
return header[0];
}
}
else {
regexp = new RegExp('^\\s*' + name + '\\s*:', 'i');
for (idx = 0; idx < length; idx++) {
header = this.extraHeaders[idx];
if (regexp.test(header)) {
return header.substring(header.indexOf(':') + 1).trim();
}
}
}
return;
},
/**
* Get the header/s of the given name.
* @param {String} name header name
* @returns {Array} Array with all the headers of the specified name.
*/
getHeaders: function (name) {
var idx, length, regexp, header = this.headers[SIP.Utils.headerize(name)], result = [];
if (header) {
length = header.length;
for (idx = 0; idx < length; idx++) {
result.push(header[idx]);
}
return result;
}
else {
length = this.extraHeaders.length;
regexp = new RegExp('^\\s*' + name + '\\s*:', 'i');
for (idx = 0; idx < length; idx++) {
header = this.extraHeaders[idx];
if (regexp.test(header)) {
result.push(header.substring(header.indexOf(':') + 1).trim());
}
}
return result;
}
},
/**
* Verify the existence of the given header.
* @param {String} name header name
* @returns {boolean} true if header with given name exists, false otherwise
*/
hasHeader: function (name) {
var regexp, idx, length = this.extraHeaders.length;
if (this.headers[SIP.Utils.headerize(name)]) {
return true;
}
else {
regexp = new RegExp('^\\s*' + name + '\\s*:', 'i');
for (idx = 0; idx < length; idx++) {
if (regexp.test(this.extraHeaders[idx])) {
return true;
}
}
}
return false;
},
toString: function () {
var msg = '', header, length, idx;
msg += this.method + ' ' + (this.ruri.toRaw ? this.ruri.toRaw() : this.ruri) + ' SIP/2.0\r\n';
for (header in this.headers) {
length = this.headers[header].length;
for (idx = 0; idx < length; idx++) {
msg += header + ': ' + this.headers[header][idx] + '\r\n';
}
}
length = this.extraHeaders.length;
for (idx = 0; idx < length; idx++) {
msg += this.extraHeaders[idx].trim() + '\r\n';
}
msg += getSupportedHeader(this);
msg += 'User-Agent: ' + this.ua.configuration.userAgentString + '\r\n';
if (this.body) {
if (typeof this.body === 'string') {
length = SIP.Utils.str_utf8_length(this.body);
msg += 'Content-Length: ' + length + '\r\n\r\n';
msg += this.body;
}
else {
if (this.body.body && this.body.contentType) {
length = SIP.Utils.str_utf8_length(this.body.body);
msg += 'Content-Type: ' + this.body.contentType + '\r\n';
msg += 'Content-Length: ' + length + '\r\n\r\n';
msg += this.body.body;
}
else {
msg += 'Content-Length: ' + 0 + '\r\n\r\n';
}
}
}
else {
msg += 'Content-Length: ' + 0 + '\r\n\r\n';
}
return msg;
}
};
/**
* @augments SIP
* @class Class for incoming SIP message.
*/
IncomingMessage = function () {
this.data = null;
this.headers = null;
this.method = null;
this.via = null;
this.via_branch = null;
this.call_id = null;
this.cseq = null;
this.from = null;
this.from_tag = null;
this.to = null;
this.to_tag = null;
this.body = null;
};
IncomingMessage.prototype = {
/**
* Insert a header of the given name and value into the last position of the
* header array.
* @param {String} name header name
* @param {String} value header value
*/
addHeader: function (name, value) {
var header = { raw: value };
name = SIP.Utils.headerize(name);
if (this.headers[name]) {
this.headers[name].push(header);
}
else {
this.headers[name] = [header];
}
},
/**
* Get the value of the given header name at the given position.
* @param {String} name header name
* @returns {String|undefined} Returns the specified header, null if header doesn't exist.
*/
getHeader: function (name) {
var header = this.headers[SIP.Utils.headerize(name)];
if (header) {
if (header[0]) {
return header[0].raw;
}
}
else {
return;
}
},
/**
* Get the header/s of the given name.
* @param {String} name header name
* @returns {Array} Array with all the headers of the specified name.
*/
getHeaders: function (name) {
var idx, length, header = this.headers[SIP.Utils.headerize(name)], result = [];
if (!header) {
return [];
}
length = header.length;
for (idx = 0; idx < length; idx++) {
result.push(header[idx].raw);
}
return result;
},
/**
* Verify the existence of the given header.
* @param {String} name header name
* @returns {boolean} true if header with given name exists, false otherwise
*/
hasHeader: function (name) {
return (this.headers[SIP.Utils.headerize(name)]) ? true : false;
},
/**
* Parse the given header on the given index.
* @param {String} name header name
* @param {Number} [idx=0] header index
* @returns {Object|undefined} Parsed header object, undefined if the header is not present or in case of a parsing error.
*/
parseHeader: function (name, idx) {
var header, value, parsed;
name = SIP.Utils.headerize(name);
idx = idx || 0;
if (!this.headers[name]) {
this.logger.log('header "' + name + '" not present');
return;
}
else if (idx >= this.headers[name].length) {
this.logger.log('not so many "' + name + '" headers present');
return;
}
header = this.headers[name][idx];
value = header.raw;
if (header.parsed) {
return header.parsed;
}
//substitute '-' by '_' for grammar rule matching.
parsed = SIP.Grammar.parse(value, name.replace(/-/g, '_'));
if (parsed === -1) {
this.headers[name].splice(idx, 1); //delete from headers
this.logger.warn('error parsing "' + name + '" header field with value "' + value + '"');
return;
}
else {
header.parsed = parsed;
return parsed;
}
},
/**
* Message Header attribute selector. Alias of parseHeader.
* @param {String} name header name
* @param {Number} [idx=0] header index
* @returns {Object|undefined} Parsed header object, undefined if the header is not present or in case of a parsing error.
*
* @example
* message.s('via',3).port
*/
s: function (name, idx) {
return this.parseHeader(name, idx);
},
/**
* Replace the value of the given header by the value.
* @param {String} name header name
* @param {String} value header value
*/
setHeader: function (name, value) {
var header = { raw: value };
this.headers[SIP.Utils.headerize(name)] = [header];
},
toString: function () {
return this.data;
}
};
/**
* @augments IncomingMessage
* @class Class for incoming SIP request.
*/
IncomingRequest = function (ua) {
this.logger = ua.getLogger('sip.sipmessage');
this.ua = ua;
this.headers = {};
this.ruri = null;
this.transport = null;
this.server_transaction = null;
};
IncomingRequest.prototype = new IncomingMessage();
/**
* Stateful reply.
* @param {Number} code status code
* @param {String} reason reason phrase
* @param {Object} headers extra headers
* @param {String} body body
* @param {Function} [onSuccess] onSuccess callback
* @param {Function} [onFailure] onFailure callback
*/
// TODO: Get rid of callbacks and make promise based
IncomingRequest.prototype.reply = function (code, reason, extraHeaders, body, onSuccess, onFailure) {
var rr, vias, length, idx, response, to = this.getHeader('To'), r = 0, v = 0;
response = SIP.Utils.buildStatusLine(code, reason);
extraHeaders = (extraHeaders || []).slice();
if (this.method === SIP.C.INVITE && code > 100 && code <= 200) {
rr = this.getHeaders('record-route');
length = rr.length;
for (r; r < length; r++) {
response += 'Record-Route: ' + rr[r] + '\r\n';
}
}
vias = this.getHeaders('via');
length = vias.length;
for (v; v < length; v++) {
response += 'Via: ' + vias[v] + '\r\n';
}
if (!this.to_tag && code > 100) {
to += ';tag=' + SIP.Utils.newTag();
}
else if (this.to_tag && !this.s('to').hasParam('tag')) {
to += ';tag=' + this.to_tag;
}
response += 'To: ' + to + '\r\n';
response += 'From: ' + this.getHeader('From') + '\r\n';
response += 'Call-ID: ' + this.call_id + '\r\n';
response += 'CSeq: ' + this.cseq + ' ' + this.method + '\r\n';
length = extraHeaders.length;
for (idx = 0; idx < length; idx++) {
response += extraHeaders[idx].trim() + '\r\n';
}
response += getSupportedHeader(this);
response += 'User-Agent: ' + this.ua.configuration.userAgentString + '\r\n';
if (body) {
if (typeof body === 'string') {
length = SIP.Utils.str_utf8_length(body);
response += 'Content-Type: application/sdp\r\n';
response += 'Content-Length: ' + length + '\r\n\r\n';
response += body;
}
else {
if (body.body && body.contentType) {
length = SIP.Utils.str_utf8_length(body.body);
response += 'Content-Type: ' + body.contentType + '\r\n';
response += 'Content-Length: ' + length + '\r\n\r\n';
response += body.body;
}
else {
response += 'Content-Length: ' + 0 + '\r\n\r\n';
}
}
}
else {
response += 'Content-Length: ' + 0 + '\r\n\r\n';
}
this.server_transaction.receiveResponse(code, response).then(onSuccess, onFailure);
return response;
};
/**
* Stateless reply.
* @param {Number} code status code
* @param {String} reason reason phrase
*/
IncomingRequest.prototype.reply_sl = function (code, reason) {
var to, response, v = 0, vias = this.getHeaders('via'), length = vias.length;
response = SIP.Utils.buildStatusLine(code, reason);
for (v; v < length; v++) {
response += 'Via: ' + vias[v] + '\r\n';
}
to = this.getHeader('To');
if (!this.to_tag && code > 100) {
to += ';tag=' + SIP.Utils.newTag();
}
else if (this.to_tag && !this.s('to').hasParam('tag')) {
to += ';tag=' + this.to_tag;
}
response += 'To: ' + to + '\r\n';
response += 'From: ' + this.getHeader('From') + '\r\n';
response += 'Call-ID: ' + this.call_id + '\r\n';
response += 'CSeq: ' + this.cseq + ' ' + this.method + '\r\n';
response += 'User-Agent: ' + this.ua.configuration.userAgentString + '\r\n';
response += 'Content-Length: ' + 0 + '\r\n\r\n';
this.transport.send(response);
};
/**
* @augments IncomingMessage
* @class Class for incoming SIP response.
*/
IncomingResponse = function (ua) {
this.logger = ua.getLogger('sip.sipmessage');
this.headers = {};
this.status_code = null;
this.reason_phrase = null;
};
IncomingResponse.prototype = new IncomingMessage();
SIP.OutgoingRequest = OutgoingRequest;
SIP.IncomingRequest = IncomingRequest;
SIP.IncomingResponse = IncomingResponse;
};
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP URI
*/
/**
* @augments SIP
* @class Class creating a SIP URI.
*
* @param {String} [scheme]
* @param {String} [user]
* @param {String} host
* @param {String} [port]
* @param {Object} [parameters]
* @param {Object} [headers]
*
*/
module.exports = function (SIP) {
var URI;
URI = function (scheme, user, host, port, parameters, headers) {
var param, header, raw, normal;
// Checks
if (!host) {
throw new TypeError('missing or invalid "host" parameter');
}
// Initialize parameters
scheme = scheme || SIP.C.SIP;
this.parameters = {};
this.headers = {};
for (param in parameters) {
this.setParam(param, parameters[param]);
}
for (header in headers) {
this.setHeader(header, headers[header]);
}
// Raw URI
raw = {
scheme: scheme,
user: user,
host: host,
port: port
};
// Normalized URI
normal = {
scheme: scheme.toLowerCase(),
user: user,
host: host.toLowerCase(),
port: port
};
Object.defineProperties(this, {
_normal: {
get: function () { return normal; }
},
_raw: {
get: function () { return raw; }
},
scheme: {
get: function () { return normal.scheme; },
set: function (value) {
raw.scheme = value;
normal.scheme = value.toLowerCase();
}
},
user: {
get: function () { return normal.user; },
set: function (value) {
normal.user = raw.user = value;
}
},
host: {
get: function () { return normal.host; },
set: function (value) {
raw.host = value;
normal.host = value.toLowerCase();
}
},
aor: {
get: function () { return normal.user + '@' + normal.host; }
},
port: {
get: function () { return normal.port; },
set: function (value) {
normal.port = raw.port = value === 0 ? value : (parseInt(value, 10) || null);
}
}
});
};
URI.prototype = {
setParam: function (key, value) {
if (key) {
this.parameters[key.toLowerCase()] = (typeof value === 'undefined' || value === null) ? null : value.toString();
}
},
getParam: function (key) {
if (key) {
return this.parameters[key.toLowerCase()];
}
},
hasParam: function (key) {
if (key) {
return (this.parameters.hasOwnProperty(key.toLowerCase()) && true) || false;
}
},
deleteParam: function (parameter) {
var value;
parameter = parameter.toLowerCase();
if (this.parameters.hasOwnProperty(parameter)) {
value = this.parameters[parameter];
delete this.parameters[parameter];
return value;
}
},
clearParams: function () {
this.parameters = {};
},
setHeader: function (name, value) {
this.headers[SIP.Utils.headerize(name)] = (value instanceof Array) ? value : [value];
},
getHeader: function (name) {
if (name) {
return this.headers[SIP.Utils.headerize(name)];
}
},
hasHeader: function (name) {
if (name) {
return (this.headers.hasOwnProperty(SIP.Utils.headerize(name)) && true) || false;
}
},
deleteHeader: function (header) {
var value;
header = SIP.Utils.headerize(header);
if (this.headers.hasOwnProperty(header)) {
value = this.headers[header];
delete this.headers[header];
return value;
}
},
clearHeaders: function () {
this.headers = {};
},
clone: function () {
return new URI(this._raw.scheme, this._raw.user, this._raw.host, this._raw.port, JSON.parse(JSON.stringify(this.parameters)), JSON.parse(JSON.stringify(this.headers)));
},
toRaw: function () {
return this._toString(this._raw);
},
toString: function () {
return this._toString(this._normal);
},
_toString: function (uri) {
var header, parameter, idx, uriString, headers = [];
uriString = uri.scheme + ':';
// add slashes if it's not a sip(s) URI
if (!uri.scheme.toLowerCase().match("^sips?$")) {
uriString += "//";
}
if (uri.user) {
uriString += SIP.Utils.escapeUser(uri.user) + '@';
}
uriString += uri.host;
if (uri.port || uri.port === 0) {
uriString += ':' + uri.port;
}
for (parameter in this.parameters) {
uriString += ';' + parameter;
if (this.parameters[parameter] !== null) {
uriString += '=' + this.parameters[parameter];
}
}
for (header in this.headers) {
for (idx in this.headers[header]) {
headers.push(header + '=' + this.headers[header][idx]);
}
}
if (headers.length > 0) {
uriString += '?' + headers.join('&');
}
return uriString;
}
};
/**
* Parse the given string and returns a SIP.URI instance or undefined if
* it is an invalid URI.
* @public
* @param {String} uri
*/
URI.parse = function (uri) {
uri = SIP.Grammar.parse(uri, 'SIP_URI');
if (uri !== -1) {
return uri;
}
else {
return undefined;
}
};
SIP.URI = URI;
};
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP NameAddrHeader
*/
/**
* @augments SIP
* @class Class creating a Name Address SIP header.
*
* @param {SIP.URI} uri
* @param {String} [displayName]
* @param {Object} [parameters]
*
*/
module.exports = function (SIP) {
var NameAddrHeader;
NameAddrHeader = function (uri, displayName, parameters) {
var param;
// Checks
if (!uri || !(uri instanceof SIP.URI)) {
throw new TypeError('missing or invalid "uri" parameter');
}
// Initialize parameters
this.uri = uri;
this.parameters = {};
for (param in parameters) {
this.setParam(param, parameters[param]);
}
Object.defineProperties(this, {
friendlyName: {
get: function () { return this.displayName || uri.aor; }
},
displayName: {
get: function () { return displayName; },
set: function (value) {
displayName = (value === 0) ? '0' : value;
}
}
});
};
NameAddrHeader.prototype = {
setParam: function (key, value) {
if (key) {
this.parameters[key.toLowerCase()] = (typeof value === 'undefined' || value === null) ? null : value.toString();
}
},
getParam: SIP.URI.prototype.getParam,
hasParam: SIP.URI.prototype.hasParam,
deleteParam: SIP.URI.prototype.deleteParam,
clearParams: SIP.URI.prototype.clearParams,
clone: function () {
return new NameAddrHeader(this.uri.clone(), this.displayName, JSON.parse(JSON.stringify(this.parameters)));
},
toString: function () {
var body, parameter;
body = (this.displayName || this.displayName === 0) ? '"' + this.displayName + '" ' : '';
body += '<' + this.uri.toString() + '>';
for (parameter in this.parameters) {
body += ';' + parameter;
if (this.parameters[parameter] !== null) {
body += '=' + this.parameters[parameter];
}
}
return body;
}
};
/**
* Parse the given string and returns a SIP.NameAddrHeader instance or undefined if
* it is an invalid NameAddrHeader.
* @public
* @param {String} name_addr_header
*/
NameAddrHeader.parse = function (name_addr_header) {
name_addr_header = SIP.Grammar.parse(name_addr_header, 'Name_Addr_Header');
if (name_addr_header !== -1) {
return name_addr_header;
}
else {
return undefined;
}
};
SIP.NameAddrHeader = NameAddrHeader;
};
/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Transactions
*/
/**
* SIP Transactions module.
* @augments SIP
*/
module.exports = function (SIP) {
var C = {
// Transaction states
STATUS_TRYING: 1,
STATUS_PROCEEDING: 2,
STATUS_CALLING: 3,
STATUS_ACCEPTED: 4,
STATUS_COMPLETED: 5,
STATUS_TERMINATED: 6,
STATUS_CONFIRMED: 7,
// Transaction types
NON_INVITE_CLIENT: 'nict',
NON_INVITE_SERVER: 'nist',
INVITE_CLIENT: 'ict',
INVITE_SERVER: 'ist'
};
function buildViaHeader(request_sender, transport, id) {
var via;
via = 'SIP/2.0/' + (request_sender.ua.configuration.hackViaTcp ? 'TCP' : transport.server.scheme);
via += ' ' + request_sender.ua.configuration.viaHost + ';branch=' + id;
if (request_sender.ua.configuration.forceRport) {
via += ';rport';
}
return via;
}
/**
* @augments SIP.Transactions
* @class Non Invite Client Transaction
* @param {SIP.RequestSender} request_sender
* @param {SIP.OutgoingRequest} request
* @param {SIP.Transport} transport
*/
var NonInviteClientTransaction = function (request_sender, request, transport) {
var via;
this.type = C.NON_INVITE_CLIENT;
this.transport = transport;
this.id = 'z9hG4bK' + Math.floor(Math.random() * 10000000);
this.request_sender = request_sender;
this.request = request;
this.logger = request_sender.ua.getLogger('sip.transaction.nict', this.id);
via = buildViaHeader(request_sender, transport, this.id);
this.request.setHeader('via', via);
this.request_sender.ua.newTransaction(this);
};
NonInviteClientTransaction.prototype = Object.create(SIP.EventEmitter.prototype);
NonInviteClientTransaction.prototype.stateChanged = function (state) {
this.state = state;
this.emit('stateChanged');
};
NonInviteClientTransaction.prototype.send = function () {
var tr = this;
this.stateChanged(C.STATUS_TRYING);
this.F = SIP.Timers.setTimeout(tr.timer_F.bind(tr), SIP.Timers.TIMER_F);
this.transport.send(this.request).catch(function () {
this.onTransportError();
}.bind(this));
};
NonInviteClientTransaction.prototype.onTransportError = function () {
this.logger.log('transport error occurred, deleting non-INVITE client transaction ' + this.id);
SIP.Timers.clearTimeout(this.F);
SIP.Timers.clearTimeout(this.K);
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
this.request_sender.onTransportError();
};
NonInviteClientTransaction.prototype.timer_F = function () {
this.logger.debug('Timer F expired for non-INVITE client transaction ' + this.id);
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
this.request_sender.onRequestTimeout();
};
NonInviteClientTransaction.prototype.timer_K = function () {
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
};
NonInviteClientTransaction.prototype.receiveResponse = function (response) {
var tr = this, status_code = response.status_code;
if (status_code < 200) {
switch (this.state) {
case C.STATUS_TRYING:
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_PROCEEDING);
this.request_sender.receiveResponse(response);
break;
}
}
else {
switch (this.state) {
case C.STATUS_TRYING:
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_COMPLETED);
SIP.Timers.clearTimeout(this.F);
if (status_code === 408) {
this.request_sender.onRequestTimeout();
}
else {
this.request_sender.receiveResponse(response);
}
this.K = SIP.Timers.setTimeout(tr.timer_K.bind(tr), SIP.Timers.TIMER_K);
break;
case C.STATUS_COMPLETED:
break;
}
}
};
/**
* @augments SIP.Transactions
* @class Invite Client Transaction
* @param {SIP.RequestSender} request_sender
* @param {SIP.OutgoingRequest} request
* @param {SIP.Transport} transport
*/
var InviteClientTransaction = function (request_sender, request, transport) {
var via, tr = this;
this.type = C.INVITE_CLIENT;
this.transport = transport;
this.id = 'z9hG4bK' + Math.floor(Math.random() * 10000000);
this.request_sender = request_sender;
this.request = request;
this.logger = request_sender.ua.getLogger('sip.transaction.ict', this.id);
via = buildViaHeader(request_sender, transport, this.id);
this.request.setHeader('via', via);
this.request_sender.ua.newTransaction(this);
// Add the cancel property to the request.
//Will be called from the request instance, not the transaction itself.
this.request.cancel = function (reason, extraHeaders) {
extraHeaders = (extraHeaders || []).slice();
var length = extraHeaders.length;
var extraHeadersString = null;
for (var idx = 0; idx < length; idx++) {
extraHeadersString = (extraHeadersString || '') + extraHeaders[idx].trim() + '\r\n';
}
tr.cancel_request(tr, reason, extraHeadersString);
};
};
InviteClientTransaction.prototype = Object.create(SIP.EventEmitter.prototype);
InviteClientTransaction.prototype.stateChanged = function (state) {
this.state = state;
this.emit('stateChanged');
};
InviteClientTransaction.prototype.send = function () {
var tr = this;
this.stateChanged(C.STATUS_CALLING);
this.B = SIP.Timers.setTimeout(tr.timer_B.bind(tr), SIP.Timers.TIMER_B);
this.transport.send(this.request).catch(function () {
this.onTransportError();
}.bind(this));
};
InviteClientTransaction.prototype.onTransportError = function () {
this.logger.log('transport error occurred, deleting INVITE client transaction ' + this.id);
SIP.Timers.clearTimeout(this.B);
SIP.Timers.clearTimeout(this.D);
SIP.Timers.clearTimeout(this.M);
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
if (this.state !== C.STATUS_ACCEPTED) {
this.request_sender.onTransportError();
}
};
// RFC 6026 7.2
InviteClientTransaction.prototype.timer_M = function () {
this.logger.debug('Timer M expired for INVITE client transaction ' + this.id);
if (this.state === C.STATUS_ACCEPTED) {
SIP.Timers.clearTimeout(this.B);
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
}
};
// RFC 3261 17.1.1
InviteClientTransaction.prototype.timer_B = function () {
this.logger.debug('Timer B expired for INVITE client transaction ' + this.id);
if (this.state === C.STATUS_CALLING) {
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
this.request_sender.onRequestTimeout();
}
};
InviteClientTransaction.prototype.timer_D = function () {
this.logger.debug('Timer D expired for INVITE client transaction ' + this.id);
SIP.Timers.clearTimeout(this.B);
this.stateChanged(C.STATUS_TERMINATED);
this.request_sender.ua.destroyTransaction(this);
};
InviteClientTransaction.prototype.sendACK = function (options) {
// TODO: Move PRACK stuff into the transaction layer. That is really where it should be
var self = this, ruri;
options = options || {};
if (this.response.getHeader('contact')) {
ruri = this.response.parseHeader('contact').uri;
}
else {
ruri = this.request.ruri;
}
var ack = new SIP.OutgoingRequest("ACK", ruri, this.request.ua, {
cseq: this.response.cseq,
call_id: this.response.call_id,
from_uri: this.response.from.uri,
from_tag: this.response.from_tag,
to_uri: this.response.to.uri,
to_tag: this.response.to_tag,
route_set: this.response.getHeaders('record-route').reverse()
}, options.extraHeaders || [], options.body);
this.ackSender = new SIP.RequestSender({
request: ack,
onRequestTimeout: this.request_sender.applicant.applicant ? this.request_sender.applicant.applicant.onRequestTimeout : function () {
self.logger.warn("ACK Request timed out");
},
onTransportError: this.request_sender.applicant.applicant ? this.request_sender.applicant.applicant.onRequestTransportError : function () {
self.logger.warn("ACK Request had a transport error");
},
receiveResponse: options.receiveResponse || function () {
self.logger.warn("Received a response to an ACK which was unexpected. Dropping Response.");
}
}, this.request.ua).send();
return ack;
};
InviteClientTransaction.prototype.cancel_request = function (tr, reason, extraHeaders) {
var request = tr.request;
this.cancel = SIP.C.CANCEL + ' ' + request.ruri + ' SIP/2.0\r\n';
this.cancel += 'Via: ' + request.headers['Via'].toString() + '\r\n';
if (this.request.headers['Route']) {
this.cancel += 'Route: ' + request.headers['Route'].toString() + '\r\n';
}
this.cancel += 'To: ' + request.headers['To'].toString() + '\r\n';
this.cancel += 'From: ' + request.headers['From'].toString() + '\r\n';
this.cancel += 'Call-ID: ' + request.headers['Call-ID'].toString() + '\r\n';
this.cancel += 'Max-Forwards: ' + SIP.UA.C.MAX_FORWARDS + '\r\n';
this.cancel += 'CSeq: ' + request.headers['CSeq'].toString().split(' ')[0] +
' CANCEL\r\n';
if (reason) {
this.cancel += 'Reason: ' + reason + '\r\n';
}
if (extraHeaders) {
this.cancel += extraHeaders;
}
this.cancel += 'Content-Length: 0\r\n\r\n';
// Send only if a provisional response (>100) has been received.
if (this.state === C.STATUS_PROCEEDING) {
this.transport.send(this.cancel);
}
};
InviteClientTransaction.prototype.receiveResponse = function (response) {
var tr = this, status_code = response.status_code;
// This may create a circular dependency...
response.transaction = this;
if (this.response &&
this.response.status_code === response.status_code &&
this.response.cseq === response.cseq) {
this.logger.debug("ICT Received a retransmission for cseq: " + response.cseq);
if (this.ackSender) {
this.ackSender.send();
}
return;
}
this.response = response;
if (status_code >= 100 && status_code <= 199) {
switch (this.state) {
case C.STATUS_CALLING:
this.stateChanged(C.STATUS_PROCEEDING);
this.request_sender.receiveResponse(response);
if (this.cancel) {
this.transport.send(this.cancel);
}
break;
case C.STATUS_PROCEEDING:
this.request_sender.receiveResponse(response);
break;
}
}
else if (status_code >= 200 && status_code <= 299) {
switch (this.state) {
case C.STATUS_CALLING:
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_ACCEPTED);
this.M = SIP.Timers.setTimeout(tr.timer_M.bind(tr), SIP.Timers.TIMER_M);
this.request_sender.receiveResponse(response);
break;
case C.STATUS_ACCEPTED:
this.request_sender.receiveResponse(response);
break;
}
}
else if (status_code >= 300 && status_code <= 699) {
switch (this.state) {
case C.STATUS_CALLING:
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_COMPLETED);
this.sendACK();
this.request_sender.receiveResponse(response);
break;
case C.STATUS_COMPLETED:
this.sendACK();
break;
}
}
};
/**
* @augments SIP.Transactions
* @class ACK Client Transaction
* @param {SIP.RequestSender} request_sender
* @param {SIP.OutgoingRequest} request
* @param {SIP.Transport} transport
*/
var AckClientTransaction = function (request_sender, request, transport) {
var via;
this.transport = transport;
this.id = 'z9hG4bK' + Math.floor(Math.random() * 10000000);
this.request_sender = request_sender;
this.request = request;
this.logger = request_sender.ua.getLogger('sip.transaction.nict', this.id);
via = buildViaHeader(request_sender, transport, this.id);
this.request.setHeader('via', via);
};
AckClientTransaction.prototype = Object.create(SIP.EventEmitter.prototype);
AckClientTransaction.prototype.send = function () {
this.transport.send(this.request).catch(function () {
this.onTransportError();
}.bind(this));
};
AckClientTransaction.prototype.onTransportError = function () {
this.logger.log('transport error occurred, for an ACK client transaction ' + this.id);
this.request_sender.onTransportError();
};
/**
* @augments SIP.Transactions
* @class Non Invite Server Transaction
* @param {SIP.IncomingRequest} request
* @param {SIP.UA} ua
*/
var NonInviteServerTransaction = function (request, ua) {
this.type = C.NON_INVITE_SERVER;
this.id = request.via_branch;
this.request = request;
this.transport = ua.transport;
this.ua = ua;
this.last_response = '';
request.server_transaction = this;
this.logger = ua.getLogger('sip.transaction.nist', this.id);
this.state = C.STATUS_TRYING;
ua.newTransaction(this);
};
NonInviteServerTransaction.prototype = Object.create(SIP.EventEmitter.prototype);
NonInviteServerTransaction.prototype.stateChanged = function (state) {
this.state = state;
this.emit('stateChanged');
};
NonInviteServerTransaction.prototype.timer_J = function () {
this.logger.debug('Timer J expired for non-INVITE server transaction ' + this.id);
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
};
NonInviteServerTransaction.prototype.onTransportError = function () {
if (!this.transportError) {
this.transportError = true;
this.logger.log('transport error occurred, deleting non-INVITE server transaction ' + this.id);
SIP.Timers.clearTimeout(this.J);
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
}
};
NonInviteServerTransaction.prototype.receiveResponse = function (status_code, response) {
var tr = this;
var deferred = SIP.Utils.defer();
if (status_code === 100) {
/* RFC 4320 4.1
* 'A SIP element MUST NOT
* send any provisional response with a
* Status-Code other than 100 to a non-INVITE request.'
*/
switch (this.state) {
case C.STATUS_TRYING:
this.stateChanged(C.STATUS_PROCEEDING);
this.transport.send(response).catch(function () {
this.onTransportError();
}.bind(this));
break;
case C.STATUS_PROCEEDING:
this.last_response = response;
this.transport.send(response).then(function () {
deferred.resolve();
}).catch(function () {
this.onTransportError();
deferred.reject();
}.bind(this));
break;
}
}
else if (status_code >= 200 && status_code <= 699) {
switch (this.state) {
case C.STATUS_TRYING:
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_COMPLETED);
this.last_response = response;
this.J = SIP.Timers.setTimeout(tr.timer_J.bind(tr), SIP.Timers.TIMER_J);
this.transport.send(response).then(function () {
deferred.resolve();
}).catch(function () {
this.onTransportError();
deferred.reject();
}.bind(this));
break;
case C.STATUS_COMPLETED:
break;
}
}
return deferred.promise;
};
/**
* @augments SIP.Transactions
* @class Invite Server Transaction
* @param {SIP.IncomingRequest} request
* @param {SIP.UA} ua
*/
var InviteServerTransaction = function (request, ua) {
this.type = C.INVITE_SERVER;
this.id = request.via_branch;
this.request = request;
this.transport = ua.transport;
this.ua = ua;
this.last_response = '';
request.server_transaction = this;
this.logger = ua.getLogger('sip.transaction.ist', this.id);
this.state = C.STATUS_PROCEEDING;
ua.newTransaction(this);
this.resendProvisionalTimer = null;
request.reply(100);
};
InviteServerTransaction.prototype = Object.create(SIP.EventEmitter.prototype);
InviteServerTransaction.prototype.stateChanged = function (state) {
this.state = state;
this.emit('stateChanged');
};
InviteServerTransaction.prototype.timer_H = function () {
this.logger.debug('Timer H expired for INVITE server transaction ' + this.id);
if (this.state === C.STATUS_COMPLETED) {
this.logger.warn('transactions', 'ACK for INVITE server transaction was never received, call will be terminated');
}
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
};
InviteServerTransaction.prototype.timer_I = function () {
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
};
// RFC 6026 7.1
InviteServerTransaction.prototype.timer_L = function () {
this.logger.debug('Timer L expired for INVITE server transaction ' + this.id);
if (this.state === C.STATUS_ACCEPTED) {
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
}
};
InviteServerTransaction.prototype.onTransportError = function () {
if (!this.transportError) {
this.transportError = true;
this.logger.log('transport error occurred, deleting INVITE server transaction ' + this.id);
if (this.resendProvisionalTimer !== null) {
SIP.Timers.clearInterval(this.resendProvisionalTimer);
this.resendProvisionalTimer = null;
}
SIP.Timers.clearTimeout(this.L);
SIP.Timers.clearTimeout(this.H);
SIP.Timers.clearTimeout(this.I);
this.stateChanged(C.STATUS_TERMINATED);
this.ua.destroyTransaction(this);
}
};
InviteServerTransaction.prototype.resend_provisional = function () {
this.transport.send(this.request).catch(function () {
this.onTransportError();
}.bind(this));
};
// INVITE Server Transaction RFC 3261 17.2.1
InviteServerTransaction.prototype.receiveResponse = function (status_code, response) {
var tr = this;
var deferred = SIP.Utils.defer();
if (status_code >= 100 && status_code <= 199) {
switch (this.state) {
case C.STATUS_PROCEEDING:
this.transport.send(response).catch(function () {
this.onTransportError();
}.bind(this));
this.last_response = response;
break;
}
}
if (status_code > 100 && status_code <= 199 && this.state === C.STATUS_PROCEEDING) {
// Trigger the resendProvisionalTimer only for the first non 100 provisional response.
if (this.resendProvisionalTimer === null) {
this.resendProvisionalTimer = SIP.Timers.setInterval(tr.resend_provisional.bind(tr), SIP.Timers.PROVISIONAL_RESPONSE_INTERVAL);
}
}
else if (status_code >= 200 && status_code <= 299) {
switch (this.state) {
case C.STATUS_PROCEEDING:
this.stateChanged(C.STATUS_ACCEPTED);
this.last_response = response;
this.L = SIP.Timers.setTimeout(tr.timer_L.bind(tr), SIP.Timers.TIMER_L);
if (this.resendProvisionalTimer !== null) {
SIP.Timers.clearInterval(this.resendProvisionalTimer);
this.resendProvisionalTimer = null;
}
/* falls through */
case C.STATUS_ACCEPTED:
// Note that this point will be reached for proceeding tr.state also.
this.transport.send(response).then(function () {
deferred.resolve();
}).catch(function (error) {
this.logger.error(error);
this.onTransportError();
deferred.reject();
}.bind(this));
break;
}
}
else if (status_code >= 300 && status_code <= 699) {
switch (this.state) {
case C.STATUS_PROCEEDING:
if (this.resendProvisionalTimer !== null) {
SIP.Timers.clearInterval(this.resendProvisionalTimer);
this.resendProvisionalTimer = null;
}
this.transport.send(response).then(function () {
this.stateChanged(C.STATUS_COMPLETED);
this.H = SIP.Timers.setTimeout(tr.timer_H.bind(tr), SIP.Timers.TIMER_H);
deferred.resolve();
}.bind(this)).catch(function (error) {
this.logger.error(error);
this.onTransportError();
deferred.reject();
}.bind(this));
break;
}
}
return deferred.promise;
};
/**
* @function
* @param {SIP.UA} ua
* @param {SIP.IncomingRequest} request
*
* @return {boolean}
* INVITE:
* _true_ if retransmission
* _false_ new request
*
* ACK:
* _true_ ACK to non2xx response
* _false_ ACK must be passed to TU (accepted state)
* ACK to 2xx response
*
* CANCEL:
* _true_ no matching invite transaction
* _false_ matching invite transaction and no final response sent
*
* OTHER:
* _true_ retransmission
* _false_ new request
*/
var checkTransaction = function (ua, request) {
var tr;
switch (request.method) {
case SIP.C.INVITE:
tr = ua.transactions.ist[request.via_branch];
if (tr) {
switch (tr.state) {
case C.STATUS_PROCEEDING:
tr.transport.send(tr.last_response);
break;
// RFC 6026 7.1 Invite retransmission
//received while in C.STATUS_ACCEPTED state. Absorb it.
case C.STATUS_ACCEPTED:
break;
}
return true;
}
break;
case SIP.C.ACK:
tr = ua.transactions.ist[request.via_branch];
// RFC 6026 7.1
if (tr) {
if (tr.state === C.STATUS_ACCEPTED) {
return false;
}
else if (tr.state === C.STATUS_COMPLETED) {
tr.stateChanged(C.STATUS_CONFIRMED);
tr.I = SIP.Timers.setTimeout(tr.timer_I.bind(tr), SIP.Timers.TIMER_I);
return true;
}
}
// ACK to 2XX Response.
else {
return false;
}
break;
case SIP.C.CANCEL:
tr = ua.transactions.ist[request.via_branch];
if (tr) {
request.reply_sl(200);
if (tr.state === C.STATUS_PROCEEDING) {
return false;
}
else {
return true;
}
}
else {
request.reply_sl(481);
return true;
}
default:
// Non-INVITE Server Transaction RFC 3261 17.2.2
tr = ua.transactions.nist[request.via_branch];
if (tr) {
switch (tr.state) {
case C.STATUS_TRYING:
break;
case C.STATUS_PROCEEDING:
case C.STATUS_COMPLETED:
tr.transport.send(tr.last_response);
break;
}
return true;
}
break;
}
};
SIP.Transactions = {
C: C,
checkTransaction: checkTransaction,
NonInviteClientTransaction: NonInviteClientTransaction,
InviteClientTransaction: InviteClientTransaction,
AckClientTransaction: AckClientTransaction,
NonInviteServerTransaction: NonInviteServerTransaction,
InviteServerTransaction: InviteServerTransaction
};
};
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Dialog
*/
/**
* @augments SIP
* @class Class creating a SIP dialog.
* @param {SIP.RTCSession} owner
* @param {SIP.IncomingRequest|SIP.IncomingResponse} message
* @param {Enum} type UAC / UAS
* @param {Enum} state SIP.Dialog.C.STATUS_EARLY / SIP.Dialog.C.STATUS_CONFIRMED
*/
module.exports = function (SIP) {
var RequestSender = __webpack_require__(17)(SIP);
var Dialog, C = {
// Dialog states
STATUS_EARLY: 1,
STATUS_CONFIRMED: 2
};
// RFC 3261 12.1
Dialog = function (owner, message, type, state) {
var contact;
this.uac_pending_reply = false;
this.uas_pending_reply = false;
if (!message.hasHeader('contact')) {
return {
error: 'unable to create a Dialog without Contact header field'
};
}
if (message instanceof SIP.IncomingResponse) {
state = (message.status_code < 200) ? C.STATUS_EARLY : C.STATUS_CONFIRMED;
}
else {
// Create confirmed dialog if state is not defined
state = state || C.STATUS_CONFIRMED;
}
contact = message.parseHeader('contact');
// RFC 3261 12.1.1
if (type === 'UAS') {
this.id = {
call_id: message.call_id,
local_tag: message.to_tag,
remote_tag: message.from_tag,
toString: function () {
return this.call_id + this.local_tag + this.remote_tag;
}
};
this.state = state;
this.remote_seqnum = message.cseq;
this.local_uri = message.parseHeader('to').uri;
this.remote_uri = message.parseHeader('from').uri;
this.remote_target = contact.uri;
this.route_set = message.getHeaders('record-route');
this.invite_seqnum = message.cseq;
this.local_seqnum = message.cseq;
}
// RFC 3261 12.1.2
else if (type === 'UAC') {
this.id = {
call_id: message.call_id,
local_tag: message.from_tag,
remote_tag: message.to_tag,
toString: function () {
return this.call_id + this.local_tag + this.remote_tag;
}
};
this.state = state;
this.invite_seqnum = message.cseq;
this.local_seqnum = message.cseq;
this.local_uri = message.parseHeader('from').uri;
this.pracked = [];
this.remote_uri = message.parseHeader('to').uri;
this.remote_target = contact.uri;
this.route_set = message.getHeaders('record-route').reverse();
}
this.logger = owner.ua.getLogger('sip.dialog', this.id.toString());
this.owner = owner;
owner.ua.dialogs[this.id.toString()] = this;
this.logger.log('new ' + type + ' dialog created with status ' + (this.state === C.STATUS_EARLY ? 'EARLY' : 'CONFIRMED'));
owner.emit('dialog', this);
};
Dialog.prototype = {
/**
* @param {SIP.IncomingMessage} message
* @param {Enum} UAC/UAS
*/
update: function (message, type) {
this.state = C.STATUS_CONFIRMED;
this.logger.log('dialog ' + this.id.toString() + ' changed to CONFIRMED state');
if (type === 'UAC') {
// RFC 3261 13.2.2.4
this.route_set = message.getHeaders('record-route').reverse();
}
},
terminate: function () {
this.logger.log('dialog ' + this.id.toString() + ' deleted');
if (this.sessionDescriptionHandler && this.state !== C.STATUS_CONFIRMED) {
// TODO: This should call .close() on the handler when implemented
this.sessionDescriptionHandler.close();
}
delete this.owner.ua.dialogs[this.id.toString()];
},
/**
* @param {String} method request method
* @param {Object} extraHeaders extra headers
* @returns {SIP.OutgoingRequest}
*/
// RFC 3261 12.2.1.1
createRequest: function (method, extraHeaders, body) {
var cseq, request;
extraHeaders = (extraHeaders || []).slice();
if (!this.local_seqnum) {
this.local_seqnum = Math.floor(Math.random() * 10000);
}
cseq = (method === SIP.C.CANCEL || method === SIP.C.ACK) ? this.invite_seqnum : this.local_seqnum += 1;
request = new SIP.OutgoingRequest(method, this.remote_target, this.owner.ua, {
'cseq': cseq,
'call_id': this.id.call_id,
'from_uri': this.local_uri,
'from_tag': this.id.local_tag,
'to_uri': this.remote_uri,
'to_tag': this.id.remote_tag,
'route_set': this.route_set
}, extraHeaders, body);
request.dialog = this;
return request;
},
/**
* @param {SIP.IncomingRequest} request
* @returns {Boolean}
*/
// RFC 3261 12.2.2
checkInDialogRequest: function (request) {
var self = this;
if (!this.remote_seqnum) {
this.remote_seqnum = request.cseq;
}
else if (request.cseq < this.remote_seqnum) {
//Do not try to reply to an ACK request.
if (request.method !== SIP.C.ACK) {
request.reply(500);
}
if (request.cseq === this.invite_seqnum) {
return true;
}
return false;
}
switch (request.method) {
// RFC3261 14.2 Modifying an Existing Session -UAS BEHAVIOR-
case SIP.C.INVITE:
if (this.uac_pending_reply === true) {
request.reply(491);
}
else if (this.uas_pending_reply === true && request.cseq > this.remote_seqnum) {
var retryAfter = (Math.random() * 10 | 0) + 1;
request.reply(500, null, ['Retry-After:' + retryAfter]);
this.remote_seqnum = request.cseq;
return false;
}
else {
this.uas_pending_reply = true;
request.server_transaction.on('stateChanged', function stateChanged() {
if (this.state === SIP.Transactions.C.STATUS_ACCEPTED ||
this.state === SIP.Transactions.C.STATUS_COMPLETED ||
this.state === SIP.Transactions.C.STATUS_TERMINATED) {
this.removeListener('stateChanged', stateChanged);
self.uas_pending_reply = false;
}
});
}
// RFC3261 12.2.2 Replace the dialog`s remote target URI if the request is accepted
if (request.hasHeader('contact')) {
request.server_transaction.on('stateChanged', function () {
if (this.state === SIP.Transactions.C.STATUS_ACCEPTED) {
self.remote_target = request.parseHeader('contact').uri;
}
});
}
break;
case SIP.C.NOTIFY:
// RFC6665 3.2 Replace the dialog`s remote target URI if the request is accepted
if (request.hasHeader('contact')) {
request.server_transaction.on('stateChanged', function () {
if (this.state === SIP.Transactions.C.STATUS_COMPLETED) {
self.remote_target = request.parseHeader('contact').uri;
}
});
}
break;
}
if (request.cseq > this.remote_seqnum) {
this.remote_seqnum = request.cseq;
}
return true;
},
sendRequest: function (applicant, method, options) {
options = options || {};
var extraHeaders = (options.extraHeaders || []).slice();
var body = null;
if (options.body) {
if (options.body.body) {
body = options.body;
}
else {
body = {};
body.body = options.body;
if (options.contentType) {
body.contentType = options.contentType;
}
}
}
var request = this.createRequest(method, extraHeaders, body), request_sender = new RequestSender(this, applicant, request);
request_sender.send();
return request;
},
/**
* @param {SIP.IncomingRequest} request
*/
receiveRequest: function (request) {
//Check in-dialog request
if (!this.checkInDialogRequest(request)) {
return;
}
this.owner.receiveRequest(request);
}
};
Dialog.C = C;
SIP.Dialog = Dialog;
};
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview In-Dialog Request Sender
*/
/**
* @augments SIP.Dialog
* @class Class creating an In-dialog request sender.
* @param {SIP.Dialog} dialog
* @param {Object} applicant
* @param {SIP.OutgoingRequest} request
*/
/**
* @fileoverview in-Dialog Request Sender
*/
module.exports = function (SIP) {
var RequestSender;
RequestSender = function (dialog, applicant, request) {
this.dialog = dialog;
this.applicant = applicant;
this.request = request;
// RFC3261 14.1 Modifying an Existing Session. UAC Behavior.
this.reattempt = false;
this.reattemptTimer = null;
};
RequestSender.prototype = {
send: function () {
var self = this, request_sender = new SIP.RequestSender(this, this.dialog.owner.ua);
request_sender.send();
// RFC3261 14.2 Modifying an Existing Session -UAC BEHAVIOR-
if (this.request.method === SIP.C.INVITE && request_sender.clientTransaction.state !== SIP.Transactions.C.STATUS_TERMINATED) {
this.dialog.uac_pending_reply = true;
request_sender.clientTransaction.on('stateChanged', function stateChanged() {
if (this.state === SIP.Transactions.C.STATUS_ACCEPTED ||
this.state === SIP.Transactions.C.STATUS_COMPLETED ||
this.state === SIP.Transactions.C.STATUS_TERMINATED) {
this.removeListener('stateChanged', stateChanged);
self.dialog.uac_pending_reply = false;
}
});
}
},
onRequestTimeout: function () {
this.applicant.onRequestTimeout();
},
onTransportError: function () {
this.applicant.onTransportError();
},
receiveResponse: function (response) {
var self = this;
// RFC3261 12.2.1.2 408 or 481 is received for a request within a dialog.
if (response.status_code === 408 || response.status_code === 481) {
this.applicant.onDialogError(response);
}
else if (response.method === SIP.C.INVITE && response.status_code === 491) {
if (this.reattempt) {
this.applicant.receiveResponse(response);
}
else {
this.request.cseq.value = this.dialog.local_seqnum += 1;
this.reattemptTimer = SIP.Timers.setTimeout(function () {
if (self.applicant.owner.status !== SIP.Session.C.STATUS_TERMINATED) {
self.reattempt = true;
self.request_sender.send();
}
}, this.getReattemptTimeout());
}
}
else {
this.applicant.receiveResponse(response);
}
}
};
return RequestSender;
};
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview Request Sender
*/
/**
* @augments SIP
* @class Class creating a request sender.
* @param {Object} applicant
* @param {SIP.UA} ua
*/
module.exports = function (SIP) {
var RequestSender;
RequestSender = function (applicant, ua) {
this.logger = ua.getLogger('sip.requestsender');
this.ua = ua;
this.applicant = applicant;
this.method = applicant.request.method;
this.request = applicant.request;
this.credentials = null;
this.challenged = false;
this.staled = false;
// If ua is in closing process or even closed just allow sending Bye and ACK
if (ua.status === SIP.UA.C.STATUS_USER_CLOSED && (this.method !== SIP.C.BYE || this.method !== SIP.C.ACK)) {
this.onTransportError();
}
};
/**
* Create the client transaction and send the message.
*/
RequestSender.prototype = {
send: function () {
switch (this.method) {
case "INVITE":
this.clientTransaction = new SIP.Transactions.InviteClientTransaction(this, this.request, this.ua.transport);
break;
case "ACK":
this.clientTransaction = new SIP.Transactions.AckClientTransaction(this, this.request, this.ua.transport);
break;
default:
this.clientTransaction = new SIP.Transactions.NonInviteClientTransaction(this, this.request, this.ua.transport);
}
this.clientTransaction.send();
return this.clientTransaction;
},
/**
* Callback fired when receiving a request timeout error from the client transaction.
* To be re-defined by the applicant.
* @event
*/
onRequestTimeout: function () {
this.applicant.onRequestTimeout();
},
/**
* Callback fired when receiving a transport error from the client transaction.
* To be re-defined by the applicant.
* @event
*/
onTransportError: function () {
this.applicant.onTransportError();
},
/**
* Called from client transaction when receiving a correct response to the request.
* Authenticate request if needed or pass the response back to the applicant.
* @param {SIP.IncomingResponse} response
*/
receiveResponse: function (response) {
var cseq, challenge, authorization_header_name, status_code = response.status_code;
/*
* Authentication
* Authenticate once. _challenged_ flag used to avoid infinite authentications.
*/
if (status_code === 401 || status_code === 407) {
// Get and parse the appropriate WWW-Authenticate or Proxy-Authenticate header.
if (response.status_code === 401) {
challenge = response.parseHeader('www-authenticate');
authorization_header_name = 'authorization';
}
else {
challenge = response.parseHeader('proxy-authenticate');
authorization_header_name = 'proxy-authorization';
}
// Verify it seems a valid challenge.
if (!challenge) {
this.logger.warn(response.status_code + ' with wrong or missing challenge, cannot authenticate');
this.applicant.receiveResponse(response);
return;
}
if (!this.challenged || (!this.staled && challenge.stale === true)) {
if (!this.credentials) {
this.credentials = this.ua.configuration.authenticationFactory(this.ua);
}
// Verify that the challenge is really valid.
if (!this.credentials.authenticate(this.request, challenge)) {
this.applicant.receiveResponse(response);
return;
}
this.challenged = true;
if (challenge.stale) {
this.staled = true;
}
if (response.method === SIP.C.REGISTER) {
cseq = this.applicant.cseq += 1;
}
else if (this.request.dialog) {
cseq = this.request.dialog.local_seqnum += 1;
}
else {
cseq = this.request.cseq + 1;
this.request.cseq = cseq;
}
this.request.setHeader('cseq', cseq + ' ' + this.method);
this.request.setHeader(authorization_header_name, this.credentials.toString());
this.send();
}
else {
this.applicant.receiveResponse(response);
}
}
else {
this.applicant.receiveResponse(response);
}
}
};
SIP.RequestSender = RequestSender;
};
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = function (SIP) {
var RegisterContext;
RegisterContext = function (ua) {
var params = {}, regId = 1;
this.registrar = ua.configuration.registrarServer;
this.expires = ua.configuration.registerExpires;
// Contact header
this.contact = ua.contact.toString();
if (regId) {
this.contact += ';reg-id=' + regId;
this.contact += ';+sip.instance="<urn:uuid:' + ua.configuration.instanceId + '>"';
}
// Call-ID and CSeq values RFC3261 10.2
this.call_id = SIP.Utils.createRandomToken(22);
this.cseq = Math.floor(Math.random() * 10000);
this.to_uri = ua.configuration.uri;
params.to_uri = this.to_uri;
params.to_displayName = ua.configuration.displayName;
params.call_id = this.call_id;
params.cseq = this.cseq;
// Extends ClientContext
SIP.Utils.augment(this, SIP.ClientContext, [ua, 'REGISTER', this.registrar, { params: params }]);
this.registrationTimer = null;
this.registrationExpiredTimer = null;
// Set status
this.registered = false;
this.logger = ua.getLogger('sip.registercontext');
ua.on('transportCreated', function (transport) {
transport.on('disconnected', this.onTransportDisconnected.bind(this));
}.bind(this));
};
RegisterContext.prototype = Object.create({}, {
register: { writable: true, value: function register(options) {
var self = this, extraHeaders;
// Handle Options
this.options = options || {};
extraHeaders = (this.options.extraHeaders || []).slice();
extraHeaders.push('Contact: ' + this.contact + ';expires=' + this.expires);
extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
// Save original extraHeaders to be used in .close
this.closeHeaders = this.options.closeWithHeaders ?
(this.options.extraHeaders || []).slice() : [];
this.receiveResponse = function (response) {
var contact, expires, contacts = response.getHeaders('contact').length, cause;
// Discard responses to older REGISTER/un-REGISTER requests.
if (response.cseq !== this.cseq) {
return;
}
// Clear registration timer
if (this.registrationTimer !== null) {
SIP.Timers.clearTimeout(this.registrationTimer);
this.registrationTimer = null;
}
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
this.emit('progress', response);
break;
case /^2[0-9]{2}$/.test(response.status_code):
this.emit('accepted', response);
if (response.hasHeader('expires')) {
expires = response.getHeader('expires');
}
if (this.registrationExpiredTimer !== null) {
SIP.Timers.clearTimeout(this.registrationExpiredTimer);
this.registrationExpiredTimer = null;
}
// Search the Contact pointing to us and update the expires value accordingly.
if (!contacts) {
this.logger.warn('no Contact header in response to REGISTER, response ignored');
break;
}
while (contacts--) {
contact = response.parseHeader('contact', contacts);
if (contact.uri.user === this.ua.contact.uri.user) {
expires = contact.getParam('expires');
break;
}
else {
contact = null;
}
}
if (!contact) {
this.logger.warn('no Contact header pointing to us, response ignored');
break;
}
if (!expires) {
expires = this.expires;
}
// Re-Register before the expiration interval has elapsed.
// For that, decrease the expires value. ie: 3 seconds
this.registrationTimer = SIP.Timers.setTimeout(function () {
self.registrationTimer = null;
self.register(self.options);
}, (expires * 1000) - 3000);
this.registrationExpiredTimer = SIP.Timers.setTimeout(function () {
self.logger.warn('registration expired');
if (self.registered) {
self.unregistered(null, SIP.C.causes.EXPIRES);
}
}, expires * 1000);
//Save gruu values
if (contact.hasParam('temp-gruu')) {
this.ua.contact.temp_gruu = SIP.URI.parse(contact.getParam('temp-gruu').replace(/"/g, ''));
}
if (contact.hasParam('pub-gruu')) {
this.ua.contact.pub_gruu = SIP.URI.parse(contact.getParam('pub-gruu').replace(/"/g, ''));
}
this.registered = true;
this.emit('registered', response || null);
break;
// Interval too brief RFC3261 10.2.8
case /^423$/.test(response.status_code):
if (response.hasHeader('min-expires')) {
// Increase our registration interval to the suggested minimum
this.expires = response.getHeader('min-expires');
// Attempt the registration again immediately
this.register(this.options);
}
else { //This response MUST contain a Min-Expires header field
this.logger.warn('423 response received for REGISTER without Min-Expires');
this.registrationFailure(response, SIP.C.causes.SIP_FAILURE_CODE);
}
break;
default:
cause = SIP.Utils.sipErrorCause(response.status_code);
this.registrationFailure(response, cause);
}
};
this.onRequestTimeout = function () {
this.registrationFailure(null, SIP.C.causes.REQUEST_TIMEOUT);
};
this.onTransportError = function () {
this.registrationFailure(null, SIP.C.causes.CONNECTION_ERROR);
};
this.cseq++;
this.request.cseq = this.cseq;
this.request.setHeader('cseq', this.cseq + ' REGISTER');
this.request.extraHeaders = extraHeaders;
this.send();
} },
registrationFailure: { writable: true, value: function registrationFailure(response, cause) {
this.emit('failed', response || null, cause || null);
} },
onTransportDisconnected: { writable: true, value: function onTransportDisconnected() {
this.registered_before = this.registered;
if (this.registrationTimer !== null) {
SIP.Timers.clearTimeout(this.registrationTimer);
this.registrationTimer = null;
}
if (this.registrationExpiredTimer !== null) {
SIP.Timers.clearTimeout(this.registrationExpiredTimer);
this.registrationExpiredTimer = null;
}
if (this.registered) {
this.unregistered(null, SIP.C.causes.CONNECTION_ERROR);
}
} },
onTransportConnected: { writable: true, value: function onTransportConnected() {
this.register(this.options);
} },
close: { writable: true, value: function close() {
var options = {
all: false,
extraHeaders: this.closeHeaders
};
this.registered_before = this.registered;
if (this.registered) {
this.unregister(options);
}
} },
unregister: { writable: true, value: function unregister(options) {
var extraHeaders;
options = options || {};
if (!this.registered && !options.all) {
this.logger.warn('Already unregistered, but sending an unregister anyways.');
}
extraHeaders = (options.extraHeaders || []).slice();
this.registered = false;
// Clear the registration timer.
if (this.registrationTimer !== null) {
SIP.Timers.clearTimeout(this.registrationTimer);
this.registrationTimer = null;
}
if (options.all) {
extraHeaders.push('Contact: *');
extraHeaders.push('Expires: 0');
}
else {
extraHeaders.push('Contact: ' + this.contact + ';expires=0');
}
this.receiveResponse = function (response) {
var cause;
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
this.emit('progress', response);
break;
case /^2[0-9]{2}$/.test(response.status_code):
this.emit('accepted', response);
if (this.registrationExpiredTimer !== null) {
SIP.Timers.clearTimeout(this.registrationExpiredTimer);
this.registrationExpiredTimer = null;
}
this.unregistered(response);
break;
default:
cause = SIP.Utils.sipErrorCause(response.status_code);
this.unregistered(response, cause);
}
};
this.onRequestTimeout = function () {
// Not actually unregistered...
//this.unregistered(null, SIP.C.causes.REQUEST_TIMEOUT);
};
this.cseq++;
this.request.cseq = this.cseq;
this.request.setHeader('cseq', this.cseq + ' REGISTER');
this.request.extraHeaders = extraHeaders;
this.send();
} },
unregistered: { writable: true, value: function unregistered(response, cause) {
this.registered = false;
this.emit('unregistered', response || null, cause || null);
} }
});
SIP.RegisterContext = RegisterContext;
};
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* eslint-disable */
/**
* @fileoverview SessionDescriptionHandler
*/
/* SessionDescriptionHandler
* @class PeerConnection helper Class.
* @param {SIP.Session} session
* @param {Object} [options]
*/
module.exports = function (EventEmitter) {
var SessionDescriptionHandler = function () { };
SessionDescriptionHandler.prototype = Object.create(EventEmitter.prototype, {
/**
* Destructor
*/
close: { value: function close() { } },
/**
* Gets the local description from the underlying media implementation
* @param {Object} [options] Options object to be used by getDescription
* @param {Array} [modifiers] Array with one time use description modifiers
* @returns {Promise} Promise that resolves with the local description to be used for the session
*/
getDescription: { value: function getDescription(options, modifiers) { } },
/**
* Check if the Session Description Handler can handle the Content-Type described by a SIP Message
* @param {String} contentType The content type that is in the SIP Message
* @returns {boolean}
*/
hasDescription: { value: function hasSessionDescription(contentType) { } },
/**
* The modifier that should be used when the session would like to place the call on hold
* @param {String} [sdp] The description that will be modified
* @returns {Promise} Promise that resolves with modified SDP
*/
holdModifier: { value: function holdModifier(sdp) { } },
/**
* Set the remote description to the underlying media implementation
* @param {String} sessionDescription The description provided by a SIP message to be set on the media implementation
* @param {Object} [options] Options object to be used by setDescription
* @param {Array} [modifiers] Array with one time use description modifiers
* @returns {Promise} Promise that resolves once the description is set
*/
setDescription: { value: function setDescription(sessionDescription, options, modifiers) { } },
/**
* Send DTMF via RTP (RFC 4733)
* @param {String} tones A string containing DTMF digits
* @param {Object} [options] Options object to be used by sendDtmf
* @returns {boolean} true if DTMF send is successful, false otherwise
*/
sendDtmf: { value: function sendDtmf(tones, options) { } },
/**
* Get the direction of the session description
* @returns {String} direction of the description
*/
getDirection: { value: function getDirection() { } },
});
return SessionDescriptionHandler;
};
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = function (SIP) {
var ClientContext;
ClientContext = function (ua, method, target, options) {
var originalTarget = target;
// Validate arguments
if (target === undefined) {
throw new TypeError('Not enough arguments');
}
this.ua = ua;
this.logger = ua.getLogger('sip.clientcontext');
this.method = method;
target = ua.normalizeTarget(target);
if (!target) {
throw new TypeError('Invalid target: ' + originalTarget);
}
/* Options
* - extraHeaders
* - params
* - contentType
* - body
*/
options = Object.create(options || Object.prototype);
options.extraHeaders = (options.extraHeaders || []).slice();
// Build the request
this.request = new SIP.OutgoingRequest(this.method, target, this.ua, options.params, options.extraHeaders);
if (options.body) {
this.body = {};
this.body.body = options.body;
if (options.contentType) {
this.body.contentType = options.contentType;
}
this.request.body = this.body;
}
/* Set other properties from the request */
this.localIdentity = this.request.from;
this.remoteIdentity = this.request.to;
this.data = {};
};
ClientContext.prototype = Object.create(SIP.EventEmitter.prototype);
ClientContext.prototype.send = function () {
(new SIP.RequestSender(this, this.ua)).send();
return this;
};
ClientContext.prototype.cancel = function (options) {
options = options || {};
options.extraHeaders = (options.extraHeaders || []).slice();
var cancel_reason = SIP.Utils.getCancelReason(options.status_code, options.reason_phrase);
this.request.cancel(cancel_reason, options.extraHeaders);
this.emit('cancel');
};
ClientContext.prototype.receiveResponse = function (response) {
var cause = SIP.Utils.getReasonPhrase(response.status_code);
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
this.emit('progress', response, cause);
break;
case /^2[0-9]{2}$/.test(response.status_code):
if (this.ua.applicants[this]) {
delete this.ua.applicants[this];
}
this.emit('accepted', response, cause);
break;
default:
if (this.ua.applicants[this]) {
delete this.ua.applicants[this];
}
this.emit('rejected', response, cause);
this.emit('failed', response, cause);
break;
}
};
ClientContext.prototype.onRequestTimeout = function () {
this.emit('failed', null, SIP.C.causes.REQUEST_TIMEOUT);
};
ClientContext.prototype.onTransportError = function () {
this.emit('failed', null, SIP.C.causes.CONNECTION_ERROR);
};
SIP.ClientContext = ClientContext;
};
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = function (SIP) {
var ServerContext;
ServerContext = function (ua, request) {
this.ua = ua;
this.logger = ua.getLogger('sip.servercontext');
this.request = request;
if (request.method === SIP.C.INVITE) {
this.transaction = new SIP.Transactions.InviteServerTransaction(request, ua);
}
else {
this.transaction = new SIP.Transactions.NonInviteServerTransaction(request, ua);
}
if (request.body) {
this.body = request.body;
}
if (request.hasHeader('Content-Type')) {
this.contentType = request.getHeader('Content-Type');
}
this.method = request.method;
this.data = {};
this.localIdentity = request.to;
this.remoteIdentity = request.from;
if (request.hasHeader('P-Asserted-Identity')) {
this.assertedIdentity = new SIP.NameAddrHeader.parse(request.getHeader('P-Asserted-Identity'));
}
};
ServerContext.prototype = Object.create(SIP.EventEmitter.prototype);
ServerContext.prototype.progress = function (options) {
options = Object.create(options || Object.prototype);
options.statusCode || (options.statusCode = 180);
options.minCode = 100;
options.maxCode = 199;
options.events = ['progress'];
return this.reply(options);
};
ServerContext.prototype.accept = function (options) {
options = Object.create(options || Object.prototype);
options.statusCode || (options.statusCode = 200);
options.minCode = 200;
options.maxCode = 299;
options.events = ['accepted'];
return this.reply(options);
};
ServerContext.prototype.reject = function (options) {
options = Object.create(options || Object.prototype);
options.statusCode || (options.statusCode = 480);
options.minCode = 300;
options.maxCode = 699;
options.events = ['rejected', 'failed'];
return this.reply(options);
};
ServerContext.prototype.reply = function (options) {
options = options || {}; // This is okay, so long as we treat options as read-only in this method
var statusCode = options.statusCode || 100, minCode = options.minCode || 100, maxCode = options.maxCode || 699, reasonPhrase = SIP.Utils.getReasonPhrase(statusCode, options.reasonPhrase), extraHeaders = options.extraHeaders || [], body = options.body, events = options.events || [], response;
if (statusCode < minCode || statusCode > maxCode) {
throw new TypeError('Invalid statusCode: ' + statusCode);
}
response = this.request.reply(statusCode, reasonPhrase, extraHeaders, body);
events.forEach(function (event) {
this.emit(event, response, reasonPhrase);
}, this);
return this;
};
ServerContext.prototype.onRequestTimeout = function () {
this.emit('failed', null, SIP.C.causes.REQUEST_TIMEOUT);
};
ServerContext.prototype.onTransportError = function () {
this.emit('failed', null, SIP.C.causes.CONNECTION_ERROR);
};
SIP.ServerContext = ServerContext;
};
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = function (SIP) {
var DTMF = __webpack_require__(24)(SIP);
var Session, InviteServerContext, InviteClientContext, ReferServerContext, ReferClientContext, C = {
//Session states
STATUS_NULL: 0,
STATUS_INVITE_SENT: 1,
STATUS_1XX_RECEIVED: 2,
STATUS_INVITE_RECEIVED: 3,
STATUS_WAITING_FOR_ANSWER: 4,
STATUS_ANSWERED: 5,
STATUS_WAITING_FOR_PRACK: 6,
STATUS_WAITING_FOR_ACK: 7,
STATUS_CANCELED: 8,
STATUS_TERMINATED: 9,
STATUS_ANSWERED_WAITING_FOR_PRACK: 10,
STATUS_EARLY_MEDIA: 11,
STATUS_CONFIRMED: 12
};
/*
* @param {function returning SIP.sessionDescriptionHandler} [sessionDescriptionHandlerFactory]
* (See the documentation for the sessionDescriptionHandlerFactory argument of the UA constructor.)
*/
Session = function (sessionDescriptionHandlerFactory) {
this.status = C.STATUS_NULL;
this.dialog = null;
this.pendingReinvite = false;
this.earlyDialogs = {};
if (!sessionDescriptionHandlerFactory) {
throw new SIP.Exceptions.SessionDescriptionHandlerMissing('A session description handler is required for the session to function');
}
this.sessionDescriptionHandlerFactory = sessionDescriptionHandlerFactory;
this.hasOffer = false;
this.hasAnswer = false;
// Session Timers
this.timers = {
ackTimer: null,
expiresTimer: null,
invite2xxTimer: null,
userNoAnswerTimer: null,
rel1xxTimer: null,
prackTimer: null
};
// Session info
this.startTime = null;
this.endTime = null;
this.tones = null;
// Hold state
this.local_hold = false;
this.early_sdp = null;
this.rel100 = SIP.C.supported.UNSUPPORTED;
};
Session.prototype = {
dtmf: function (tones, options) {
var tone, dtmfs = [], self = this, dtmfType = this.ua.configuration.dtmfType;
options = options || {};
if (tones === undefined) {
throw new TypeError('Not enough arguments');
}
// Check Session Status
if (this.status !== C.STATUS_CONFIRMED && this.status !== C.STATUS_WAITING_FOR_ACK) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
// Check tones
if ((typeof tones !== 'string' && typeof tones !== 'number') || !tones.toString().match(/^[0-9A-D#*,]+$/i)) {
throw new TypeError('Invalid tones: ' + tones);
}
var sendDTMF = function () {
var dtmf, timeout;
if (self.status === C.STATUS_TERMINATED || !self.tones || self.tones.length === 0) {
// Stop sending DTMF
self.tones = null;
return this;
}
dtmf = self.tones.shift();
if (tone === ',') {
timeout = 2000;
}
else {
dtmf.on('failed', function () { self.tones = null; });
dtmf.send(options);
timeout = dtmf.duration + dtmf.interToneGap;
}
// Set timeout for the next tone
SIP.Timers.setTimeout(sendDTMF, timeout);
};
tones = tones.toString();
if (dtmfType === SIP.C.dtmfType.RTP) {
var sent = this.sessionDescriptionHandler.sendDtmf(tones, options);
if (!sent) {
this.logger.warn("Attempt to use dtmfType 'RTP' has failed, falling back to INFO packet method");
dtmfType = SIP.C.dtmfType.INFO;
}
}
if (dtmfType === SIP.C.dtmfType.INFO) {
tones = tones.split('');
while (tones.length > 0) {
dtmfs.push(new DTMF(this, tones.shift(), options));
}
if (this.tones) {
// Tones are already queued, just add to the queue
this.tones = this.tones.concat(dtmfs);
return this;
}
this.tones = dtmfs;
sendDTMF();
}
return this;
},
bye: function (options) {
options = Object.create(options || Object.prototype);
var statusCode = options.statusCode;
// Check Session Status
if (this.status === C.STATUS_TERMINATED) {
this.logger.error('Error: Attempted to send BYE in a terminated session.');
return this;
}
this.logger.log('terminating Session');
if (statusCode && (statusCode < 200 || statusCode >= 700)) {
throw new TypeError('Invalid statusCode: ' + statusCode);
}
options.receiveResponse = function () { };
return this.
sendRequest(SIP.C.BYE, options).
terminated();
},
refer: function (target, options) {
options = options || {};
// Check Session Status
if (this.status !== C.STATUS_CONFIRMED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.referContext = new SIP.ReferClientContext(this.ua, this, target, options);
this.emit('referRequested', this.referContext);
this.referContext.refer(options);
},
sendRequest: function (method, options) {
options = options || {};
var self = this;
var request = new SIP.OutgoingRequest(method, this.dialog.remote_target, this.ua, {
cseq: options.cseq || (this.dialog.local_seqnum += 1),
call_id: this.dialog.id.call_id,
from_uri: this.dialog.local_uri,
from_tag: this.dialog.id.local_tag,
to_uri: this.dialog.remote_uri,
to_tag: this.dialog.id.remote_tag,
route_set: this.dialog.route_set,
statusCode: options.statusCode,
reasonPhrase: options.reasonPhrase
}, options.extraHeaders || [], options.body);
new SIP.RequestSender({
request: request,
onRequestTimeout: function () {
self.onRequestTimeout();
},
onTransportError: function () {
self.onTransportError();
},
receiveResponse: options.receiveResponse || function (response) {
self.receiveNonInviteResponse(response);
}
}, this.ua).send();
// Emit the request event
this.emit(method.toLowerCase(), request);
return this;
},
close: function () {
var idx;
if (this.status === C.STATUS_TERMINATED) {
return this;
}
this.logger.log('closing INVITE session ' + this.id);
// 1st Step. Terminate media.
if (this.sessionDescriptionHandler) {
this.sessionDescriptionHandler.close();
}
// 2nd Step. Terminate signaling.
// Clear session timers
for (idx in this.timers) {
SIP.Timers.clearTimeout(this.timers[idx]);
}
// Terminate dialogs
// Terminate confirmed dialog
if (this.dialog) {
this.dialog.terminate();
delete this.dialog;
}
// Terminate early dialogs
for (idx in this.earlyDialogs) {
this.earlyDialogs[idx].terminate();
delete this.earlyDialogs[idx];
}
this.status = C.STATUS_TERMINATED;
this.ua.transport.removeListener("transportError", this.errorListener);
delete this.ua.sessions[this.id];
return this;
},
createDialog: function (message, type, early) {
var dialog, early_dialog, local_tag = message[(type === 'UAS') ? 'to_tag' : 'from_tag'], remote_tag = message[(type === 'UAS') ? 'from_tag' : 'to_tag'], id = message.call_id + local_tag + remote_tag;
early_dialog = this.earlyDialogs[id];
// Early Dialog
if (early) {
if (early_dialog) {
return true;
}
else {
early_dialog = new SIP.Dialog(this, message, type, SIP.Dialog.C.STATUS_EARLY);
// Dialog has been successfully created.
if (early_dialog.error) {
this.logger.error(early_dialog.error);
this.failed(message, SIP.C.causes.INTERNAL_ERROR);
return false;
}
else {
this.earlyDialogs[id] = early_dialog;
return true;
}
}
}
// Confirmed Dialog
else {
// In case the dialog is in _early_ state, update it
if (early_dialog) {
early_dialog.update(message, type);
this.dialog = early_dialog;
delete this.earlyDialogs[id];
for (var dia in this.earlyDialogs) {
this.earlyDialogs[dia].terminate();
delete this.earlyDialogs[dia];
}
return true;
}
// Otherwise, create a _confirmed_ dialog
dialog = new SIP.Dialog(this, message, type);
if (dialog.error) {
this.logger.error(dialog.error);
this.failed(message, SIP.C.causes.INTERNAL_ERROR);
return false;
}
else {
this.to_tag = message.to_tag;
this.dialog = dialog;
return true;
}
}
},
/**
* Hold
*/
hold: function (options, modifiers) {
if (this.status !== C.STATUS_WAITING_FOR_ACK && this.status !== C.STATUS_CONFIRMED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
if (this.local_hold) {
this.logger.log('Session is already on hold, cannot put it on hold again');
return;
}
options = options || {};
options.modifiers = modifiers || [];
options.modifiers.push(this.sessionDescriptionHandler.holdModifier);
this.local_hold = true;
this.sendReinvite(options);
},
/**
* Unhold
*/
unhold: function (options, modifiers) {
if (this.status !== C.STATUS_WAITING_FOR_ACK && this.status !== C.STATUS_CONFIRMED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
if (!this.local_hold) {
this.logger.log('Session is not on hold, cannot unhold it');
return;
}
options = options || {};
if (modifiers) {
options.modifiers = modifiers;
}
this.local_hold = false;
this.sendReinvite(options);
},
reinvite: function (options, modifiers) {
options = options || {};
if (modifiers) {
options.modifiers = modifiers;
}
return this.sendReinvite(options);
},
/**
* In dialog INVITE Reception
* @private
*/
receiveReinvite: function (request) {
var self = this, promise;
// TODO: Should probably check state of the session
self.emit('reinvite', this);
if (request.hasHeader('P-Asserted-Identity')) {
this.assertedIdentity = new SIP.NameAddrHeader.parse(request.getHeader('P-Asserted-Identity'));
}
// Invite w/o SDP
if (request.getHeader('Content-Length') === '0' && !request.getHeader('Content-Type')) {
promise = this.sessionDescriptionHandler.getDescription(this.sessionDescriptionHandlerOptions, this.modifiers);
// Invite w/ SDP
}
else if (this.sessionDescriptionHandler.hasDescription(request.getHeader('Content-Type'))) {
promise = this.sessionDescriptionHandler.setDescription(request.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(this.sessionDescriptionHandler.getDescription.bind(this.sessionDescriptionHandler, this.sessionDescriptionHandlerOptions, this.modifiers));
// Bad Packet (should never get hit)
}
else {
request.reply(415);
this.emit('reinviteFailed', self);
return;
}
this.receiveRequest = function (request) {
if (request.method === SIP.C.ACK && this.status === C.STATUS_WAITING_FOR_ACK) {
if (this.sessionDescriptionHandler.hasDescription(request.getHeader('Content-Type'))) {
this.hasAnswer = true;
this.sessionDescriptionHandler.setDescription(request.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(function () {
SIP.Timers.clearTimeout(this.timers.ackTimer);
SIP.Timers.clearTimeout(this.timers.invite2xxTimer);
this.status = C.STATUS_CONFIRMED;
this.emit('confirmed', request);
}.bind(this));
}
else {
SIP.Timers.clearTimeout(this.timers.ackTimer);
SIP.Timers.clearTimeout(this.timers.invite2xxTimer);
this.status = C.STATUS_CONFIRMED;
this.emit('confirmed', request);
}
}
else {
SIP.Session.prototype.receiveRequest.apply(this, [request]);
}
}.bind(this);
promise.catch(function onFailure(e) {
var statusCode;
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
statusCode = 500;
}
else if (e instanceof SIP.Exceptions.RenegotiationError) {
self.emit('renegotiationError', e);
self.logger.warn(e);
statusCode = 488;
}
else {
self.logger.error(e);
statusCode = 488;
}
request.reply(statusCode);
self.emit('reinviteFailed', self);
// TODO: This could be better
throw e;
})
.then(function (description) {
var extraHeaders = ['Contact: ' + self.contact];
request.reply(200, null, extraHeaders, description, function () {
self.status = C.STATUS_WAITING_FOR_ACK;
self.setACKTimer();
self.emit('reinviteAccepted', self);
});
});
},
sendReinvite: function (options) {
if (this.pendingReinvite) {
this.logger.warn('Reinvite in progress. Please wait until complete, then try again.');
return;
}
this.pendingReinvite = true;
options = options || {};
options.modifiers = options.modifiers || [];
var self = this, extraHeaders = (options.extraHeaders || []).slice();
extraHeaders.push('Contact: ' + this.contact);
extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
this.sessionDescriptionHandler.getDescription(options.sessionDescriptionHandlerOptions, options.modifiers)
.then(function (description) {
self.sendRequest(SIP.C.INVITE, {
extraHeaders: extraHeaders,
body: description,
receiveResponse: self.receiveReinviteResponse.bind(self)
});
}).catch(function onFailure(e) {
if (e instanceof SIP.Exceptions.RenegotiationError) {
self.pendingReinvite = false;
self.emit('renegotiationError', e);
self.logger.warn('Renegotiation Error');
self.logger.warn(e);
return;
}
self.logger.error('sessionDescriptionHandler error');
self.logger.error(e);
});
},
receiveRequest: function (request) {
switch (request.method) {
case SIP.C.BYE:
request.reply(200);
if (this.status === C.STATUS_CONFIRMED) {
this.emit('bye', request);
this.terminated(request, SIP.C.causes.BYE);
}
break;
case SIP.C.INVITE:
if (this.status === C.STATUS_CONFIRMED) {
this.logger.log('re-INVITE received');
this.receiveReinvite(request);
}
break;
case SIP.C.INFO:
if (this.status === C.STATUS_CONFIRMED || this.status === C.STATUS_WAITING_FOR_ACK) {
if (this.onInfo) {
return this.onInfo(request);
}
var body, tone, duration, contentType = request.getHeader('content-type'), reg_tone = /^(Signal\s*?=\s*?)([0-9A-D#*]{1})(\s)?.*/, reg_duration = /^(Duration\s?=\s?)([0-9]{1,4})(\s)?.*/;
if (contentType) {
if (contentType.match(/^application\/dtmf-relay/i)) {
if (request.body) {
body = request.body.split('\r\n', 2);
if (body.length === 2) {
if (reg_tone.test(body[0])) {
tone = body[0].replace(reg_tone, "$2");
}
if (reg_duration.test(body[1])) {
duration = parseInt(body[1].replace(reg_duration, "$2"), 10);
}
}
}
new DTMF(this, tone, { duration: duration }).init_incoming(request);
}
else {
request.reply(415, null, ["Accept: application/dtmf-relay"]);
}
}
}
break;
case SIP.C.REFER:
if (this.status === C.STATUS_CONFIRMED) {
this.logger.log('REFER received');
this.referContext = new SIP.ReferServerContext(this.ua, request);
var hasReferListener = this.listeners('referRequested').length;
if (hasReferListener) {
this.emit('referRequested', this.referContext);
}
else {
this.logger.log('No referRequested listeners, automatically accepting and following the refer');
var options = { followRefer: true };
if (this.passedOptions) {
options.inviteOptions = this.passedOptions;
}
this.referContext.accept(options, this.modifiers);
}
}
break;
case SIP.C.NOTIFY:
if ((this.referContext && this.referContext instanceof SIP.ReferClientContext) && request.hasHeader('event') && /^refer(;.*)?$/.test(request.getHeader('event'))) {
this.referContext.receiveNotify(request);
return;
}
request.reply(200, 'OK');
this.emit('notify', request);
break;
}
},
/**
* Reception of Response for in-dialog INVITE
* @private
*/
receiveReinviteResponse: function (response) {
var self = this;
if (this.status === C.STATUS_TERMINATED) {
this.logger.error('Received reinvite response, but in STATUS_TERMINATED');
// TODO: Do we need to send a SIP response?
return;
}
if (!this.pendingReinvite) {
this.logger.error('Received reinvite response, but have no pending reinvite');
// TODO: Do we need to send a SIP response?
return;
}
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
break;
case /^2[0-9]{2}$/.test(response.status_code):
this.status = C.STATUS_CONFIRMED;
// 17.1.1.1 - For each final response that is received at the client transaction, the client transaction sends an ACK,
this.emit("ack", response.transaction.sendACK());
this.pendingReinvite = false;
// TODO: All of these timers should move into the Transaction layer
SIP.Timers.clearTimeout(self.timers.invite2xxTimer);
if (!this.sessionDescriptionHandler.hasDescription(response.getHeader('Content-Type'))) {
this.logger.error('2XX response received to re-invite but did not have a description');
this.emit('reinviteFailed', self);
this.emit('renegotiationError', new SIP.Exceptions.RenegotiationError('2XX response received to re-invite but did not have a description'));
break;
}
this.sessionDescriptionHandler.setDescription(response.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.catch(function onFailure(e) {
self.logger.error('Could not set the description in 2XX response');
self.logger.error(e);
self.emit('reinviteFailed', self);
self.emit('renegotiationError', e);
self.sendRequest(SIP.C.BYE, {
extraHeaders: ['Reason: ' + SIP.Utils.getReasonHeaderValue(488, 'Not Acceptable Here')]
});
self.terminated(null, SIP.C.causes.INCOMPATIBLE_SDP);
}).then(function () {
self.emit('reinviteAccepted', self);
});
break;
default:
this.pendingReinvite = false;
this.logger.log('Received a non 1XX or 2XX response to a re-invite');
this.emit('reinviteFailed', self);
this.emit('renegotiationError', new SIP.Exceptions.RenegotiationError('Invalid response to a re-invite'));
}
},
acceptAndTerminate: function (response, status_code, reason_phrase) {
var extraHeaders = [];
if (status_code) {
extraHeaders.push('Reason: ' + SIP.Utils.getReasonHeaderValue(status_code, reason_phrase));
}
// An error on dialog creation will fire 'failed' event
if (this.dialog || this.createDialog(response, 'UAC')) {
this.emit("ack", response.transaction.sendACK());
this.sendRequest(SIP.C.BYE, {
extraHeaders: extraHeaders
});
}
return this;
},
/**
* RFC3261 13.3.1.4
* Response retransmissions cannot be accomplished by transaction layer
* since it is destroyed when receiving the first 2xx answer
*/
setInvite2xxTimer: function (request, description) {
var self = this, timeout = SIP.Timers.T1;
this.timers.invite2xxTimer = SIP.Timers.setTimeout(function invite2xxRetransmission() {
if (self.status !== C.STATUS_WAITING_FOR_ACK) {
return;
}
self.logger.log('no ACK received, attempting to retransmit OK');
var extraHeaders = ['Contact: ' + self.contact];
request.reply(200, null, extraHeaders, description);
timeout = Math.min(timeout * 2, SIP.Timers.T2);
self.timers.invite2xxTimer = SIP.Timers.setTimeout(invite2xxRetransmission, timeout);
}, timeout);
},
/**
* RFC3261 14.2
* If a UAS generates a 2xx response and never receives an ACK,
* it SHOULD generate a BYE to terminate the dialog.
*/
setACKTimer: function () {
var self = this;
this.timers.ackTimer = SIP.Timers.setTimeout(function () {
if (self.status === C.STATUS_WAITING_FOR_ACK) {
self.logger.log('no ACK received for an extended period of time, terminating the call');
SIP.Timers.clearTimeout(self.timers.invite2xxTimer);
self.sendRequest(SIP.C.BYE);
self.terminated(null, SIP.C.causes.NO_ACK);
}
}, SIP.Timers.TIMER_H);
},
/*
* @private
*/
onTransportError: function () {
if (this.status !== C.STATUS_CONFIRMED && this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.CONNECTION_ERROR);
}
},
onRequestTimeout: function () {
if (this.status === C.STATUS_CONFIRMED) {
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
else if (this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.REQUEST_TIMEOUT);
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
},
onDialogError: function (response) {
if (this.status === C.STATUS_CONFIRMED) {
this.terminated(response, SIP.C.causes.DIALOG_ERROR);
}
else if (this.status !== C.STATUS_TERMINATED) {
this.failed(response, SIP.C.causes.DIALOG_ERROR);
this.terminated(response, SIP.C.causes.DIALOG_ERROR);
}
},
/**
* @private
*/
failed: function (response, cause) {
if (this.status === C.STATUS_TERMINATED) {
return this;
}
this.emit('failed', response || null, cause || null);
return this;
},
rejected: function (response, cause) {
this.emit('rejected', response || null, cause || null);
return this;
},
canceled: function () {
if (this.sessionDescriptionHandler) {
this.sessionDescriptionHandler.close();
}
this.emit('cancel');
return this;
},
accepted: function (response, cause) {
cause = SIP.Utils.getReasonPhrase(response && response.status_code, cause);
this.startTime = new Date();
if (this.replacee) {
this.replacee.emit('replaced', this);
this.replacee.terminate();
}
this.emit('accepted', response, cause);
return this;
},
terminated: function (message, cause) {
if (this.status === C.STATUS_TERMINATED) {
return this;
}
this.endTime = new Date();
this.close();
this.emit('terminated', message || null, cause || null);
return this;
},
connecting: function (request) {
this.emit('connecting', { request: request });
return this;
}
};
Session.C = C;
SIP.Session = Session;
InviteServerContext = function (ua, request) {
var expires, self = this, contentType = request.getHeader('Content-Type'), contentDisp = request.parseHeader('Content-Disposition');
SIP.Utils.augment(this, SIP.ServerContext, [ua, request]);
SIP.Utils.augment(this, SIP.Session, [ua.configuration.sessionDescriptionHandlerFactory]);
if (contentDisp && contentDisp.type === 'render') {
this.renderbody = request.body;
this.rendertype = contentType;
}
this.status = C.STATUS_INVITE_RECEIVED;
this.from_tag = request.from_tag;
this.id = request.call_id + this.from_tag;
this.request = request;
this.contact = this.ua.contact.toString();
this.receiveNonInviteResponse = function () { }; // intentional no-op
this.logger = ua.getLogger('sip.inviteservercontext', this.id);
//Save the session into the ua sessions collection.
this.ua.sessions[this.id] = this;
//Get the Expires header value if exists
if (request.hasHeader('expires')) {
expires = request.getHeader('expires') * 1000;
}
//Set 100rel if necessary
function set100rel(h, c) {
if (request.hasHeader(h) && request.getHeader(h).toLowerCase().indexOf('100rel') >= 0) {
self.rel100 = c;
}
}
set100rel('require', SIP.C.supported.REQUIRED);
set100rel('supported', SIP.C.supported.SUPPORTED);
/* Set the to_tag before
* replying a response code that will create a dialog.
*/
request.to_tag = SIP.Utils.newTag();
// An error on dialog creation will fire 'failed' event
if (!this.createDialog(request, 'UAS', true)) {
request.reply(500, 'Missing Contact header field');
return;
}
var options = { extraHeaders: ['Contact: ' + self.contact] };
if (self.rel100 !== SIP.C.supported.REQUIRED) {
self.progress(options);
}
self.status = C.STATUS_WAITING_FOR_ANSWER;
// Set userNoAnswerTimer
self.timers.userNoAnswerTimer = SIP.Timers.setTimeout(function () {
request.reply(408);
self.failed(request, SIP.C.causes.NO_ANSWER);
self.terminated(request, SIP.C.causes.NO_ANSWER);
}, self.ua.configuration.noAnswerTimeout);
/* Set expiresTimer
* RFC3261 13.3.1
*/
if (expires) {
self.timers.expiresTimer = SIP.Timers.setTimeout(function () {
if (self.status === C.STATUS_WAITING_FOR_ANSWER) {
request.reply(487);
self.failed(request, SIP.C.causes.EXPIRES);
self.terminated(request, SIP.C.causes.EXPIRES);
}
}, expires);
}
this.errorListener = this.onTransportError.bind(this);
ua.transport.on('transportError', this.errorListener);
};
InviteServerContext.prototype = Object.create({}, {
reject: { writable: true, value: function (options) {
// Check Session Status
if (this.status === C.STATUS_TERMINATED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.logger.log('rejecting RTCSession');
SIP.ServerContext.prototype.reject.call(this, options);
return this.terminated();
} },
terminate: { writable: true, value: function (options) {
options = options || {};
var extraHeaders = (options.extraHeaders || []).slice(), body = options.body, dialog, self = this;
if (this.status === C.STATUS_WAITING_FOR_ACK &&
this.request.server_transaction.state !== SIP.Transactions.C.STATUS_TERMINATED) {
dialog = this.dialog;
this.receiveRequest = function (request) {
if (request.method === SIP.C.ACK) {
this.sendRequest(SIP.C.BYE, {
extraHeaders: extraHeaders,
body: body
});
dialog.terminate();
}
};
this.request.server_transaction.on('stateChanged', function () {
if (this.state === SIP.Transactions.C.STATUS_TERMINATED && this.dialog) {
this.request = new SIP.OutgoingRequest(SIP.C.BYE, this.dialog.remote_target, this.ua, {
'cseq': this.dialog.local_seqnum += 1,
'call_id': this.dialog.id.call_id,
'from_uri': this.dialog.local_uri,
'from_tag': this.dialog.id.local_tag,
'to_uri': this.dialog.remote_uri,
'to_tag': this.dialog.id.remote_tag,
'route_set': this.dialog.route_set
}, extraHeaders, body);
new SIP.RequestSender({
request: this.request,
onRequestTimeout: function () {
self.onRequestTimeout();
},
onTransportError: function () {
self.onTransportError();
},
receiveResponse: function () {
return;
}
}, this.ua).send();
dialog.terminate();
}
});
this.emit('bye', this.request);
this.terminated();
// Restore the dialog into 'this' in order to be able to send the in-dialog BYE :-)
this.dialog = dialog;
// Restore the dialog into 'ua' so the ACK can reach 'this' session
this.ua.dialogs[dialog.id.toString()] = dialog;
}
else if (this.status === C.STATUS_CONFIRMED) {
this.bye(options);
}
else {
this.reject(options);
}
return this;
} },
/*
* @param {Object} [options.sessionDescriptionHandlerOptions] gets passed to SIP.SessionDescriptionHandler.getDescription as options
*/
progress: { writable: true, value: function (options) {
options = options || {};
var statusCode = options.statusCode || 180, reasonPhrase = options.reasonPhrase, extraHeaders = (options.extraHeaders || []).slice(), body = options.body, response;
if (statusCode < 100 || statusCode > 199) {
throw new TypeError('Invalid statusCode: ' + statusCode);
}
if (this.isCanceled || this.status === C.STATUS_TERMINATED) {
return this;
}
function do100rel() {
/* jshint validthis: true */
statusCode = options.statusCode || 183;
// Set status and add extra headers
this.status = C.STATUS_WAITING_FOR_PRACK;
extraHeaders.push('Contact: ' + this.contact);
extraHeaders.push('Require: 100rel');
extraHeaders.push('RSeq: ' + Math.floor(Math.random() * 10000));
// Get the session description to add to preaccept with
this.sessionDescriptionHandler.getDescription(options.sessionDescriptionHandlerOptions, options.modifiers)
.then(function onSuccess(description) {
if (this.isCanceled || this.status === C.STATUS_TERMINATED) {
return;
}
this.early_sdp = description.body;
this[this.hasOffer ? 'hasAnswer' : 'hasOffer'] = true;
// Retransmit until we get a response or we time out (see prackTimer below)
var timeout = SIP.Timers.T1;
this.timers.rel1xxTimer = SIP.Timers.setTimeout(function rel1xxRetransmission() {
this.request.reply(statusCode, null, extraHeaders, description);
timeout *= 2;
this.timers.rel1xxTimer = SIP.Timers.setTimeout(rel1xxRetransmission.bind(this), timeout);
}.bind(this), timeout);
// Timeout and reject INVITE if no response
this.timers.prackTimer = SIP.Timers.setTimeout(function () {
if (this.status !== C.STATUS_WAITING_FOR_PRACK) {
return;
}
this.logger.log('no PRACK received, rejecting the call');
SIP.Timers.clearTimeout(this.timers.rel1xxTimer);
this.request.reply(504);
this.terminated(null, SIP.C.causes.NO_PRACK);
}.bind(this), SIP.Timers.T1 * 64);
// Send the initial response
response = this.request.reply(statusCode, reasonPhrase, extraHeaders, description);
this.emit('progress', response, reasonPhrase);
}.bind(this), function onFailure() {
this.request.reply(480);
this.failed(null, SIP.C.causes.WEBRTC_ERROR);
this.terminated(null, SIP.C.causes.WEBRTC_ERROR);
}.bind(this));
} // end do100rel
function normalReply() {
/* jshint validthis:true */
response = this.request.reply(statusCode, reasonPhrase, extraHeaders, body);
this.emit('progress', response, reasonPhrase);
}
if (options.statusCode !== 100 &&
(this.rel100 === SIP.C.supported.REQUIRED ||
(this.rel100 === SIP.C.supported.SUPPORTED && options.rel100) ||
(this.rel100 === SIP.C.supported.SUPPORTED && (this.ua.configuration.rel100 === SIP.C.supported.REQUIRED)))) {
this.sessionDescriptionHandler = this.setupSessionDescriptionHandler();
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
if (this.sessionDescriptionHandler.hasDescription(this.request.getHeader('Content-Type'))) {
this.hasOffer = true;
this.sessionDescriptionHandler.setDescription(this.request.body, options.sessionDescriptionHandlerOptions, options.modifiers)
.then(do100rel.apply(this))
.catch(function onFailure(e) {
this.logger.warn('invalid description');
this.logger.warn(e);
this.failed(null, SIP.C.causes.WEBRTC_ERROR);
this.terminated(null, SIP.C.causes.WEBRTC_ERROR);
}.bind(this));
}
else {
do100rel.apply(this);
}
}
else {
normalReply.apply(this);
}
return this;
} },
/*
* @param {Object} [options.sessionDescriptionHandlerOptions] gets passed to SIP.SessionDescriptionHandler.getDescription as options
*/
accept: { writable: true, value: function (options) {
options = options || {};
this.onInfo = options.onInfo;
var self = this, request = this.request, extraHeaders = (options.extraHeaders || []).slice(), descriptionCreationSucceeded = function (description) {
var response,
// run for reply success callback
replySucceeded = function () {
self.status = C.STATUS_WAITING_FOR_ACK;
self.setInvite2xxTimer(request, description);
self.setACKTimer();
},
// run for reply failure callback
replyFailed = function () {
self.failed(null, SIP.C.causes.CONNECTION_ERROR);
self.terminated(null, SIP.C.causes.CONNECTION_ERROR);
};
extraHeaders.push('Contact: ' + self.contact);
extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
if (!self.hasOffer) {
self.hasOffer = true;
}
else {
self.hasAnswer = true;
}
response = request.reply(200, null, extraHeaders, description, replySucceeded, replyFailed);
if (self.status !== C.STATUS_TERMINATED) { // Didn't fail
self.accepted(response, SIP.Utils.getReasonPhrase(200));
}
}, descriptionCreationFailed = function (err) {
if (err instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
self.logger.log(err.message);
self.logger.log(err.error);
}
// TODO: This should check the actual error and make sure it is an
// "expected" error. Otherwise it should throw.
if (self.status === C.STATUS_TERMINATED) {
return;
}
self.request.reply(480);
self.failed(null, SIP.C.causes.WEBRTC_ERROR);
self.terminated(null, SIP.C.causes.WEBRTC_ERROR);
};
// Check Session Status
if (this.status === C.STATUS_WAITING_FOR_PRACK) {
this.status = C.STATUS_ANSWERED_WAITING_FOR_PRACK;
return this;
}
else if (this.status === C.STATUS_WAITING_FOR_ANSWER) {
this.status = C.STATUS_ANSWERED;
}
else if (this.status !== C.STATUS_EARLY_MEDIA) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
// An error on dialog creation will fire 'failed' event
if (!this.createDialog(request, 'UAS')) {
request.reply(500, 'Missing Contact header field');
return this;
}
SIP.Timers.clearTimeout(this.timers.userNoAnswerTimer);
if (this.status === C.STATUS_EARLY_MEDIA) {
descriptionCreationSucceeded({});
}
else {
this.sessionDescriptionHandler = this.setupSessionDescriptionHandler();
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
if (this.request.getHeader('Content-Length') === '0' && !this.request.getHeader('Content-Type')) {
this.sessionDescriptionHandler.getDescription(options.sessionDescriptionHandlerOptions, options.modifiers)
.catch(descriptionCreationFailed)
.then(descriptionCreationSucceeded);
}
else if (this.sessionDescriptionHandler.hasDescription(this.request.getHeader('Content-Type'))) {
this.hasOffer = true;
this.sessionDescriptionHandler.setDescription(this.request.body, options.sessionDescriptionHandlerOptions, options.modifiers)
.then(function () {
return this.sessionDescriptionHandler.getDescription(options.sessionDescriptionHandlerOptions, options.modifiers);
}.bind(this))
.catch(descriptionCreationFailed)
.then(descriptionCreationSucceeded);
}
else {
this.request.reply(415);
// TODO: Events
return;
}
}
return this;
} },
receiveRequest: { writable: true, value: function (request) {
// ISC RECEIVE REQUEST
function confirmSession() {
/* jshint validthis:true */
var contentType, contentDisp;
SIP.Timers.clearTimeout(this.timers.ackTimer);
SIP.Timers.clearTimeout(this.timers.invite2xxTimer);
this.status = C.STATUS_CONFIRMED;
contentType = request.getHeader('Content-Type');
contentDisp = request.getHeader('Content-Disposition');
if (contentDisp && contentDisp.type === 'render') {
this.renderbody = request.body;
this.rendertype = contentType;
}
this.emit('confirmed', request);
}
switch (request.method) {
case SIP.C.CANCEL:
/* RFC3261 15 States that a UAS may have accepted an invitation while a CANCEL
* was in progress and that the UAC MAY continue with the session established by
* any 2xx response, or MAY terminate with BYE. SIP does continue with the
* established session. So the CANCEL is processed only if the session is not yet
* established.
*/
/*
* Terminate the whole session in case the user didn't accept (or yet to send the answer) nor reject the
*request opening the session.
*/
if (this.status === C.STATUS_WAITING_FOR_ANSWER ||
this.status === C.STATUS_WAITING_FOR_PRACK ||
this.status === C.STATUS_ANSWERED_WAITING_FOR_PRACK ||
this.status === C.STATUS_EARLY_MEDIA ||
this.status === C.STATUS_ANSWERED) {
this.status = C.STATUS_CANCELED;
this.request.reply(487);
this.canceled(request);
this.rejected(request, SIP.C.causes.CANCELED);
this.failed(request, SIP.C.causes.CANCELED);
this.terminated(request, SIP.C.causes.CANCELED);
}
break;
case SIP.C.ACK:
if (this.status === C.STATUS_WAITING_FOR_ACK) {
if (this.sessionDescriptionHandler.hasDescription(request.getHeader('Content-Type'))) {
// ACK contains answer to an INVITE w/o SDP negotiation
this.hasAnswer = true;
this.sessionDescriptionHandler.setDescription(request.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(
// TODO: Catch then .then
confirmSession.bind(this), function onFailure(e) {
this.logger.warn(e);
this.terminate({
statusCode: '488',
reasonPhrase: 'Bad Media Description'
});
this.failed(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
this.terminated(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
}.bind(this));
}
else {
confirmSession.apply(this);
}
}
break;
case SIP.C.PRACK:
if (this.status === C.STATUS_WAITING_FOR_PRACK || this.status === C.STATUS_ANSWERED_WAITING_FOR_PRACK) {
if (!this.hasAnswer) {
this.sessionDescriptionHandler = this.setupSessionDescriptionHandler();
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
if (this.sessionDescriptionHandler.hasDescription(request.getHeader('Content-Type'))) {
this.hasAnswer = true;
this.sessionDescriptionHandler.setDescription(request.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(function onSuccess() {
SIP.Timers.clearTimeout(this.timers.rel1xxTimer);
SIP.Timers.clearTimeout(this.timers.prackTimer);
request.reply(200);
if (this.status === C.STATUS_ANSWERED_WAITING_FOR_PRACK) {
this.status = C.STATUS_EARLY_MEDIA;
this.accept();
}
this.status = C.STATUS_EARLY_MEDIA;
}.bind(this), function onFailure(e) {
this.logger.warn(e);
this.terminate({
statusCode: '488',
reasonPhrase: 'Bad Media Description'
});
this.failed(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
this.terminated(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
}.bind(this));
}
else {
this.terminate({
statusCode: '488',
reasonPhrase: 'Bad Media Description'
});
this.failed(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
this.terminated(request, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
}
}
else {
SIP.Timers.clearTimeout(this.timers.rel1xxTimer);
SIP.Timers.clearTimeout(this.timers.prackTimer);
request.reply(200);
if (this.status === C.STATUS_ANSWERED_WAITING_FOR_PRACK) {
this.status = C.STATUS_EARLY_MEDIA;
this.accept();
}
this.status = C.STATUS_EARLY_MEDIA;
}
}
else if (this.status === C.STATUS_EARLY_MEDIA) {
request.reply(200);
}
break;
default:
Session.prototype.receiveRequest.apply(this, [request]);
break;
}
} },
// Internal Function to setup the handler consistently
setupSessionDescriptionHandler: { writable: true, value: function () {
if (this.sessionDescriptionHandler) {
return this.sessionDescriptionHandler;
}
return this.sessionDescriptionHandlerFactory(this, this.ua.configuration.sessionDescriptionHandlerFactoryOptions);
} },
onTransportError: { writable: true, value: function () {
if (this.status !== C.STATUS_CONFIRMED && this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.CONNECTION_ERROR);
}
} },
onRequestTimeout: { writable: true, value: function () {
if (this.status === C.STATUS_CONFIRMED) {
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
else if (this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.REQUEST_TIMEOUT);
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
} }
});
SIP.InviteServerContext = InviteServerContext;
InviteClientContext = function (ua, target, options, modifiers) {
options = options || {};
this.passedOptions = options; // Save for later to use with refer
options.params = Object.create(options.params || Object.prototype);
var extraHeaders = (options.extraHeaders || []).slice(), sessionDescriptionHandlerFactory = ua.configuration.sessionDescriptionHandlerFactory;
this.sessionDescriptionHandlerFactoryOptions = ua.configuration.sessionDescriptionHandlerFactoryOptions || {};
this.sessionDescriptionHandlerOptions = options.sessionDescriptionHandlerOptions || {};
this.modifiers = modifiers;
this.inviteWithoutSdp = options.inviteWithoutSdp || false;
// Set anonymous property
this.anonymous = options.anonymous || false;
// Custom data to be sent either in INVITE or in ACK
this.renderbody = options.renderbody || null;
this.rendertype = options.rendertype || 'text/plain';
// Session parameter initialization
this.from_tag = SIP.Utils.newTag();
options.params.from_tag = this.from_tag;
/* Do not add ;ob in initial forming dialog requests if the registration over
* the current connection got a GRUU URI.
*/
this.contact = ua.contact.toString({
anonymous: this.anonymous,
outbound: this.anonymous ? !ua.contact.temp_gruu : !ua.contact.pub_gruu
});
if (this.anonymous) {
options.params.from_displayName = 'Anonymous';
options.params.from_uri = 'sip:anonymous@anonymous.invalid';
extraHeaders.push('P-Preferred-Identity: ' + ua.configuration.uri.toString());
extraHeaders.push('Privacy: id');
}
extraHeaders.push('Contact: ' + this.contact);
extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
if (this.inviteWithoutSdp && this.renderbody) {
extraHeaders.push('Content-Type: ' + this.rendertype);
extraHeaders.push('Content-Disposition: render;handling=optional');
}
if (ua.configuration.rel100 === SIP.C.supported.REQUIRED) {
extraHeaders.push('Require: 100rel');
}
if (ua.configuration.replaces === SIP.C.supported.REQUIRED) {
extraHeaders.push('Require: replaces');
}
options.extraHeaders = extraHeaders;
SIP.Utils.augment(this, SIP.ClientContext, [ua, SIP.C.INVITE, target, options]);
SIP.Utils.augment(this, SIP.Session, [sessionDescriptionHandlerFactory]);
// Check Session Status
if (this.status !== C.STATUS_NULL) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
// OutgoingSession specific parameters
this.isCanceled = false;
this.received_100 = false;
this.method = SIP.C.INVITE;
this.receiveNonInviteResponse = this.receiveResponse;
this.receiveResponse = this.receiveInviteResponse;
this.logger = ua.getLogger('sip.inviteclientcontext');
ua.applicants[this] = this;
this.id = this.request.call_id + this.from_tag;
this.onInfo = options.onInfo;
this.errorListener = this.onTransportError.bind(this);
ua.transport.on('transportError', this.errorListener);
};
InviteClientContext.prototype = Object.create({}, {
invite: { writable: true, value: function () {
var self = this;
//Save the session into the ua sessions collection.
//Note: placing in constructor breaks call to request.cancel on close... User does not need this anyway
this.ua.sessions[this.id] = this;
// This should allow the function to return so that listeners can be set up for these events
SIP.Utils.Promise.resolve().then(function () {
if (this.inviteWithoutSdp) {
//just send an invite with no sdp...
this.request.body = self.renderbody;
this.status = C.STATUS_INVITE_SENT;
this.send();
}
else {
//Initialize Media Session
this.sessionDescriptionHandler = this.sessionDescriptionHandlerFactory(this, this.sessionDescriptionHandlerFactoryOptions);
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
this.sessionDescriptionHandler.getDescription(this.sessionDescriptionHandlerOptions, this.modifiers)
.then(function onSuccess(description) {
if (self.isCanceled || self.status === C.STATUS_TERMINATED) {
return;
}
self.hasOffer = true;
self.request.body = description;
self.status = C.STATUS_INVITE_SENT;
self.send();
}, function onFailure(err) {
if (err instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
self.logger.log(err.message);
self.logger.log(err.error);
}
if (self.status === C.STATUS_TERMINATED) {
return;
}
self.failed(null, SIP.C.causes.WEBRTC_ERROR);
self.terminated(null, SIP.C.causes.WEBRTC_ERROR);
});
}
}.bind(this));
return this;
} },
receiveInviteResponse: { writable: true, value: function (response) {
var cause, session = this, id = response.call_id + response.from_tag + response.to_tag, extraHeaders = [], options = {};
if (this.status === C.STATUS_TERMINATED || response.method !== SIP.C.INVITE) {
return;
}
if (this.dialog && (response.status_code >= 200 && response.status_code <= 299)) {
if (id !== this.dialog.id.toString()) {
if (!this.createDialog(response, 'UAC', true)) {
return;
}
this.emit("ack", response.transaction.sendACK({ body: SIP.Utils.generateFakeSDP(response.body) }));
this.earlyDialogs[id].sendRequest(this, SIP.C.BYE);
/* NOTE: This fails because the forking proxy does not recognize that an unanswerable
* leg (due to peerConnection limitations) has been answered first. If your forking
* proxy does not hang up all unanswered branches on the first branch answered, remove this.
*/
if (this.status !== C.STATUS_CONFIRMED) {
this.failed(response, SIP.C.causes.WEBRTC_ERROR);
this.terminated(response, SIP.C.causes.WEBRTC_ERROR);
}
return;
}
else if (this.status === C.STATUS_CONFIRMED) {
this.emit("ack", response.transaction.sendACK());
return;
}
else if (!this.hasAnswer) {
// invite w/o sdp is waiting for callback
//an invite with sdp must go on, and hasAnswer is true
return;
}
}
if (this.dialog && response.status_code < 200) {
/*
Early media has been set up with at least one other different branch,
but a final 2xx response hasn't been received
*/
if (this.dialog.pracked.indexOf(response.getHeader('rseq')) !== -1 ||
(this.dialog.pracked[this.dialog.pracked.length - 1] >= response.getHeader('rseq') && this.dialog.pracked.length > 0)) {
return;
}
if (!this.earlyDialogs[id] && !this.createDialog(response, 'UAC', true)) {
return;
}
if (this.earlyDialogs[id].pracked.indexOf(response.getHeader('rseq')) !== -1 ||
(this.earlyDialogs[id].pracked[this.earlyDialogs[id].pracked.length - 1] >= response.getHeader('rseq') && this.earlyDialogs[id].pracked.length > 0)) {
return;
}
extraHeaders.push('RAck: ' + response.getHeader('rseq') + ' ' + response.getHeader('cseq'));
this.earlyDialogs[id].pracked.push(response.getHeader('rseq'));
this.earlyDialogs[id].sendRequest(this, SIP.C.PRACK, {
extraHeaders: extraHeaders,
body: SIP.Utils.generateFakeSDP(response.body)
});
return;
}
// Proceed to cancellation if the user requested.
if (this.isCanceled) {
if (response.status_code >= 100 && response.status_code < 200) {
this.request.cancel(this.cancelReason, extraHeaders);
this.canceled(null);
}
else if (response.status_code >= 200 && response.status_code < 299) {
this.acceptAndTerminate(response);
this.emit('bye', this.request);
}
else if (response.status_code >= 300) {
cause = SIP.C.REASON_PHRASE[response.status_code] || SIP.C.causes.CANCELED;
this.rejected(response, cause);
this.failed(response, cause);
this.terminated(response, cause);
}
return;
}
switch (true) {
case /^100$/.test(response.status_code):
this.received_100 = true;
this.emit('progress', response);
break;
case (/^1[0-9]{2}$/.test(response.status_code)):
// Do nothing with 1xx responses without To tag.
if (!response.to_tag) {
this.logger.warn('1xx response received without to tag');
break;
}
// Create Early Dialog if 1XX comes with contact
if (response.hasHeader('contact')) {
// An error on dialog creation will fire 'failed' event
if (!this.createDialog(response, 'UAC', true)) {
break;
}
}
this.status = C.STATUS_1XX_RECEIVED;
if (response.hasHeader('P-Asserted-Identity')) {
this.assertedIdentity = new SIP.NameAddrHeader.parse(response.getHeader('P-Asserted-Identity'));
}
if (response.hasHeader('require') &&
response.getHeader('require').indexOf('100rel') !== -1) {
// Do nothing if this.dialog is already confirmed
if (this.dialog || !this.earlyDialogs[id]) {
break;
}
if (this.earlyDialogs[id].pracked.indexOf(response.getHeader('rseq')) !== -1 ||
(this.earlyDialogs[id].pracked[this.earlyDialogs[id].pracked.length - 1] >= response.getHeader('rseq') && this.earlyDialogs[id].pracked.length > 0)) {
return;
}
// TODO: This may be broken. It may have to be on the early dialog
this.sessionDescriptionHandler = this.sessionDescriptionHandlerFactory(this, this.sessionDescriptionHandlerFactoryOptions);
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
if (!this.sessionDescriptionHandler.hasDescription(response.getHeader('Content-Type'))) {
extraHeaders.push('RAck: ' + response.getHeader('rseq') + ' ' + response.getHeader('cseq'));
this.earlyDialogs[id].pracked.push(response.getHeader('rseq'));
this.earlyDialogs[id].sendRequest(this, SIP.C.PRACK, {
extraHeaders: extraHeaders
});
this.emit('progress', response);
}
else if (this.hasOffer) {
if (!this.createDialog(response, 'UAC')) {
break;
}
this.hasAnswer = true;
this.dialog.pracked.push(response.getHeader('rseq'));
this.sessionDescriptionHandler.setDescription(response.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(function onSuccess() {
extraHeaders.push('RAck: ' + response.getHeader('rseq') + ' ' + response.getHeader('cseq'));
session.sendRequest(SIP.C.PRACK, {
extraHeaders: extraHeaders,
receiveResponse: function () { }
});
session.status = C.STATUS_EARLY_MEDIA;
session.emit('progress', response);
}, function onFailure(e) {
session.logger.warn(e);
session.acceptAndTerminate(response, 488, 'Not Acceptable Here');
session.failed(response, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
});
}
else {
var earlyDialog = this.earlyDialogs[id];
var earlyMedia = earlyDialog.sessionDescriptionHandler = this.sessionDescriptionHandlerFactory(this, this.sessionDescriptionHandlerFactoryOptions);
this.emit('SessionDescriptionHandler-created', earlyMedia);
earlyDialog.pracked.push(response.getHeader('rseq'));
earlyMedia.setDescription(response.body, session.sessionDescriptionHandlerOptions, session.modifers)
.then(earlyMedia.getDescription.bind(earlyMedia, session.sessionDescriptionHandlerOptions, session.modifiers))
.then(function onSuccess(description) {
extraHeaders.push('RAck: ' + response.getHeader('rseq') + ' ' + response.getHeader('cseq'));
earlyDialog.sendRequest(session, SIP.C.PRACK, {
extraHeaders: extraHeaders,
body: description
});
session.status = C.STATUS_EARLY_MEDIA;
session.emit('progress', response);
})
.catch(function onFailure(e) {
// TODO: This is a bit wonky
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
earlyDialog.pracked.push(response.getHeader('rseq'));
if (session.status === C.STATUS_TERMINATED) {
return;
}
session.failed(null, SIP.C.causes.WEBRTC_ERROR);
session.terminated(null, SIP.C.causes.WEBRTC_ERROR);
}
else {
earlyDialog.pracked.splice(earlyDialog.pracked.indexOf(response.getHeader('rseq')), 1);
// Could not set remote description
session.logger.warn('invalid description');
session.logger.warn(e);
}
});
}
}
else {
this.emit('progress', response);
}
break;
case /^2[0-9]{2}$/.test(response.status_code):
var cseq = this.request.cseq + ' ' + this.request.method;
if (cseq !== response.getHeader('cseq')) {
break;
}
if (response.hasHeader('P-Asserted-Identity')) {
this.assertedIdentity = new SIP.NameAddrHeader.parse(response.getHeader('P-Asserted-Identity'));
}
if (this.status === C.STATUS_EARLY_MEDIA && this.dialog) {
this.status = C.STATUS_CONFIRMED;
options = {};
if (this.renderbody) {
extraHeaders.push('Content-Type: ' + this.rendertype);
options.extraHeaders = extraHeaders;
options.body = this.renderbody;
}
this.emit("ack", response.transaction.sendACK(options));
this.accepted(response);
break;
}
// Do nothing if this.dialog is already confirmed
if (this.dialog) {
break;
}
// This is an invite without sdp
if (!this.hasOffer) {
if (this.earlyDialogs[id] && this.earlyDialogs[id].sessionDescriptionHandler) {
//REVISIT
this.hasOffer = true;
this.hasAnswer = true;
this.sessionDescriptionHandler = this.earlyDialogs[id].sessionDescriptionHandler;
if (!this.createDialog(response, 'UAC')) {
break;
}
this.status = C.STATUS_CONFIRMED;
this.emit("ack", response.transaction.sendACK());
this.accepted(response);
}
else {
this.sessionDescriptionHandler = this.sessionDescriptionHandlerFactory(this, this.sessionDescriptionHandlerFactoryOptions);
this.emit('SessionDescriptionHandler-created', this.sessionDescriptionHandler);
if (!this.sessionDescriptionHandler.hasDescription(response.getHeader('Content-Type'))) {
this.acceptAndTerminate(response, 400, 'Missing session description');
this.failed(response, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
break;
}
if (!this.createDialog(response, 'UAC')) {
break;
}
this.hasOffer = true;
this.sessionDescriptionHandler.setDescription(response.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(this.sessionDescriptionHandler.getDescription.bind(this.sessionDescriptionHandler, this.sessionDescriptionHandlerOptions, this.modifiers))
.then(function onSuccess(description) {
//var localMedia;
if (session.isCanceled || session.status === C.STATUS_TERMINATED) {
return;
}
session.status = C.STATUS_CONFIRMED;
session.hasAnswer = true;
session.emit("ack", response.transaction.sendACK({ body: description }));
session.accepted(response);
})
.catch(function onFailure(e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
session.logger.warn('invalid description');
session.logger.warn(e);
// TODO: This message is inconsistent
session.acceptAndTerminate(response, 488, 'Invalid session description');
session.failed(response, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
}
});
}
}
else if (this.hasAnswer) {
if (this.renderbody) {
extraHeaders.push('Content-Type: ' + session.rendertype);
options.extraHeaders = extraHeaders;
options.body = this.renderbody;
}
this.emit("ack", response.transaction.sendACK(options));
}
else {
if (!this.sessionDescriptionHandler.hasDescription(response.getHeader('Content-Type'))) {
this.acceptAndTerminate(response, 400, 'Missing session description');
this.failed(response, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
break;
}
if (!this.createDialog(response, 'UAC')) {
break;
}
this.hasAnswer = true;
this.sessionDescriptionHandler.setDescription(response.body, this.sessionDescriptionHandlerOptions, this.modifiers)
.then(function onSuccess() {
var options = {};
session.status = C.STATUS_CONFIRMED;
if (session.renderbody) {
extraHeaders.push('Content-Type: ' + session.rendertype);
options.extraHeaders = extraHeaders;
options.body = session.renderbody;
}
session.emit("ack", response.transaction.sendACK(options));
session.accepted(response);
}, function onFailure(e) {
session.logger.warn(e);
session.acceptAndTerminate(response, 488, 'Not Acceptable Here');
session.failed(response, SIP.C.causes.BAD_MEDIA_DESCRIPTION);
});
}
break;
default:
cause = SIP.Utils.sipErrorCause(response.status_code);
this.rejected(response, cause);
this.failed(response, cause);
this.terminated(response, cause);
}
} },
cancel: { writable: true, value: function (options) {
options = options || {};
options.extraHeaders = (options.extraHeaders || []).slice();
if (this.isCanceled) {
throw new SIP.Exceptions.InvalidStateError('CANCELED');
}
// Check Session Status
if (this.status === C.STATUS_TERMINATED || this.status === C.STATUS_CONFIRMED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.logger.log('canceling RTCSession');
this.isCanceled = true;
var cancel_reason = SIP.Utils.getCancelReason(options.status_code, options.reason_phrase);
// Check Session Status
if (this.status === C.STATUS_NULL ||
(this.status === C.STATUS_INVITE_SENT && !this.received_100)) {
this.cancelReason = cancel_reason;
}
else if (this.status === C.STATUS_INVITE_SENT ||
this.status === C.STATUS_1XX_RECEIVED ||
this.status === C.STATUS_EARLY_MEDIA) {
this.request.cancel(cancel_reason, options.extraHeaders);
}
return this.canceled();
} },
terminate: { writable: true, value: function (options) {
if (this.status === C.STATUS_TERMINATED) {
return this;
}
if (this.status === C.STATUS_WAITING_FOR_ACK || this.status === C.STATUS_CONFIRMED) {
this.bye(options);
}
else {
this.cancel(options);
}
return this;
} },
receiveRequest: { writable: true, value: function (request) {
// ICC RECEIVE REQUEST
// Reject CANCELs
if (request.method === SIP.C.CANCEL) {
// TODO; make this a switch when it gets added
}
if (request.method === SIP.C.ACK && this.status === C.STATUS_WAITING_FOR_ACK) {
SIP.Timers.clearTimeout(this.timers.ackTimer);
SIP.Timers.clearTimeout(this.timers.invite2xxTimer);
this.status = C.STATUS_CONFIRMED;
this.accepted();
}
return Session.prototype.receiveRequest.apply(this, [request]);
} },
onTransportError: { writable: true, value: function () {
if (this.status !== C.STATUS_CONFIRMED && this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.CONNECTION_ERROR);
}
} },
onRequestTimeout: { writable: true, value: function () {
if (this.status === C.STATUS_CONFIRMED) {
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
else if (this.status !== C.STATUS_TERMINATED) {
this.failed(null, SIP.C.causes.REQUEST_TIMEOUT);
this.terminated(null, SIP.C.causes.REQUEST_TIMEOUT);
}
} }
});
SIP.InviteClientContext = InviteClientContext;
ReferClientContext = function (ua, applicant, target, options) {
this.options = options || {};
this.extraHeaders = (this.options.extraHeaders || []).slice();
if (ua === undefined || applicant === undefined || target === undefined) {
throw new TypeError('Not enough arguments');
}
SIP.Utils.augment(this, SIP.ClientContext, [ua, SIP.C.REFER, applicant.remoteIdentity.uri.toString(), options]);
this.applicant = applicant;
var withReplaces = target instanceof SIP.InviteServerContext ||
target instanceof SIP.InviteClientContext;
if (withReplaces) {
// Attended Transfer
// All of these fields should be defined based on the check above
this.target = '"' + target.remoteIdentity.friendlyName + '" ' +
'<' + target.dialog.remote_target.toString() +
'?Replaces=' + target.dialog.id.call_id +
'%3Bto-tag%3D' + target.dialog.id.remote_tag +
'%3Bfrom-tag%3D' + target.dialog.id.local_tag + '>';
}
else {
// Blind Transfer
// Refer-To: <sip:bob@example.com>
try {
this.target = SIP.Grammar.parse(target, 'Refer_To').uri || target;
}
catch (e) {
this.logger.debug(".refer() cannot parse Refer_To from", target);
this.logger.debug("...falling through to normalizeTarget()");
}
// Check target validity
this.target = this.ua.normalizeTarget(this.target);
if (!this.target) {
throw new TypeError('Invalid target: ' + target);
}
}
if (this.ua) {
this.extraHeaders.push('Referred-By: <' + this.ua.configuration.uri + '>');
}
// TODO: Check that this is correct isc/icc
this.extraHeaders.push('Contact: ' + applicant.contact);
this.extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
this.extraHeaders.push('Refer-To: ' + this.target);
this.errorListener = this.onTransportError.bind(this);
ua.transport.on('transportError', this.errorListener);
};
ReferClientContext.prototype = Object.create({}, {
refer: { writable: true, value: function (options) {
options = options || {};
var extraHeaders = (this.extraHeaders || []).slice();
if (options.extraHeaders) {
extraHeaders.concat(options.extraHeaders);
}
this.applicant.sendRequest(SIP.C.REFER, {
extraHeaders: this.extraHeaders,
receiveResponse: function (response) {
if (/^1[0-9]{2}$/.test(response.status_code)) {
this.emit('referRequestProgress', this);
}
else if (/^2[0-9]{2}$/.test(response.status_code)) {
this.emit('referRequestAccepted', this);
}
else if (/^[4-6][0-9]{2}$/.test(response.status_code)) {
this.emit('referRequestRejected', this);
}
if (options.receiveResponse) {
options.receiveResponse(response);
}
}.bind(this)
});
return this;
} },
receiveNotify: { writable: true, value: function (request) {
// If we can correctly handle this, then we need to send a 200 OK!
if (request.hasHeader('Content-Type') && request.getHeader('Content-Type').search(/^message\/sipfrag/) !== -1) {
var messageBody = SIP.Grammar.parse(request.body, 'sipfrag');
if (messageBody === -1) {
request.reply(489, 'Bad Event');
return;
}
switch (true) {
case (/^1[0-9]{2}$/.test(messageBody.status_code)):
this.emit('referProgress', this);
break;
case (/^2[0-9]{2}$/.test(messageBody.status_code)):
this.emit('referAccepted', this);
if (!this.options.activeAfterTransfer && this.applicant.terminate) {
this.applicant.terminate();
}
break;
default:
this.emit('referRejected', this);
break;
}
request.reply(200);
this.emit('notify', request);
return;
}
request.reply(489, 'Bad Event');
} }
});
SIP.ReferClientContext = ReferClientContext;
ReferServerContext = function (ua, request) {
SIP.Utils.augment(this, SIP.ServerContext, [ua, request]);
this.ua = ua;
this.status = C.STATUS_INVITE_RECEIVED;
this.from_tag = request.from_tag;
this.id = request.call_id + this.from_tag;
this.request = request;
this.contact = this.ua.contact.toString();
this.logger = ua.getLogger('sip.referservercontext', this.id);
// RFC 3515 2.4.1
if (!this.request.hasHeader('refer-to')) {
this.logger.warn('Invalid REFER packet. A refer-to header is required. Rejecting refer.');
this.reject();
return;
}
this.referTo = this.request.parseHeader('refer-to');
// TODO: Must set expiration timer and send 202 if there is no response by then
this.referredSession = this.ua.findSession(request);
// Needed to send the NOTIFY's
this.cseq = Math.floor(Math.random() * 10000);
this.call_id = this.request.call_id;
this.from_uri = this.request.to.uri;
this.from_tag = this.request.to.parameters.tag;
this.remote_target = this.request.headers.Contact[0].parsed.uri;
this.to_uri = this.request.from.uri;
this.to_tag = this.request.from_tag;
this.route_set = this.request.getHeaders('record-route');
this.receiveNonInviteResponse = function () { };
if (this.request.hasHeader('referred-by')) {
this.referredBy = this.request.getHeader('referred-by');
}
if (this.referTo.uri.hasHeader('replaces')) {
this.replaces = this.referTo.uri.getHeader('replaces');
}
this.errorListener = this.onTransportError.bind(this);
ua.transport.on('transportError', this.errorListener);
this.status = C.STATUS_WAITING_FOR_ANSWER;
};
ReferServerContext.prototype = Object.create({}, {
progress: { writable: true, value: function () {
if (this.status !== C.STATUS_WAITING_FOR_ANSWER) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.request.reply(100);
} },
reject: { writable: true, value: function (options) {
if (this.status === C.STATUS_TERMINATED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.logger.log('Rejecting refer');
this.status = C.STATUS_TERMINATED;
SIP.ServerContext.prototype.reject.call(this, options);
this.emit('referRequestRejected', this);
} },
accept: { writable: true, value: function (options, modifiers) {
options = options || {};
if (this.status === C.STATUS_WAITING_FOR_ANSWER) {
this.status = C.STATUS_ANSWERED;
}
else {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
this.request.reply(202, 'Accepted');
this.emit('referRequestAccepted', this);
if (options.followRefer) {
this.logger.log('Accepted refer, attempting to automatically follow it');
var target = this.referTo.uri;
if (!target.scheme.match("^sips?$")) {
this.logger.error('SIP.js can only automatically follow SIP refer target');
this.reject();
return;
}
var inviteOptions = options.inviteOptions || {};
var extraHeaders = (inviteOptions.extraHeaders || []).slice();
if (this.replaces) {
// decodeURIComponent is a holdover from 2c086eb4. Not sure that it is actually necessary
extraHeaders.push('Replaces: ' + decodeURIComponent(this.replaces));
}
if (this.referredBy) {
extraHeaders.push('Referred-By: ' + this.referredBy);
}
inviteOptions.extraHeaders = extraHeaders;
target.clearHeaders();
this.targetSession = this.ua.invite(target, inviteOptions, modifiers);
this.emit('referInviteSent', this);
this.targetSession.once('progress', function () {
this.sendNotify('SIP/2.0 100 Trying');
this.emit('referProgress', this);
if (this.referredSession) {
this.referredSession.emit('referProgress', this);
}
}.bind(this));
this.targetSession.once('accepted', function () {
this.logger.log('Successfully followed the refer');
this.sendNotify('SIP/2.0 200 OK');
this.emit('referAccepted', this);
if (this.referredSession) {
this.referredSession.emit('referAccepted', this);
}
}.bind(this));
var referFailed = function (response) {
if (this.status === C.STATUS_TERMINATED) {
return; // No throw here because it is possible this gets called multiple times
}
this.logger.log('Refer was not successful. Resuming session');
if (response && response.status_code === 429) {
this.logger.log('Alerting referrer that identity is required.');
this.sendNotify('SIP/2.0 429 Provide Referrer Identity');
return;
}
this.sendNotify('SIP/2.0 603 Declined');
// Must change the status after sending the final Notify or it will not send due to check
this.status = C.STATUS_TERMINATED;
this.emit('referRejected', this);
if (this.referredSession) {
this.referredSession.emit('referRejected');
}
};
this.targetSession.once('rejected', referFailed.bind(this));
this.targetSession.once('failed', referFailed.bind(this));
}
else {
this.logger.log('Accepted refer, but did not automatically follow it');
this.sendNotify('SIP/2.0 200 OK');
this.emit('referAccepted', this);
if (this.referredSession) {
this.referredSession.emit('referAccepted', this);
}
}
} },
sendNotify: { writable: true, value: function (body) {
if (this.status !== C.STATUS_ANSWERED) {
throw new SIP.Exceptions.InvalidStateError(this.status);
}
if (SIP.Grammar.parse(body, 'sipfrag') === -1) {
throw new Error('sipfrag body is required to send notify for refer');
}
var request = new SIP.OutgoingRequest(SIP.C.NOTIFY, this.remote_target, this.ua, {
cseq: this.cseq += 1,
call_id: this.call_id,
from_uri: this.from_uri,
from_tag: this.from_tag,
to_uri: this.to_uri,
to_tag: this.to_tag,
route_set: this.route_set
}, [
'Event: refer',
'Subscription-State: terminated',
'Content-Type: message/sipfrag'
], body);
new SIP.RequestSender({
request: request,
onRequestTimeout: function () {
return;
},
onTransportError: function () {
return;
},
receiveResponse: function () {
return;
}
}, this.ua).send();
} }
});
SIP.ReferServerContext = ReferServerContext;
};
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview DTMF
*/
/**
* @class DTMF
* @param {SIP.Session} session
*/
module.exports = function (SIP) {
var DTMF, C = {
MIN_DURATION: 70,
MAX_DURATION: 6000,
DEFAULT_DURATION: 100,
MIN_INTER_TONE_GAP: 50,
DEFAULT_INTER_TONE_GAP: 500
};
DTMF = function (session, tone, options) {
var duration, interToneGap;
if (tone === undefined) {
throw new TypeError('Not enough arguments');
}
this.logger = session.ua.getLogger('sip.invitecontext.dtmf', session.id);
this.owner = session;
this.direction = null;
options = options || {};
duration = options.duration || null;
interToneGap = options.interToneGap || null;
// Check tone type
if (typeof tone === 'string') {
tone = tone.toUpperCase();
}
else if (typeof tone === 'number') {
tone = tone.toString();
}
else {
throw new TypeError('Invalid tone: ' + tone);
}
// Check tone value
if (!tone.match(/^[0-9A-D#*]$/)) {
throw new TypeError('Invalid tone: ' + tone);
}
else {
this.tone = tone;
}
// Check duration
if (duration && !SIP.Utils.isDecimal(duration)) {
throw new TypeError('Invalid tone duration: ' + duration);
}
else if (!duration) {
duration = DTMF.C.DEFAULT_DURATION;
}
else if (duration < DTMF.C.MIN_DURATION) {
this.logger.warn('"duration" value is lower than the minimum allowed, setting it to ' + DTMF.C.MIN_DURATION + ' milliseconds');
duration = DTMF.C.MIN_DURATION;
}
else if (duration > DTMF.C.MAX_DURATION) {
this.logger.warn('"duration" value is greater than the maximum allowed, setting it to ' + DTMF.C.MAX_DURATION + ' milliseconds');
duration = DTMF.C.MAX_DURATION;
}
else {
duration = Math.abs(duration);
}
this.duration = duration;
// Check interToneGap
if (interToneGap && !SIP.Utils.isDecimal(interToneGap)) {
throw new TypeError('Invalid interToneGap: ' + interToneGap);
}
else if (!interToneGap) {
interToneGap = DTMF.C.DEFAULT_INTER_TONE_GAP;
}
else if (interToneGap < DTMF.C.MIN_INTER_TONE_GAP) {
this.logger.warn('"interToneGap" value is lower than the minimum allowed, setting it to ' + DTMF.C.MIN_INTER_TONE_GAP + ' milliseconds');
interToneGap = DTMF.C.MIN_INTER_TONE_GAP;
}
else {
interToneGap = Math.abs(interToneGap);
}
this.interToneGap = interToneGap;
};
DTMF.prototype = Object.create(SIP.EventEmitter.prototype);
DTMF.prototype.send = function (options) {
var extraHeaders, body = {};
this.direction = 'outgoing';
// Check RTCSession Status
if (this.owner.status !== SIP.Session.C.STATUS_CONFIRMED &&
this.owner.status !== SIP.Session.C.STATUS_WAITING_FOR_ACK) {
throw new SIP.Exceptions.InvalidStateError(this.owner.status);
}
// Get DTMF options
options = options || {};
extraHeaders = options.extraHeaders ? options.extraHeaders.slice() : [];
body.contentType = 'application/dtmf-relay';
body.body = "Signal= " + this.tone + "\r\n";
body.body += "Duration= " + this.duration;
this.request = this.owner.dialog.sendRequest(this, SIP.C.INFO, {
extraHeaders: extraHeaders,
body: body
});
this.owner.emit('dtmf', this.request, this);
};
/**
* @private
*/
DTMF.prototype.receiveResponse = function (response) {
var cause;
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
// Ignore provisional responses.
break;
case /^2[0-9]{2}$/.test(response.status_code):
this.emit('succeeded', {
originator: 'remote',
response: response
});
break;
default:
cause = SIP.Utils.sipErrorCause(response.status_code);
this.emit('failed', response, cause);
break;
}
};
/**
* @private
*/
DTMF.prototype.onRequestTimeout = function () {
this.emit('failed', null, SIP.C.causes.REQUEST_TIMEOUT);
this.owner.onRequestTimeout();
};
/**
* @private
*/
DTMF.prototype.onTransportError = function () {
this.emit('failed', null, SIP.C.causes.CONNECTION_ERROR);
this.owner.onTransportError();
};
/**
* @private
*/
DTMF.prototype.onDialogError = function (response) {
this.emit('failed', response, SIP.C.causes.DIALOG_ERROR);
this.owner.onDialogError(response);
};
/**
* @private
*/
DTMF.prototype.init_incoming = function (request) {
this.direction = 'incoming';
this.request = request;
request.reply(200);
if (!this.tone || !this.duration) {
this.logger.warn('invalid INFO DTMF received, discarded');
}
else {
this.owner.emit('dtmf', request, this);
}
};
DTMF.C = C;
return DTMF;
};
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Subscriber (SIP-Specific Event Notifications RFC6665)
*/
/**
* @augments SIP
* @class Class creating a SIP Subscription.
*/
module.exports = function (SIP) {
SIP.Subscription = function (ua, target, event, options) {
options = Object.create(options || Object.prototype);
this.extraHeaders = options.extraHeaders = (options.extraHeaders || []).slice();
this.id = null;
this.state = 'init';
if (!event) {
throw new TypeError('Event necessary to create a subscription.');
}
else {
//TODO: check for valid events here probably make a list in SIP.C; or leave it up to app to check?
//The check may need to/should probably occur on the other side,
this.event = event;
}
if (typeof options.expires !== 'number') {
ua.logger.warn('expires must be a number. Using default of 3600.');
this.expires = 3600;
}
else {
this.expires = options.expires;
}
this.requestedExpires = this.expires;
options.extraHeaders.push('Event: ' + this.event);
options.extraHeaders.push('Expires: ' + this.expires);
if (options.body) {
this.body = options.body;
}
this.contact = ua.contact.toString();
options.extraHeaders.push('Contact: ' + this.contact);
options.extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
SIP.Utils.augment(this, SIP.ClientContext, [ua, SIP.C.SUBSCRIBE, target, options]);
this.logger = ua.getLogger('sip.subscription');
this.dialog = null;
this.timers = { N: null, sub_duration: null };
this.errorCodes = [404, 405, 410, 416, 480, 481, 482, 483, 484, 485, 489, 501, 604];
};
SIP.Subscription.prototype = {
subscribe: function () {
var sub = this;
//these states point to an existing subscription, no subscribe is necessary
if (this.state === 'active') {
this.refresh();
return this;
}
else if (this.state === 'notify_wait') {
return this;
}
SIP.Timers.clearTimeout(this.timers.sub_duration);
SIP.Timers.clearTimeout(this.timers.N);
this.timers.N = SIP.Timers.setTimeout(sub.timer_fire.bind(sub), SIP.Timers.TIMER_N);
this.ua.earlySubscriptions[this.request.call_id + this.request.from.parameters.tag + this.event] = this;
this.send();
this.state = 'notify_wait';
return this;
},
refresh: function () {
if (this.state === 'terminated' || this.state === 'pending' || this.state === 'notify_wait') {
return;
}
this.dialog.sendRequest(this, SIP.C.SUBSCRIBE, {
extraHeaders: this.extraHeaders,
body: this.body
});
},
receiveResponse: function (response) {
var expires, sub = this, cause = SIP.Utils.getReasonPhrase(response.status_code);
if ((this.state === 'notify_wait' && response.status_code >= 300) ||
(this.state !== 'notify_wait' && this.errorCodes.indexOf(response.status_code) !== -1)) {
this.failed(response, null);
}
else if (/^2[0-9]{2}$/.test(response.status_code)) {
this.emit('accepted', response, cause);
//As we don't support RFC 5839 or other extensions where the NOTIFY is optional, timer N will not be cleared
//SIP.Timers.clearTimeout(this.timers.N);
expires = response.getHeader('Expires');
if (expires && expires <= this.requestedExpires) {
// Preserve new expires value for subsequent requests
this.expires = expires;
this.timers.sub_duration = SIP.Timers.setTimeout(sub.refresh.bind(sub), expires * 900);
}
else {
if (!expires) {
this.logger.warn('Expires header missing in a 200-class response to SUBSCRIBE');
this.failed(response, SIP.C.EXPIRES_HEADER_MISSING);
}
else {
this.logger.warn('Expires header in a 200-class response to SUBSCRIBE with a higher value than the one in the request');
this.failed(response, SIP.C.INVALID_EXPIRES_HEADER);
}
}
}
else if (response.statusCode > 300) {
this.emit('failed', response, cause);
this.emit('rejected', response, cause);
}
},
unsubscribe: function () {
var extraHeaders = [], sub = this;
this.state = 'terminated';
extraHeaders.push('Event: ' + this.event);
extraHeaders.push('Expires: 0');
extraHeaders.push('Contact: ' + this.contact);
extraHeaders.push('Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString());
//makes sure expires isn't set, and other typical resubscribe behavior
this.receiveResponse = function () { };
this.dialog.sendRequest(this, this.method, {
extraHeaders: extraHeaders,
body: this.body
});
SIP.Timers.clearTimeout(this.timers.sub_duration);
SIP.Timers.clearTimeout(this.timers.N);
this.timers.N = SIP.Timers.setTimeout(sub.timer_fire.bind(sub), SIP.Timers.TIMER_N);
},
/**
* @private
*/
timer_fire: function () {
if (this.state === 'terminated') {
this.terminateDialog();
SIP.Timers.clearTimeout(this.timers.N);
SIP.Timers.clearTimeout(this.timers.sub_duration);
delete this.ua.subscriptions[this.id];
}
else if (this.state === 'notify_wait' || this.state === 'pending') {
this.close();
}
else {
this.refresh();
}
},
/**
* @private
*/
close: function () {
if (this.state === 'notify_wait') {
this.state = 'terminated';
SIP.Timers.clearTimeout(this.timers.N);
SIP.Timers.clearTimeout(this.timers.sub_duration);
this.receiveResponse = function () { };
delete this.ua.earlySubscriptions[this.request.call_id + this.request.from.parameters.tag + this.event];
}
else if (this.state !== 'terminated') {
this.unsubscribe();
}
},
/**
* @private
*/
createConfirmedDialog: function (message, type) {
var dialog;
this.terminateDialog();
dialog = new SIP.Dialog(this, message, type);
dialog.invite_seqnum = this.request.cseq;
dialog.local_seqnum = this.request.cseq;
if (!dialog.error) {
this.dialog = dialog;
return true;
}
// Dialog not created due to an error
else {
return false;
}
},
/**
* @private
*/
terminateDialog: function () {
if (this.dialog) {
delete this.ua.subscriptions[this.id];
this.dialog.terminate();
delete this.dialog;
}
},
/**
* @private
*/
receiveRequest: function (request) {
var sub_state, sub = this;
function setExpiresTimeout() {
if (sub_state.expires) {
SIP.Timers.clearTimeout(sub.timers.sub_duration);
sub_state.expires = Math.min(sub.expires, Math.max(sub_state.expires, 0));
sub.timers.sub_duration = SIP.Timers.setTimeout(sub.refresh.bind(sub), sub_state.expires * 900);
}
}
if (!this.matchEvent(request)) { //checks event and subscription_state headers
request.reply(489);
return;
}
if (!this.dialog) {
if (this.createConfirmedDialog(request, 'UAS')) {
this.id = this.dialog.id.toString();
delete this.ua.earlySubscriptions[this.request.call_id + this.request.from.parameters.tag + this.event];
this.ua.subscriptions[this.id] = this;
// UPDATE ROUTE SET TO BE BACKWARDS COMPATIBLE?
}
}
sub_state = request.parseHeader('Subscription-State');
request.reply(200, SIP.C.REASON_200);
SIP.Timers.clearTimeout(this.timers.N);
this.emit('notify', { request: request });
// if we've set state to terminated, no further processing should take place
// and we are only interested in cleaning up after the appropriate NOTIFY
if (this.state === 'terminated') {
if (sub_state.state === 'terminated') {
this.terminateDialog();
SIP.Timers.clearTimeout(this.timers.N);
SIP.Timers.clearTimeout(this.timers.sub_duration);
delete this.ua.subscriptions[this.id];
}
return;
}
switch (sub_state.state) {
case 'active':
this.state = 'active';
setExpiresTimeout();
break;
case 'pending':
if (this.state === 'notify_wait') {
setExpiresTimeout();
}
this.state = 'pending';
break;
case 'terminated':
SIP.Timers.clearTimeout(this.timers.sub_duration);
if (sub_state.reason) {
this.logger.log('terminating subscription with reason ' + sub_state.reason);
switch (sub_state.reason) {
case 'deactivated':
case 'timeout':
this.subscribe();
return;
case 'probation':
case 'giveup':
if (sub_state.params && sub_state.params['retry-after']) {
this.timers.sub_duration = SIP.Timers.setTimeout(sub.subscribe.bind(sub), sub_state.params['retry-after']);
}
else {
this.subscribe();
}
return;
case 'rejected':
case 'noresource':
case 'invariant':
break;
}
}
this.close();
break;
}
},
failed: function (response, cause) {
this.close();
this.emit('failed', response, cause);
this.emit('rejected', response, cause);
return this;
},
onDialogError: function (response) {
this.failed(response, SIP.C.causes.DIALOG_ERROR);
},
/**
* @private
*/
matchEvent: function (request) {
var event;
// Check mandatory header Event
if (!request.hasHeader('Event')) {
this.logger.warn('missing Event header');
return false;
}
// Check mandatory header Subscription-State
if (!request.hasHeader('Subscription-State')) {
this.logger.warn('missing Subscription-State header');
return false;
}
// Check whether the event in NOTIFY matches the event in SUBSCRIBE
event = request.parseHeader('event').event;
if (this.event !== event) {
this.logger.warn('event match failed');
request.reply(481, 'Event Match Failed');
return false;
}
else {
return true;
}
}
};
};
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SIP Publish (SIP Extension for Event State Publication RFC3903)
*/
/**
* @augments SIP
* @class Class creating a SIP PublishContext.
*/
module.exports = function (SIP) {
var PublishContext;
PublishContext = function (ua, target, event, options) {
this.options = options = (options || {});
this.options.extraHeaders = (options.extraHeaders || []).slice();
this.options.contentType = (options.contentType || 'text/plain');
if (typeof options.expires !== 'number' || (options.expires % 1) !== 0) {
this.options.expires = 3600;
}
else {
this.options.expires = Number(options.expires);
}
if (typeof (options.unpublishOnClose) !== "boolean") {
this.options.unpublishOnClose = true;
}
else {
this.options.unpublishOnClose = options.unpublishOnClose;
}
if (target === undefined || target === null || target === '') {
throw new SIP.Exceptions.MethodParameterError('Publish', 'Target', target);
}
else {
this.target = ua.normalizeTarget(target);
}
if (event === undefined || event === null || event === '') {
throw new SIP.Exceptions.MethodParameterError('Publish', 'Event', event);
}
else {
this.event = event;
}
// Call parent constructor
SIP.ClientContext.call(this, ua, SIP.C.PUBLISH, this.target, this.options);
this.logger = this.ua.getLogger('sip.publish');
this.pubRequestBody = null;
this.pubRequestExpires = this.options.expires;
this.pubRequestEtag = null;
this.publish_refresh_timer = null;
ua.on('transportCreated', function (transport) {
transport.on('transportError', this.onTransportError.bind(this));
}.bind(this));
};
// Extend ClientContext
PublishContext.prototype = Object.create(SIP.ClientContext.prototype);
// Restore the class constructor
PublishContext.prototype.constructor = PublishContext;
/**
* Publish
*
* @param {string} Event body to publish, optional
*
*/
PublishContext.prototype.publish = function (body) {
// Clean up before the run
this.request = null;
SIP.Timers.clearTimeout(this.publish_refresh_timer);
if (body !== undefined && body !== null && body !== '') {
// is Inital or Modify request
this.options.body = body;
this.pubRequestBody = this.options.body;
if (this.pubRequestExpires === 0) {
// This is Initial request after unpublish
this.pubRequestExpires = this.options.expires;
this.pubRequestEtag = null;
}
if (!(this.ua.publishers[this.target.toString() + ':' + this.event])) {
this.ua.publishers[this.target.toString() + ':' + this.event] = this;
}
}
else {
// This is Refresh request
this.pubRequestBody = null;
if (this.pubRequestEtag === null) {
//Request not valid
throw new SIP.Exceptions.MethodParameterError('Publish', 'Body', body);
}
if (this.pubRequestExpires === 0) {
//Request not valid
throw new SIP.Exceptions.MethodParameterError('Publish', 'Expire', this.pubRequestExpires);
}
}
this.sendPublishRequest();
};
/**
* Unpublish
*
*/
PublishContext.prototype.unpublish = function () {
// Clean up before the run
this.request = null;
SIP.Timers.clearTimeout(this.publish_refresh_timer);
this.pubRequestBody = null;
this.pubRequestExpires = 0;
if (this.pubRequestEtag !== null) {
this.sendPublishRequest();
}
};
/**
* Close
*
*/
PublishContext.prototype.close = function () {
// Send unpublish, if requested
if (this.options.unpublishOnClose) {
this.unpublish();
}
else {
this.request = null;
SIP.Timers.clearTimeout(this.publish_refresh_timer);
this.pubRequestBody = null;
this.pubRequestExpires = 0;
this.pubRequestEtag = null;
}
if (this.ua.publishers[this.target.toString() + ':' + this.event]) {
delete this.ua.publishers[this.target.toString() + ':' + this.event];
}
};
/**
* @private
*
*/
PublishContext.prototype.sendPublishRequest = function () {
var reqOptions;
reqOptions = Object.create(this.options || Object.prototype);
reqOptions.extraHeaders = (this.options.extraHeaders || []).slice();
reqOptions.extraHeaders.push('Event: ' + this.event);
reqOptions.extraHeaders.push('Expires: ' + this.pubRequestExpires);
if (this.pubRequestEtag !== null) {
reqOptions.extraHeaders.push('SIP-If-Match: ' + this.pubRequestEtag);
}
this.request = new SIP.OutgoingRequest(SIP.C.PUBLISH, this.target, this.ua, this.options.params, reqOptions.extraHeaders);
if (this.pubRequestBody !== null) {
this.request.body = {};
this.request.body.body = this.pubRequestBody;
this.request.body.contentType = this.options.contentType;
}
this.send();
};
/**
* @private
*
*/
PublishContext.prototype.receiveResponse = function (response) {
var expires, minExpires, cause = SIP.Utils.getReasonPhrase(response.status_code);
switch (true) {
case /^1[0-9]{2}$/.test(response.status_code):
this.emit('progress', response, cause);
break;
case /^2[0-9]{2}$/.test(response.status_code):
// Set SIP-Etag
if (response.hasHeader('SIP-ETag')) {
this.pubRequestEtag = response.getHeader('SIP-ETag');
}
else {
this.logger.warn('SIP-ETag header missing in a 200-class response to PUBLISH');
}
// Update Expire
if (response.hasHeader('Expires')) {
expires = Number(response.getHeader('Expires'));
if (typeof expires === 'number' && expires >= 0 && expires <= this.pubRequestExpires) {
this.pubRequestExpires = expires;
}
else {
this.logger.warn('Bad Expires header in a 200-class response to PUBLISH');
}
}
else {
this.logger.warn('Expires header missing in a 200-class response to PUBLISH');
}
if (this.pubRequestExpires !== 0) {
// Schedule refresh
this.publish_refresh_timer = SIP.Timers.setTimeout(this.publish.bind(this), this.pubRequestExpires * 900);
this.emit('published', response, cause);
}
else {
this.emit('unpublished', response, cause);
}
break;
case /^412$/.test(response.status_code):
// 412 code means no matching ETag - possibly the PUBLISH expired
// Resubmit as new request, if the current request is not a "remove"
if (this.pubRequestEtag !== null && this.pubRequestExpires !== 0) {
this.logger.warn('412 response to PUBLISH, recovering');
this.pubRequestEtag = null;
this.emit('progress', response, cause);
this.publish(this.options.body);
}
else {
this.logger.warn('412 response to PUBLISH, recovery failed');
this.pubRequestExpires = 0;
this.emit('failed', response, cause);
this.emit('unpublished', response, cause);
}
break;
case /^423$/.test(response.status_code):
// 423 code means we need to adjust the Expires interval up
if (this.pubRequestExpires !== 0 && response.hasHeader('Min-Expires')) {
minExpires = Number(response.getHeader('Min-Expires'));
if (typeof minExpires === 'number' || minExpires > this.pubRequestExpires) {
this.logger.warn('423 code in response to PUBLISH, adjusting the Expires value and trying to recover');
this.pubRequestExpires = minExpires;
this.emit('progress', response, cause);
this.publish(this.options.body);
}
else {
this.logger.warn('Bad 423 response Min-Expires header received for PUBLISH');
this.pubRequestExpires = 0;
this.emit('failed', response, cause);
this.emit('unpublished', response, cause);
}
}
else {
this.logger.warn('423 response to PUBLISH, recovery failed');
this.pubRequestExpires = 0;
this.emit('failed', response, cause);
this.emit('unpublished', response, cause);
}
break;
default:
this.pubRequestExpires = 0;
this.emit('failed', response, cause);
this.emit('unpublished', response, cause);
break;
}
// Do the cleanup
if (this.pubRequestExpires === 0) {
SIP.Timers.clearTimeout(this.publish_refresh_timer);
this.pubRequestBody = null;
this.pubRequestEtag = null;
}
};
PublishContext.prototype.onRequestTimeout = function () {
SIP.ClientContext.prototype.onRequestTimeout.call(this);
this.emit('unpublished', null, SIP.C.causes.REQUEST_TIMEOUT);
};
PublishContext.prototype.onTransportError = function () {
SIP.ClientContext.prototype.onTransportError.call(this);
this.emit('unpublished', null, SIP.C.causes.CONNECTION_ERROR);
};
SIP.PublishContext = PublishContext;
};
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
/**
* @augments SIP
* @class Class creating a SIP User Agent.
* @param {function returning SIP.sessionDescriptionHandler} [configuration.sessionDescriptionHandlerFactory]
* A function will be invoked by each of the UA's Sessions to build the sessionDescriptionHandler for that Session.
* If no (or a falsy) value is provided, each Session will use a default (WebRTC) sessionDescriptionHandler.
*
* @param {Object} [configuration.media] gets passed to SIP.sessionDescriptionHandler.getDescription as mediaHint
*/
module.exports = function (SIP, environment) {
var UA, C = {
// UA status codes
STATUS_INIT: 0,
STATUS_STARTING: 1,
STATUS_READY: 2,
STATUS_USER_CLOSED: 3,
STATUS_NOT_READY: 4,
// UA error codes
CONFIGURATION_ERROR: 1,
NETWORK_ERROR: 2,
ALLOWED_METHODS: [
'ACK',
'CANCEL',
'INVITE',
'MESSAGE',
'BYE',
'OPTIONS',
'INFO',
'NOTIFY',
'REFER'
],
ACCEPTED_BODY_TYPES: [
'application/sdp',
'application/dtmf-relay'
],
MAX_FORWARDS: 70,
TAG_LENGTH: 10
};
UA = function (configuration) {
var self = this;
// Helper function for forwarding events
function selfEmit(type) {
//registrationFailed handler is invoked with two arguments. Allow event handlers to be invoked with a variable no. of arguments
return self.emit.bind(self, type);
}
// Set Accepted Body Types
C.ACCEPTED_BODY_TYPES = C.ACCEPTED_BODY_TYPES.toString();
this.log = new SIP.LoggerFactory();
this.logger = this.getLogger('sip.ua');
this.cache = {
credentials: {}
};
this.configuration = {};
this.dialogs = {};
//User actions outside any session/dialog (MESSAGE)
this.applicants = {};
this.data = {};
this.sessions = {};
this.subscriptions = {};
this.earlySubscriptions = {};
this.publishers = {};
this.transport = null;
this.contact = null;
this.status = C.STATUS_INIT;
this.error = null;
this.transactions = {
nist: {},
nict: {},
ist: {},
ict: {}
};
Object.defineProperties(this, {
transactionsCount: {
get: function () {
var type, transactions = ['nist', 'nict', 'ist', 'ict'], count = 0;
for (type in transactions) {
count += Object.keys(this.transactions[transactions[type]]).length;
}
return count;
}
},
nictTransactionsCount: {
get: function () {
return Object.keys(this.transactions['nict']).length;
}
},
nistTransactionsCount: {
get: function () {
return Object.keys(this.transactions['nist']).length;
}
},
ictTransactionsCount: {
get: function () {
return Object.keys(this.transactions['ict']).length;
}
},
istTransactionsCount: {
get: function () {
return Object.keys(this.transactions['ist']).length;
}
}
});
/**
* Load configuration
*
* @throws {SIP.Exceptions.ConfigurationError}
* @throws {TypeError}
*/
if (configuration === undefined) {
configuration = {};
}
else if (typeof configuration === 'string' || configuration instanceof String) {
configuration = {
uri: configuration
};
}
// Apply log configuration if present
if (configuration.log) {
if (configuration.log.hasOwnProperty('builtinEnabled')) {
this.log.builtinEnabled = configuration.log.builtinEnabled;
}
if (configuration.log.hasOwnProperty('level')) {
this.log.level = configuration.log.level;
}
if (configuration.log.hasOwnProperty('connector')) {
this.log.connector = configuration.log.connector;
}
}
try {
this.loadConfig(configuration);
}
catch (e) {
this.status = C.STATUS_NOT_READY;
this.error = C.CONFIGURATION_ERROR;
throw e;
}
// Initialize registerContext
this.registerContext = new SIP.RegisterContext(this);
this.registerContext.on('failed', selfEmit('registrationFailed'));
this.registerContext.on('registered', selfEmit('registered'));
this.registerContext.on('unregistered', selfEmit('unregistered'));
if (this.configuration.autostart) {
this.start();
}
};
UA.prototype = Object.create(SIP.EventEmitter.prototype);
//=================
// High Level API
//=================
UA.prototype.register = function (options) {
this.configuration.register = true;
this.registerContext.register(options);
return this;
};
/**
* Unregister.
*
* @param {Boolean} [all] unregister all user bindings.
*
*/
UA.prototype.unregister = function (options) {
this.configuration.register = false;
var context = this.registerContext;
this.transport.afterConnected(context.unregister.bind(context, options));
return this;
};
UA.prototype.isRegistered = function () {
return this.registerContext.registered;
};
/**
* Make an outgoing call.
*
* @param {String} target
* @param {Object} views
* @param {Object} [options.media] gets passed to SIP.sessionDescriptionHandler.getDescription as mediaHint
*
* @throws {TypeError}
*
*/
UA.prototype.invite = function (target, options, modifiers) {
var context = new SIP.InviteClientContext(this, target, options, modifiers);
// Delay sending actual invite until the next 'tick' if we are already
// connected, so that API consumers can register to events fired by the
// the session.
this.transport.afterConnected(function () {
context.invite();
this.emit('inviteSent', context);
}.bind(this));
return context;
};
UA.prototype.subscribe = function (target, event, options) {
var sub = new SIP.Subscription(this, target, event, options);
this.transport.afterConnected(sub.subscribe.bind(sub));
return sub;
};
/**
* Send PUBLISH Event State Publication (RFC3903)
*
* @param {String} target
* @param {String} event
* @param {String} body
* @param {Object} [options]
*
* @throws {SIP.Exceptions.MethodParameterError}
*
*/
UA.prototype.publish = function (target, event, body, options) {
var pub = new SIP.PublishContext(this, target, event, options);
this.transport.afterConnected(pub.publish.bind(pub, body));
return pub;
};
/**
* Send a message.
*
* @param {String} target
* @param {String} body
* @param {Object} [options]
*
* @throws {TypeError}
*
*/
UA.prototype.message = function (target, body, options) {
if (body === undefined) {
throw new TypeError('Not enough arguments');
}
// There is no Message module, so it is okay that the UA handles defaults here.
options = Object.create(options || Object.prototype);
options.contentType || (options.contentType = 'text/plain');
options.body = body;
return this.request(SIP.C.MESSAGE, target, options);
};
UA.prototype.request = function (method, target, options) {
var req = new SIP.ClientContext(this, method, target, options);
this.transport.afterConnected(req.send.bind(req));
return req;
};
/**
* Gracefully close.
*
*/
UA.prototype.stop = function () {
var session, subscription, applicant, publisher, ua = this;
function transactionsListener() {
if (ua.nistTransactionsCount === 0 && ua.nictTransactionsCount === 0) {
ua.removeListener('transactionDestroyed', transactionsListener);
ua.transport.disconnect();
}
}
this.logger.log('user requested closure...');
if (this.status === C.STATUS_USER_CLOSED) {
this.logger.warn('UA already closed');
return this;
}
// Close registerContext
this.logger.log('closing registerContext');
this.registerContext.close();
// Run _terminate_ on every Session
for (session in this.sessions) {
this.logger.log('closing session ' + session);
this.sessions[session].terminate();
}
//Run _close_ on every confirmed Subscription
for (subscription in this.subscriptions) {
this.logger.log('unsubscribing from subscription ' + subscription);
this.subscriptions[subscription].close();
}
//Run _close_ on every early Subscription
for (subscription in this.earlySubscriptions) {
this.logger.log('unsubscribing from early subscription ' + subscription);
this.earlySubscriptions[subscription].close();
}
//Run _close_ on every Publisher
for (publisher in this.publishers) {
this.logger.log('unpublish ' + publisher);
this.publishers[publisher].close();
}
// Run _close_ on every applicant
for (applicant in this.applicants) {
this.applicants[applicant].close();
}
this.status = C.STATUS_USER_CLOSED;
/*
* If the remaining transactions are all INVITE transactions, there is no need to
* wait anymore because every session has already been closed by this method.
* - locally originated sessions where terminated (CANCEL or BYE)
* - remotely originated sessions where rejected (4XX) or terminated (BYE)
* Remaining INVITE transactions belong tho sessions that where answered. This are in
* 'accepted' state due to timers 'L' and 'M' defined in [RFC 6026]
*/
if (this.nistTransactionsCount === 0 && this.nictTransactionsCount === 0) {
this.transport.disconnect();
}
else {
this.on('transactionDestroyed', transactionsListener);
}
if (typeof environment.removeEventListener === 'function') {
// Google Chrome Packaged Apps don't allow 'unload' listeners:
// unload is not available in packaged apps
if (!(global.chrome && global.chrome.app && global.chrome.app.runtime)) {
environment.removeEventListener('unload', this.environListener);
}
}
return this;
};
/**
* Connect to the WS server if status = STATUS_INIT.
* Resume UA after being closed.
*
*/
UA.prototype.start = function () {
// var server;
this.logger.log('user requested startup...');
if (this.status === C.STATUS_INIT) {
this.status = C.STATUS_STARTING;
if (!this.configuration.transportConstructor) {
throw new SIP.Exceptions.TransportError("Transport constructor not set");
}
this.transport = new this.configuration.transportConstructor(this.getLogger('sip.transport'), this.configuration.transportOptions);
this.setTransportListeners();
this.emit('transportCreated', this.transport);
this.transport.connect();
}
else if (this.status === C.STATUS_USER_CLOSED) {
this.logger.log('resuming');
this.status = C.STATUS_READY;
this.transport.connect();
}
else if (this.status === C.STATUS_STARTING) {
this.logger.log('UA is in STARTING status, not opening new connection');
}
else if (this.status === C.STATUS_READY) {
this.logger.log('UA is in READY status, not resuming');
}
else {
this.logger.error('Connection is down. Auto-Recovery system is trying to connect');
}
if (this.configuration.autostop && typeof environment.addEventListener === 'function') {
// Google Chrome Packaged Apps don't allow 'unload' listeners:
// unload is not available in packaged apps
if (!(global.chrome && global.chrome.app && global.chrome.app.runtime)) {
this.environListener = this.stop.bind(this);
environment.addEventListener('unload', this.environListener);
}
}
return this;
};
/**
* Normalize a string into a valid SIP request URI
*
* @param {String} target
*
* @returns {SIP.URI|undefined}
*/
UA.prototype.normalizeTarget = function (target) {
return SIP.Utils.normalizeTarget(target, this.configuration.hostportParams);
};
//===============================
// Private (For internal use)
//===============================
UA.prototype.saveCredentials = function (credentials) {
this.cache.credentials[credentials.realm] = this.cache.credentials[credentials.realm] || {};
this.cache.credentials[credentials.realm][credentials.uri] = credentials;
return this;
};
UA.prototype.getCredentials = function (request) {
var realm, credentials;
realm = request.ruri.host;
if (this.cache.credentials[realm] && this.cache.credentials[realm][request.ruri]) {
credentials = this.cache.credentials[realm][request.ruri];
credentials.method = request.method;
}
return credentials;
};
UA.prototype.getLogger = function (category, label) {
return this.log.getLogger(category, label);
};
//==============================
// Event Handlers
//==============================
UA.prototype.onTransportError = function () {
if (this.status === C.STATUS_USER_CLOSED) {
return;
}
if (!this.error || this.error !== C.NETWORK_ERROR) {
this.status = C.STATUS_NOT_READY;
this.error = C.NETWORK_ERROR;
}
};
/**
* Helper function. Sets transport listeners
* @private
*/
UA.prototype.setTransportListeners = function () {
this.transport.on('connected', this.onTransportConnected.bind(this));
this.transport.on('message', this.onTransportReceiveMsg.bind(this));
this.transport.on('transportError', this.onTransportError.bind(this));
};
/**
* Transport connection event.
* @private
* @event
* @param {SIP.Transport} transport.
*/
UA.prototype.onTransportConnected = function () {
if (this.configuration.register) {
this.configuration.authenticationFactory.initialize().then(function () {
this.registerContext.onTransportConnected();
}.bind(this));
}
};
/**
* Transport message receipt event.
* @private
* @event
* @param {String} message
*/
UA.prototype.onTransportReceiveMsg = function (message) {
var transaction;
message = SIP.Parser.parseMessage(message, this);
if (this.status === SIP.UA.C.STATUS_USER_CLOSED && message instanceof SIP.IncomingRequest) {
this.logger.warn('UA received message when status = USER_CLOSED - aborting');
return;
}
// Do some sanity check
if (SIP.sanityCheck(message, this, this.transport)) {
if (message instanceof SIP.IncomingRequest) {
message.transport = this.transport;
this.receiveRequest(message);
}
else if (message instanceof SIP.IncomingResponse) {
/* Unike stated in 18.1.2, if a response does not match
* any transaction, it is discarded here and no passed to the core
* in order to be discarded there.
*/
switch (message.method) {
case SIP.C.INVITE:
transaction = this.transactions.ict[message.via_branch];
if (transaction) {
transaction.receiveResponse(message);
}
break;
case SIP.C.ACK:
// Just in case ;-)
break;
default:
transaction = this.transactions.nict[message.via_branch];
if (transaction) {
transaction.receiveResponse(message);
}
break;
}
}
}
};
/**
* new Transaction
* @private
* @param {SIP.Transaction} transaction.
*/
UA.prototype.newTransaction = function (transaction) {
this.transactions[transaction.type][transaction.id] = transaction;
this.emit('newTransaction', { transaction: transaction });
};
/**
* destroy Transaction
* @private
* @param {SIP.Transaction} transaction.
*/
UA.prototype.destroyTransaction = function (transaction) {
delete this.transactions[transaction.type][transaction.id];
this.emit('transactionDestroyed', {
transaction: transaction
});
};
//=========================
// receiveRequest
//=========================
/**
* Request reception
* @private
* @param {SIP.IncomingRequest} request.
*/
UA.prototype.receiveRequest = function (request) {
var dialog, session, message, earlySubscription, method = request.method, replaces, replacedDialog, self = this;
function ruriMatches(uri) {
return uri && uri.user === request.ruri.user;
}
// Check that request URI points to us
if (!(ruriMatches(this.configuration.uri) ||
ruriMatches(this.contact.uri) ||
ruriMatches(this.contact.pub_gruu) ||
ruriMatches(this.contact.temp_gruu))) {
this.logger.warn('Request-URI does not point to us');
if (request.method !== SIP.C.ACK) {
request.reply_sl(404);
}
return;
}
// Check request URI scheme
if (request.ruri.scheme === SIP.C.SIPS) {
request.reply_sl(416);
return;
}
// Check transaction
if (SIP.Transactions.checkTransaction(this, request)) {
return;
}
/* RFC3261 12.2.2
* Requests that do not change in any way the state of a dialog may be
* received within a dialog (for example, an OPTIONS request).
* They are processed as if they had been received outside the dialog.
*/
if (method === SIP.C.OPTIONS) {
new SIP.Transactions.NonInviteServerTransaction(request, this);
request.reply(200, null, [
'Allow: ' + SIP.UA.C.ALLOWED_METHODS.toString(),
'Accept: ' + C.ACCEPTED_BODY_TYPES
]);
}
else if (method === SIP.C.MESSAGE) {
message = new SIP.ServerContext(this, request);
message.body = request.body;
message.content_type = request.getHeader('Content-Type') || 'text/plain';
request.reply(200, null);
this.emit('message', message);
}
else if (method !== SIP.C.INVITE &&
method !== SIP.C.ACK) {
// Let those methods pass through to normal processing for now.
new SIP.ServerContext(this, request);
}
// Initial Request
if (!request.to_tag) {
switch (method) {
case SIP.C.INVITE:
replaces =
this.configuration.replaces !== SIP.C.supported.UNSUPPORTED &&
request.parseHeader('replaces');
if (replaces) {
replacedDialog = this.dialogs[replaces.call_id + replaces.replaces_to_tag + replaces.replaces_from_tag];
if (!replacedDialog) {
//Replaced header without a matching dialog, reject
request.reply_sl(481, null);
return;
}
else if (replacedDialog.owner.status === SIP.Session.C.STATUS_TERMINATED) {
request.reply_sl(603, null);
return;
}
else if (replacedDialog.state === SIP.Dialog.C.STATUS_CONFIRMED && replaces.early_only) {
request.reply_sl(486, null);
return;
}
}
session = new SIP.InviteServerContext(this, request);
session.replacee = replacedDialog && replacedDialog.owner;
self.emit('invite', session);
break;
case SIP.C.BYE:
// Out of dialog BYE received
request.reply(481);
break;
case SIP.C.CANCEL:
session = this.findSession(request);
if (session) {
session.receiveRequest(request);
}
else {
this.logger.warn('received CANCEL request for a non existent session');
}
break;
case SIP.C.ACK:
/* Absorb it.
* ACK request without a corresponding Invite Transaction
* and without To tag.
*/
break;
case SIP.C.NOTIFY:
if (this.configuration.allowLegacyNotifications && this.listeners('notify').length > 0) {
request.reply(200, null);
self.emit('notify', { request: request });
}
else {
request.reply(481, 'Subscription does not exist');
}
break;
case SIP.C.REFER:
this.logger.log('Received an out of dialog refer');
if (this.configuration.allowOutOfDialogRefers) {
this.logger.log('Allow out of dialog refers is enabled on the UA');
var referContext = new SIP.ReferServerContext(this, request);
var hasReferListener = this.listeners('outOfDialogReferRequested').length;
if (hasReferListener) {
this.emit('outOfDialogReferRequested', referContext);
}
else {
this.logger.log('No outOfDialogReferRequest listeners, automatically accepting and following the out of dialog refer');
referContext.accept({ followRefer: true });
}
break;
}
request.reply(405);
break;
default:
request.reply(405);
break;
}
}
// In-dialog request
else {
dialog = this.findDialog(request);
if (dialog) {
if (method === SIP.C.INVITE) {
new SIP.Transactions.InviteServerTransaction(request, this);
}
dialog.receiveRequest(request);
}
else if (method === SIP.C.NOTIFY) {
session = this.findSession(request);
earlySubscription = this.findEarlySubscription(request);
if (session) {
session.receiveRequest(request);
}
else if (earlySubscription) {
earlySubscription.receiveRequest(request);
}
else {
this.logger.warn('received NOTIFY request for a non existent session or subscription');
request.reply(481, 'Subscription does not exist');
}
}
/* RFC3261 12.2.2
* Request with to tag, but no matching dialog found.
* Exception: ACK for an Invite request for which a dialog has not
* been created.
*/
else {
if (method !== SIP.C.ACK) {
request.reply(481);
}
}
}
};
//=================
// Utils
//=================
/**
* Get the session to which the request belongs to, if any.
* @private
* @param {SIP.IncomingRequest} request.
* @returns {SIP.OutgoingSession|SIP.IncomingSession|null}
*/
UA.prototype.findSession = function (request) {
return this.sessions[request.call_id + request.from_tag] ||
this.sessions[request.call_id + request.to_tag] ||
null;
};
/**
* Get the dialog to which the request belongs to, if any.
* @private
* @param {SIP.IncomingRequest}
* @returns {SIP.Dialog|null}
*/
UA.prototype.findDialog = function (request) {
return this.dialogs[request.call_id + request.from_tag + request.to_tag] ||
this.dialogs[request.call_id + request.to_tag + request.from_tag] ||
null;
};
/**
* Get the subscription which has not been confirmed to which the request belongs to, if any
* @private
* @param {SIP.IncomingRequest}
* @returns {SIP.Subscription|null}
*/
UA.prototype.findEarlySubscription = function (request) {
return this.earlySubscriptions[request.call_id + request.to_tag + request.getHeader('event')] || null;
};
function checkAuthenticationFactory(authenticationFactory) {
if (!(authenticationFactory instanceof Function)) {
return;
}
if (!authenticationFactory.initialize) {
authenticationFactory.initialize = function initialize() {
return SIP.Utils.Promise.resolve();
};
}
return authenticationFactory;
}
/**
* Configuration load.
* @private
* returns {Boolean}
*/
UA.prototype.loadConfig = function (configuration) {
// Settings and default values
var parameter, value, checked_value, hostportParams, registrarServer, settings = {
/* Host address
* Value to be set in Via sent_by and host part of Contact FQDN
*/
viaHost: SIP.Utils.createRandomToken(12) + '.invalid',
uri: new SIP.URI('sip', 'anonymous.' + SIP.Utils.createRandomToken(6), 'anonymous.invalid', null, null),
//Custom Configuration Settings
custom: {},
//Display name
displayName: '',
// Password
password: null,
// Registration parameters
registerExpires: 600,
register: true,
registrarServer: null,
// Transport related parameters
transportConstructor: __webpack_require__(29)(SIP),
transportOptions: {},
//string to be inserted into User-Agent request header
userAgentString: SIP.C.USER_AGENT,
// Session parameters
noAnswerTimeout: 60,
// Hacks
hackViaTcp: false,
hackIpInContact: false,
hackWssInTransport: false,
hackAllowUnregisteredOptionTags: false,
// Session Description Handler Options
sessionDescriptionHandlerFactoryOptions: {
constraints: {},
peerConnectionOptions: {}
},
contactName: SIP.Utils.createRandomToken(8),
contactTransport: 'ws',
forceRport: false,
//autostarting
autostart: true,
autostop: true,
//Reliable Provisional Responses
rel100: SIP.C.supported.UNSUPPORTED,
// DTMF type: 'info' or 'rtp' (RFC 4733)
// RTP Payload Spec: https://tools.ietf.org/html/rfc4733
// WebRTC Audio Spec: https://tools.ietf.org/html/rfc7874
dtmfType: SIP.C.dtmfType.INFO,
// Replaces header (RFC 3891)
// http://tools.ietf.org/html/rfc3891
replaces: SIP.C.supported.UNSUPPORTED,
sessionDescriptionHandlerFactory: __webpack_require__(30)(SIP).defaultFactory,
authenticationFactory: checkAuthenticationFactory(function authenticationFactory(ua) {
return new SIP.DigestAuthentication(ua);
}),
allowLegacyNotifications: false,
allowOutOfDialogRefers: false,
};
// Pre-Configuration
function aliasUnderscored(parameter, logger) {
var underscored = parameter.replace(/([a-z][A-Z])/g, function (m) {
return m[0] + '_' + m[1].toLowerCase();
});
if (parameter === underscored) {
return;
}
var hasParameter = configuration.hasOwnProperty(parameter);
if (configuration.hasOwnProperty(underscored)) {
logger.warn(underscored + ' is deprecated, please use ' + parameter);
if (hasParameter) {
logger.warn(parameter + ' overriding ' + underscored);
}
}
configuration[parameter] = hasParameter ? configuration[parameter] : configuration[underscored];
}
var configCheck = this.getConfigurationCheck();
// Check Mandatory parameters
for (parameter in configCheck.mandatory) {
aliasUnderscored(parameter, this.logger);
if (!configuration.hasOwnProperty(parameter)) {
throw new SIP.Exceptions.ConfigurationError(parameter);
}
else {
value = configuration[parameter];
checked_value = configCheck.mandatory[parameter](value);
if (checked_value !== undefined) {
settings[parameter] = checked_value;
}
else {
throw new SIP.Exceptions.ConfigurationError(parameter, value);
}
}
}
// Check Optional parameters
for (parameter in configCheck.optional) {
aliasUnderscored(parameter, this.logger);
if (configuration.hasOwnProperty(parameter)) {
value = configuration[parameter];
// If the parameter value is an empty array, but shouldn't be, apply its default value.
if (value instanceof Array && value.length === 0) {
continue;
}
// If the parameter value is null, empty string, or undefined then apply its default value.
if (value === null || value === "" || value === undefined) {
continue;
}
// If it's a number with NaN value then also apply its default value.
// NOTE: JS does not allow "value === NaN", the following does the work:
else if (typeof (value) === 'number' && isNaN(value)) {
continue;
}
checked_value = configCheck.optional[parameter](value);
if (checked_value !== undefined) {
settings[parameter] = checked_value;
}
else {
throw new SIP.Exceptions.ConfigurationError(parameter, value);
}
}
}
// Post Configuration Process
// Allow passing 0 number as displayName.
if (settings.displayName === 0) {
settings.displayName = '0';
}
// Instance-id for GRUU
if (!settings.instanceId) {
settings.instanceId = SIP.Utils.newUUID();
}
// sipjsId instance parameter. Static random tag of length 5
settings.sipjsId = SIP.Utils.createRandomToken(5);
// String containing settings.uri without scheme and user.
hostportParams = settings.uri.clone();
hostportParams.user = null;
settings.hostportParams = hostportParams.toRaw().replace(/^sip:/i, '');
/* Check whether authorizationUser is explicitly defined.
* Take 'settings.uri.user' value if not.
*/
if (!settings.authorizationUser) {
settings.authorizationUser = settings.uri.user;
}
/* If no 'registrarServer' is set use the 'uri' value without user portion. */
if (!settings.registrarServer) {
registrarServer = settings.uri.clone();
registrarServer.user = null;
settings.registrarServer = registrarServer;
}
// User noAnswerTimeout
settings.noAnswerTimeout = settings.noAnswerTimeout * 1000;
// Via Host
if (settings.hackIpInContact) {
if (typeof settings.hackIpInContact === 'boolean') {
settings.viaHost = SIP.Utils.getRandomTestNetIP();
}
else if (typeof settings.hackIpInContact === 'string') {
settings.viaHost = settings.hackIpInContact;
}
}
// Contact transport parameter
if (settings.hackWssInTransport) {
settings.contactTransport = 'wss';
}
this.contact = {
pub_gruu: null,
temp_gruu: null,
uri: new SIP.URI('sip', settings.contactName, settings.viaHost, null, { transport: settings.contactTransport }),
toString: function (options) {
options = options || {};
var anonymous = options.anonymous || null, outbound = options.outbound || null, contact = '<';
if (anonymous) {
contact += (this.temp_gruu || ('sip:anonymous@anonymous.invalid;transport=' + settings.contactTransport)).toString();
}
else {
contact += (this.pub_gruu || this.uri).toString();
}
if (outbound) {
contact += ';ob';
}
contact += '>';
return contact;
}
};
var skeleton = {};
// Fill the value of the configuration_skeleton
for (parameter in settings) {
skeleton[parameter] = settings[parameter];
}
Object.assign(this.configuration, skeleton);
this.logger.log('configuration parameters after validation:');
for (parameter in settings) {
switch (parameter) {
case 'uri':
case 'registrarServer':
case 'sessionDescriptionHandlerFactory':
this.logger.log('· ' + parameter + ': ' + settings[parameter]);
break;
case 'password':
this.logger.log('· ' + parameter + ': ' + 'NOT SHOWN');
break;
case 'transportConstructor':
this.logger.log('· ' + parameter + ': ' + settings[parameter].name);
break;
default:
this.logger.log('· ' + parameter + ': ' + JSON.stringify(settings[parameter]));
}
}
return;
};
/**
* Configuration checker.
* @private
* @return {Boolean}
*/
UA.prototype.getConfigurationCheck = function () {
return {
mandatory: {},
optional: {
uri: function (uri) {
var parsed;
if (!(/^sip:/i).test(uri)) {
uri = SIP.C.SIP + ':' + uri;
}
parsed = SIP.URI.parse(uri);
if (!parsed) {
return;
}
else if (!parsed.user) {
return;
}
else {
return parsed;
}
},
transportConstructor: function (transportConstructor) {
if (transportConstructor instanceof Function) {
return transportConstructor;
}
},
transportOptions: function (transportOptions) {
if (typeof transportOptions === 'object') {
return transportOptions;
}
},
authorizationUser: function (authorizationUser) {
if (SIP.Grammar.parse('"' + authorizationUser + '"', 'quoted_string') === -1) {
return;
}
else {
return authorizationUser;
}
},
displayName: function (displayName) {
if (SIP.Grammar.parse('"' + displayName + '"', 'displayName') === -1) {
return;
}
else {
return displayName;
}
},
dtmfType: function (dtmfType) {
switch (dtmfType) {
case SIP.C.dtmfType.RTP:
return SIP.C.dtmfType.RTP;
case SIP.C.dtmfType.INFO:
// Fall through
default:
return SIP.C.dtmfType.INFO;
}
},
hackViaTcp: function (hackViaTcp) {
if (typeof hackViaTcp === 'boolean') {
return hackViaTcp;
}
},
hackIpInContact: function (hackIpInContact) {
if (typeof hackIpInContact === 'boolean') {
return hackIpInContact;
}
else if (typeof hackIpInContact === 'string' && SIP.Grammar.parse(hackIpInContact, 'host') !== -1) {
return hackIpInContact;
}
},
hackWssInTransport: function (hackWssInTransport) {
if (typeof hackWssInTransport === 'boolean') {
return hackWssInTransport;
}
},
hackAllowUnregisteredOptionTags: function (hackAllowUnregisteredOptionTags) {
if (typeof hackAllowUnregisteredOptionTags === 'boolean') {
return hackAllowUnregisteredOptionTags;
}
},
contactTransport: function (contactTransport) {
if (typeof contactTransport === 'string') {
return contactTransport;
}
},
forceRport: function (forceRport) {
if (typeof forceRport === 'boolean') {
return forceRport;
}
},
instanceId: function (instanceId) {
if (typeof instanceId !== 'string') {
return;
}
if ((/^uuid:/i.test(instanceId))) {
instanceId = instanceId.substr(5);
}
if (SIP.Grammar.parse(instanceId, 'uuid') === -1) {
return;
}
else {
return instanceId;
}
},
noAnswerTimeout: function (noAnswerTimeout) {
var value;
if (SIP.Utils.isDecimal(noAnswerTimeout)) {
value = Number(noAnswerTimeout);
if (value > 0) {
return value;
}
}
},
password: function (password) {
return String(password);
},
rel100: function (rel100) {
if (rel100 === SIP.C.supported.REQUIRED) {
return SIP.C.supported.REQUIRED;
}
else if (rel100 === SIP.C.supported.SUPPORTED) {
return SIP.C.supported.SUPPORTED;
}
else {
return SIP.C.supported.UNSUPPORTED;
}
},
replaces: function (replaces) {
if (replaces === SIP.C.supported.REQUIRED) {
return SIP.C.supported.REQUIRED;
}
else if (replaces === SIP.C.supported.SUPPORTED) {
return SIP.C.supported.SUPPORTED;
}
else {
return SIP.C.supported.UNSUPPORTED;
}
},
register: function (register) {
if (typeof register === 'boolean') {
return register;
}
},
registerExpires: function (registerExpires) {
var value;
if (SIP.Utils.isDecimal(registerExpires)) {
value = Number(registerExpires);
if (value > 0) {
return value;
}
}
},
registrarServer: function (registrarServer) {
var parsed;
if (typeof registrarServer !== 'string') {
return;
}
if (!/^sip:/i.test(registrarServer)) {
registrarServer = SIP.C.SIP + ':' + registrarServer;
}
parsed = SIP.URI.parse(registrarServer);
if (!parsed) {
return;
}
else if (parsed.user) {
return;
}
else {
return parsed;
}
},
userAgentString: function (userAgentString) {
if (typeof userAgentString === 'string') {
return userAgentString;
}
},
autostart: function (autostart) {
if (typeof autostart === 'boolean') {
return autostart;
}
},
autostop: function (autostop) {
if (typeof autostop === 'boolean') {
return autostop;
}
},
sessionDescriptionHandlerFactory: function (sessionDescriptionHandlerFactory) {
if (sessionDescriptionHandlerFactory instanceof Function) {
return sessionDescriptionHandlerFactory;
}
},
sessionDescriptionHandlerFactoryOptions: function (options) {
if (typeof options === 'object') {
return options;
}
},
authenticationFactory: checkAuthenticationFactory,
allowLegacyNotifications: function (allowLegacyNotifications) {
if (typeof allowLegacyNotifications === 'boolean') {
return allowLegacyNotifications;
}
},
custom: function (custom) {
if (typeof custom === 'object') {
return custom;
}
},
contactName: function (contactName) {
if (typeof contactName === 'string') {
return contactName;
}
},
}
};
};
UA.C = C;
SIP.UA = UA;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)))
/***/ }),
/* 28 */
/***/ (function(module, exports) {
var g;
// This works in non-strict mode
g = (function() {
return this;
})();
try {
// This works if eval is allowed (see CSP)
g = g || Function("return this")() || (1, eval)("this");
} catch (e) {
// This works if the window reference is available
if (typeof window === "object") g = window;
}
// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}
module.exports = g;
/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
/**
* @fileoverview Transport
*/
/**
* @augments SIP
* @class Transport
* @param {Object} options
*/
module.exports = function (SIP) {
var Transport, C = {
// Transport status codes
STATUS_CONNECTING: 0,
STATUS_OPEN: 1,
STATUS_CLOSING: 2,
STATUS_CLOSED: 3,
};
var WebSocket = (global.window || global).WebSocket;
/**
* Compute an amount of time in seconds to wait before sending another
* keep-alive.
* @returns {Number}
*/
function computeKeepAliveTimeout(upperBound) {
var lowerBound = upperBound * 0.8;
return 1000 * (Math.random() * (upperBound - lowerBound) + lowerBound);
}
Transport = function (logger, options) {
options = SIP.Utils.defaultOptions({}, options);
this.logger = logger;
this.ws = null;
this.server = null;
this.connectionPromise = null;
this.connectDeferredResolve = null;
this.connectionTimeout = null;
this.disconnectionPromise = null;
this.disconnectDeferredResolve = null;
this.boundOnOpen = null;
this.boundOnMessage = null;
this.boundOnClose = null;
this.boundOnError = null;
this.reconnectionAttempts = 0;
this.reconnectTimer = null;
// Keep alive
this.keepAliveInterval = null;
this.keepAliveDebounceTimeout = null;
this.status = C.STATUS_CONNECTING;
this.configuration = {};
this.loadConfig(options);
};
Transport.prototype = Object.create(SIP.Transport.prototype, {
/**
*
* @returns {Boolean}
*/
isConnected: { writable: true, value: function isConnected() {
return this.status === C.STATUS_OPEN;
} },
/**
* Send a message.
* @param {SIP.OutgoingRequest|String} msg
* @param {Object} [options]
* @returns {Promise}
*/
sendPromise: { writable: true, value: function sendPromise(msg, options) {
options = options || {};
if (!this.statusAssert(C.STATUS_OPEN, options.force)) {
this.onError('unable to send message - WebSocket not open');
return SIP.Utils.Promise.reject();
}
var message = msg.toString();
if (this.ws) {
if (this.configuration.traceSip === true) {
this.logger.log('sending WebSocket message:\n\n' + message + '\n');
}
this.ws.send(message);
return SIP.Utils.Promise.resolve({ msg: message });
}
else {
this.onError('unable to send message - WebSocket does not exist');
return SIP.Utils.Promise.reject();
}
} },
/**
* Disconnect socket.
*/
disconnectPromise: { writable: true, value: function disconnectPromise(options) {
if (this.disconnectionPromise) {
return this.disconnectionPromise;
}
options = options || {};
if (!this.statusTransition(C.STATUS_CLOSING, options.force)) {
return SIP.Utils.Promise.reject('Failed status transition - attempted to disconnect a socket that was not open');
}
this.disconnectionPromise = new SIP.Utils.Promise(function (resolve, reject) {
this.disconnectDeferredResolve = resolve;
if (this.reconnectTimer) {
SIP.Timers.clearTimeout(this.reconnectTimer);
this.reconnectTimer = null;
}
if (this.ws) {
this.stopSendingKeepAlives();
this.logger.log('closing WebSocket ' + this.server.ws_uri);
this.ws.close(options.code, options.reason);
}
else {
reject('Attempted to disconnect but the websocket doesn\'t exist');
}
}.bind(this));
return this.disconnectionPromise;
} },
/**
* Connect socket.
*/
connectPromise: { writable: true, value: function connectPromise(options) {
if (this.connectionPromise) {
return this.connectionPromise;
}
options = options || {};
this.server = this.server || this.getNextWsServer(options.force);
this.connectionPromise = new SIP.Utils.Promise(function (resolve, reject) {
if ((this.status === C.STATUS_OPEN || this.status === C.STATUS_CLOSING) && !options.force) {
this.logger.warn('WebSocket ' + this.server.ws_uri + ' is already connected');
reject('Failed status check - attempted to open a connection but already open/closing');
return;
}
this.connectDeferredResolve = resolve;
this.status = C.STATUS_CONNECTING;
this.logger.log('connecting to WebSocket ' + this.server.ws_uri);
this.disposeWs();
try {
this.ws = new WebSocket(this.server.ws_uri, 'sip');
}
catch (e) {
this.ws = null;
this.status = C.STATUS_CLOSED; // force status to closed in error case
this.onError('error connecting to WebSocket ' + this.server.ws_uri + ':' + e);
reject('Failed to create a websocket');
return;
}
if (!this.ws) {
reject('Unexpected instance websocket not set');
return;
}
this.connectionTimeout = SIP.Timers.setTimeout(function () {
this.onError('took too long to connect - exceeded time set in configuration.connectionTimeout: ' + this.configuration.connectionTimeout + 's');
}.bind(this), this.configuration.connectionTimeout * 1000);
this.boundOnOpen = this.onOpen.bind(this);
this.boundOnMessage = this.onMessage.bind(this);
this.boundOnClose = this.onClose.bind(this);
this.boundOnError = this.onError.bind(this);
this.ws.addEventListener('open', this.boundOnOpen);
this.ws.addEventListener('message', this.boundOnMessage);
this.ws.addEventListener('close', this.boundOnClose);
this.ws.addEventListener('error', this.boundOnError);
}.bind(this));
return this.connectionPromise;
} },
// Transport Event Handlers
/**
* @event
* @param {event} e
*/
onOpen: { writable: true, value: function onOpen() {
this.status = C.STATUS_OPEN; // quietly force status to open
this.emit('connected');
SIP.Timers.clearTimeout(this.connectionTimeout);
this.logger.log('WebSocket ' + this.server.ws_uri + ' connected');
// Clear reconnectTimer since we are not disconnected
if (this.reconnectTimer !== null) {
SIP.Timers.clearTimeout(this.reconnectTimer);
this.reconnectTimer = null;
}
// Reset reconnectionAttempts
this.reconnectionAttempts = 0;
// Reset disconnection promise so we can disconnect from a fresh state
this.disconnectionPromise = null;
this.disconnectDeferredResolve = null;
// Start sending keep-alives
this.startSendingKeepAlives();
if (this.connectDeferredResolve) {
this.connectDeferredResolve({ overrideEvent: true });
}
else {
this.logger.warn('Unexpected websocket.onOpen with no connectDeferredResolve');
}
} },
/**
* @event
* @param {event} e
*/
onClose: { writable: true, value: function onClose(e) {
this.logger.log('WebSocket disconnected (code: ' + e.code + (e.reason ? '| reason: ' + e.reason : '') + ')');
this.emit('disconnected', { code: e.code, reason: e.reason });
if (this.status !== C.STATUS_CLOSING) {
this.logger.warn('WebSocket abrupt disconnection');
this.emit('transportError');
}
this.stopSendingKeepAlives();
// Clean up connection variables so we can connect again from a fresh state
SIP.Timers.clearTimeout(this.connectionTimeout);
this.connectionTimeout = null;
this.connectionPromise = null;
this.connectDeferredResolve = null;
// Check whether the user requested to close.
if (this.disconnectDeferredResolve) {
this.disconnectDeferredResolve({ overrideEvent: true });
this.statusTransition(C.STATUS_CLOSED);
this.disconnectDeferredResolve = null;
return;
}
this.status = C.STATUS_CLOSED; // quietly force status to closed
this.reconnect();
} },
/**
* Removes event listeners and clears the instance ws
* @private
* @param {event} e
*/
disposeWs: { writable: true, value: function disposeWs() {
if (this.ws) {
this.ws.removeEventListener('open', this.boundOnOpen);
this.ws.removeEventListener('message', this.boundOnMessage);
this.ws.removeEventListener('close', this.boundOnClose);
this.ws.removeEventListener('error', this.boundOnError);
this.boundOnOpen = null;
this.boundOnMessage = null;
this.boundOnClose = null;
this.boundOnError = null;
this.ws = null;
}
} },
/**
* @event
* @param {event} e
*/
onMessage: { writable: true, value: function onMessage(e) {
var data = e.data;
// CRLF Keep Alive response from server. Clear our keep alive timeout.
if (/^(\r\n)+$/.test(data)) {
this.clearKeepAliveTimeout();
if (this.configuration.traceSip === true) {
this.logger.log('received WebSocket message with CRLF Keep Alive response');
}
return;
}
else if (!data) {
this.logger.warn('received empty message, message discarded');
return;
}
// WebSocket binary message.
else if (typeof data !== 'string') {
try {
data = String.fromCharCode.apply(null, new Uint8Array(data));
}
catch (err) {
this.logger.warn('received WebSocket binary message failed to be converted into string, message discarded');
return;
}
if (this.configuration.traceSip === true) {
this.logger.log('received WebSocket binary message:\n\n' + data + '\n');
}
}
// WebSocket text message.
else {
if (this.configuration.traceSip === true) {
this.logger.log('received WebSocket text message:\n\n' + data + '\n');
}
}
this.emit('message', data);
} },
/**
* @event
* @param {event} e
*/
onError: { writable: true, value: function onError(e) {
this.logger.warn('Transport error: ' + e);
this.emit('transportError');
} },
/**
* Reconnection attempt logic.
* @private
*/
reconnect: { writable: true, value: function reconnect() {
if (this.reconnectionAttempts > 0) {
this.logger.log('Reconnection attempt ' + this.reconnectionAttempts + ' failed');
}
if (this.noAvailableServers()) {
this.logger.warn('no available ws servers left - going to closed state');
this.status = C.STATUS_CLOSED;
this.emit('closed');
this.resetServerErrorStatus();
return;
}
if (this.isConnected()) {
this.logger.warn('attempted to reconnect while connected - forcing disconnect');
this.disconnect({ force: true });
}
this.reconnectionAttempts += 1;
if (this.reconnectionAttempts > this.configuration.maxReconnectionAttempts) {
this.logger.warn('maximum reconnection attempts for WebSocket ' + this.server.ws_uri);
this.logger.log('transport ' + this.server.ws_uri + ' failed | connection state set to \'error\'');
this.server.isError = true;
this.emit('transportError');
this.server = this.getNextWsServer();
this.reconnectionAttempts = 0;
this.reconnect();
}
else {
this.logger.log('trying to reconnect to WebSocket ' + this.server.ws_uri + ' (reconnection attempt ' + this.reconnectionAttempts + ')');
this.reconnectTimer = SIP.Timers.setTimeout(function () {
this.connect();
this.reconnectTimer = null;
}.bind(this), (this.reconnectionAttempts === 1) ? 0 : this.configuration.reconnectionTimeout * 1000);
}
} },
/**
* Resets the error state of all servers in the configuration
*/
resetServerErrorStatus: { writable: true, value: function resetServerErrorStatus() {
var idx, length = this.configuration.wsServers.length;
for (idx = 0; idx < length; idx++) {
this.configuration.wsServers[idx].isError = false;
}
} },
/**
* Retrieve the next server to which connect.
* @private
* @param {Boolean} force allows bypass of server error status checking
* @returns {Object} wsServer
*/
getNextWsServer: { writable: true, value: function getNextWsServer(force) {
if (this.noAvailableServers()) {
this.logger.warn('attempted to get next ws server but there are no available ws servers left');
return;
}
// Order servers by weight
var idx, length, wsServer, candidates = [];
length = this.configuration.wsServers.length;
for (idx = 0; idx < length; idx++) {
wsServer = this.configuration.wsServers[idx];
if (wsServer.isError && !force) {
continue;
}
else if (candidates.length === 0) {
candidates.push(wsServer);
}
else if (wsServer.weight > candidates[0].weight) {
candidates = [wsServer];
}
else if (wsServer.weight === candidates[0].weight) {
candidates.push(wsServer);
}
}
idx = Math.floor(Math.random() * candidates.length);
return candidates[idx];
} },
/**
* Checks all configuration servers, returns true if all of them have isError: true and false otherwise
* @private
* @returns {Boolean}
*/
noAvailableServers: { writable: true, value: function noAvailableServers() {
var server;
for (server in this.configuration.wsServers) {
if (!this.configuration.wsServers[server].isError) {
return false;
}
}
return true;
} },
//==============================
// KeepAlive Stuff
//==============================
/**
* Send a keep-alive (a double-CRLF sequence).
* @private
* @returns {Boolean}
*/
sendKeepAlive: { writable: true, value: function sendKeepAlive() {
if (this.keepAliveDebounceTimeout) {
// We already have an outstanding keep alive, do not send another.
return;
}
this.keepAliveDebounceTimeout = SIP.Timers.setTimeout(function () {
this.emit('keepAliveDebounceTimeout');
this.clearKeepAliveTimeout();
}.bind(this), this.configuration.keepAliveDebounce * 1000);
return this.send('\r\n\r\n');
} },
clearKeepAliveTimeout: { writable: true, value: function clearKeepAliveTimeout() {
SIP.Timers.clearTimeout(this.keepAliveDebounceTimeout);
this.keepAliveDebounceTimeout = null;
} },
/**
* Start sending keep-alives.
* @private
*/
startSendingKeepAlives: { writable: true, value: function startSendingKeepAlives() {
if (this.configuration.keepAliveInterval && !this.keepAliveInterval) {
this.keepAliveInterval = SIP.Timers.setInterval(function () {
this.sendKeepAlive();
this.startSendingKeepAlives();
}.bind(this), computeKeepAliveTimeout(this.configuration.keepAliveInterval));
}
} },
/**
* Stop sending keep-alives.
* @private
*/
stopSendingKeepAlives: { writable: true, value: function stopSendingKeepAlives() {
SIP.Timers.clearInterval(this.keepAliveInterval);
SIP.Timers.clearTimeout(this.keepAliveDebounceTimeout);
this.keepAliveInterval = null;
this.keepAliveDebounceTimeout = null;
} },
//==============================
// Status Stuff
//==============================
/**
* Checks given status against instance current status. Returns true if they match
* @private
* @param {Number} status
* @param {Boolean} [force]
* @returns {Boolean}
*/
statusAssert: { writable: true, value: function statusAssert(status, force) {
if (status === this.status) {
return true;
}
else {
if (force) {
this.logger.warn('Attempted to assert ' + Object.keys(C)[this.status] + ' as ' + Object.keys(C)[status] + '- continuing with option: \'force\'');
return true;
}
else {
this.logger.warn('Tried to assert ' + Object.keys(C)[status] + ' but is currently ' + Object.keys(C)[this.status]);
return false;
}
}
} },
/**
* Transitions the status. Checks for legal transition via assertion beforehand
* @private
* @param {Number} status
* @param {Boolean} [force]
* @returns {Boolean}
*/
statusTransition: { writable: true, value: function statusTransition(status, force) {
this.logger.log('Attempting to transition status from ' + Object.keys(C)[this.status] + ' to ' + Object.keys(C)[status]);
if ((status === C.STATUS_OPEN && this.statusAssert(C.STATUS_CONNECTING, force)) ||
(status === C.STATUS_CLOSING && this.statusAssert(C.STATUS_OPEN, force)) ||
(status === C.STATUS_CLOSED && this.statusAssert(C.STATUS_CLOSING, force))) {
this.status = status;
return true;
}
else {
this.logger.warn('Status transition failed - result: no-op - reason: either gave an nonexistent status or attempted illegal transition');
return false;
}
} },
//==============================
// Configuration Handling
//==============================
/**
* Configuration load.
* @private
* returns {Boolean}
*/
loadConfig: { writable: true, value: function loadConfig(configuration) {
var parameter, value, checked_value, settings = {
wsServers: [{
scheme: 'WSS',
sip_uri: '<sip:edge.sip.onsip.com;transport=ws;lr>',
weight: 0,
ws_uri: 'wss://edge.sip.onsip.com',
isError: false
}],
connectionTimeout: 5,
maxReconnectionAttempts: 3,
reconnectionTimeout: 4,
keepAliveInterval: 0,
keepAliveDebounce: 10,
// Logging
traceSip: false,
};
// Pre-Configuration
function aliasUnderscored(parameter, logger) {
var underscored = parameter.replace(/([a-z][A-Z])/g, function (m) {
return m[0] + '_' + m[1].toLowerCase();
});
if (parameter === underscored) {
return;
}
var hasParameter = configuration.hasOwnProperty(parameter);
if (configuration.hasOwnProperty(underscored)) {
logger.warn(underscored + ' is deprecated, please use ' + parameter);
if (hasParameter) {
logger.warn(parameter + ' overriding ' + underscored);
}
}
configuration[parameter] = hasParameter ? configuration[parameter] : configuration[underscored];
}
var configCheck = this.getConfigurationCheck();
// Check Mandatory parameters
for (parameter in configCheck.mandatory) {
aliasUnderscored(parameter, this.logger);
if (!configuration.hasOwnProperty(parameter)) {
throw new SIP.Exceptions.ConfigurationError(parameter);
}
else {
value = configuration[parameter];
checked_value = configCheck.mandatory[parameter](value);
if (checked_value !== undefined) {
settings[parameter] = checked_value;
}
else {
throw new SIP.Exceptions.ConfigurationError(parameter, value);
}
}
}
// Check Optional parameters
for (parameter in configCheck.optional) {
aliasUnderscored(parameter, this.logger);
if (configuration.hasOwnProperty(parameter)) {
value = configuration[parameter];
// If the parameter value is an empty array, but shouldn't be, apply its default value.
if (value instanceof Array && value.length === 0) {
continue;
}
// If the parameter value is null, empty string, or undefined then apply its default value.
if (value === null || value === '' || value === undefined) {
continue;
}
// If it's a number with NaN value then also apply its default value.
// NOTE: JS does not allow "value === NaN", the following does the work:
else if (typeof (value) === 'number' && isNaN(value)) {
continue;
}
checked_value = configCheck.optional[parameter](value);
if (checked_value !== undefined) {
settings[parameter] = checked_value;
}
else {
throw new SIP.Exceptions.ConfigurationError(parameter, value);
}
}
}
var skeleton = {};
// Fill the value of the configuration_skeleton
for (parameter in settings) {
skeleton[parameter] = {
value: settings[parameter],
};
}
Object.defineProperties(this.configuration, skeleton);
this.logger.log('configuration parameters after validation:');
for (parameter in settings) {
this.logger.log('· ' + parameter + ': ' + JSON.stringify(settings[parameter]));
}
return;
} },
/**
* Configuration checker.
* @private
* @return {Boolean}
*/
getConfigurationCheck: { writable: true, value: function getConfigurationCheck() {
return {
mandatory: {},
optional: {
//Note: this function used to call 'this.logger.error' but calling 'this' with anything here is invalid
wsServers: function (wsServers) {
var idx, length, url;
/* Allow defining wsServers parameter as:
* String: "host"
* Array of Strings: ["host1", "host2"]
* Array of Objects: [{ws_uri:"host1", weight:1}, {ws_uri:"host2", weight:0}]
* Array of Objects and Strings: [{ws_uri:"host1"}, "host2"]
*/
if (typeof wsServers === 'string') {
wsServers = [{ ws_uri: wsServers }];
}
else if (wsServers instanceof Array) {
length = wsServers.length;
for (idx = 0; idx < length; idx++) {
if (typeof wsServers[idx] === 'string') {
wsServers[idx] = { ws_uri: wsServers[idx] };
}
}
}
else {
return;
}
if (wsServers.length === 0) {
return false;
}
length = wsServers.length;
for (idx = 0; idx < length; idx++) {
if (!wsServers[idx].ws_uri) {
return;
}
if (wsServers[idx].weight && !Number(wsServers[idx].weight)) {
return;
}
url = SIP.Grammar.parse(wsServers[idx].ws_uri, 'absoluteURI');
if (url === -1) {
return;
}
else if (['wss', 'ws', 'udp'].indexOf(url.scheme) < 0) {
return;
}
else {
wsServers[idx].sip_uri = '<sip:' + url.host + (url.port ? ':' + url.port : '') + ';transport=' + url.scheme.replace(/^wss$/i, 'ws') + ';lr>';
if (!wsServers[idx].weight) {
wsServers[idx].weight = 0;
}
wsServers[idx].isError = false;
wsServers[idx].scheme = url.scheme.toUpperCase();
}
}
return wsServers;
},
keepAliveInterval: function (keepAliveInterval) {
var value;
if (SIP.Utils.isDecimal(keepAliveInterval)) {
value = Number(keepAliveInterval);
if (value > 0) {
return value;
}
}
},
keepAliveDebounce: function (keepAliveDebounce) {
var value;
if (SIP.Utils.isDecimal(keepAliveDebounce)) {
value = Number(keepAliveDebounce);
if (value > 0) {
return value;
}
}
},
traceSip: function (traceSip) {
if (typeof traceSip === 'boolean') {
return traceSip;
}
},
connectionTimeout: function (connectionTimeout) {
var value;
if (SIP.Utils.isDecimal(connectionTimeout)) {
value = Number(connectionTimeout);
if (value > 0) {
return value;
}
}
},
maxReconnectionAttempts: function (maxReconnectionAttempts) {
var value;
if (SIP.Utils.isDecimal(maxReconnectionAttempts)) {
value = Number(maxReconnectionAttempts);
if (value >= 0) {
return value;
}
}
},
reconnectionTimeout: function (reconnectionTimeout) {
var value;
if (SIP.Utils.isDecimal(reconnectionTimeout)) {
value = Number(reconnectionTimeout);
if (value > 0) {
return value;
}
}
}
}
};
} }
});
Transport.C = C;
SIP.Web.Transport = Transport;
return Transport;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)))
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
/**
* @fileoverview SessionDescriptionHandler
*/
/* SessionDescriptionHandler
* @class PeerConnection helper Class.
* @param {SIP.Session} session
* @param {Object} [options]
*/
module.exports = function (SIP) {
// Constructor
var SessionDescriptionHandler = function (logger, observer, options) {
// TODO: Validate the options
this.options = options || {};
this.logger = logger;
this.observer = observer;
this.dtmfSender = null;
this.shouldAcquireMedia = true;
this.CONTENT_TYPE = 'application/sdp';
this.C = {};
this.C.DIRECTION = {
NULL: null,
SENDRECV: "sendrecv",
SENDONLY: "sendonly",
RECVONLY: "recvonly",
INACTIVE: "inactive"
};
this.logger.log('SessionDescriptionHandlerOptions: ' + JSON.stringify(this.options));
this.direction = this.C.DIRECTION.NULL;
this.modifiers = this.options.modifiers || [];
if (!Array.isArray(this.modifiers)) {
this.modifiers = [this.modifiers];
}
var environment = global.window || global;
this.WebRTC = {
MediaStream: environment.MediaStream,
getUserMedia: environment.navigator.mediaDevices.getUserMedia.bind(environment.navigator.mediaDevices),
RTCPeerConnection: environment.RTCPeerConnection
};
this.iceGatheringDeferred = null;
this.iceGatheringTimeout = false;
this.iceGatheringTimer = null;
this.initPeerConnection(this.options.peerConnectionOptions);
this.constraints = this.checkAndDefaultConstraints(this.options.constraints);
};
/**
* @param {SIP.Session} session
* @param {Object} [options]
*/
SessionDescriptionHandler.defaultFactory = function defaultFactory(session, options) {
var logger = session.ua.getLogger('sip.invitecontext.sessionDescriptionHandler', session.id);
var SessionDescriptionHandlerObserver = __webpack_require__(31);
var observer = new SessionDescriptionHandlerObserver(session, options);
return new SessionDescriptionHandler(logger, observer, options);
};
SessionDescriptionHandler.prototype = Object.create(SIP.SessionDescriptionHandler.prototype, {
// Functions the sesssion can use
/**
* Destructor
*/
close: { writable: true, value: function () {
this.logger.log('closing PeerConnection');
// have to check signalingState since this.close() gets called multiple times
if (this.peerConnection && this.peerConnection.signalingState !== 'closed') {
if (this.peerConnection.getSenders) {
this.peerConnection.getSenders().forEach(function (sender) {
if (sender.track) {
sender.track.stop();
}
});
}
else {
this.logger.warn('Using getLocalStreams which is deprecated');
this.peerConnection.getLocalStreams().forEach(function (stream) {
stream.getTracks().forEach(function (track) {
track.stop();
});
});
}
if (this.peerConnection.getReceivers) {
this.peerConnection.getReceivers().forEach(function (receiver) {
if (receiver.track) {
receiver.track.stop();
}
});
}
else {
this.logger.warn('Using getRemoteStreams which is deprecated');
this.peerConnection.getRemoteStreams().forEach(function (stream) {
stream.getTracks().forEach(function (track) {
track.stop();
});
});
}
this.resetIceGatheringComplete();
this.peerConnection.close();
}
} },
/**
* Gets the local description from the underlying media implementation
* @param {Object} [options] Options object to be used by getDescription
* @param {MediaStreamConstraints} [options.constraints] MediaStreamConstraints https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamConstraints
* @param {Object} [options.peerConnectionOptions] If this is set it will recreate the peer connection with the new options
* @param {Array} [modifiers] Array with one time use description modifiers
* @returns {Promise} Promise that resolves with the local description to be used for the session
*/
getDescription: { writable: true, value: function (options, modifiers) {
options = options || {};
if (options.peerConnectionOptions) {
this.initPeerConnection(options.peerConnectionOptions);
}
// Merge passed constraints with saved constraints and save
var newConstraints = Object.assign({}, this.constraints, options.constraints);
newConstraints = this.checkAndDefaultConstraints(newConstraints);
if (JSON.stringify(newConstraints) !== JSON.stringify(this.constraints)) {
this.constraints = newConstraints;
this.shouldAcquireMedia = true;
}
modifiers = modifiers || [];
if (!Array.isArray(modifiers)) {
modifiers = [modifiers];
}
modifiers = modifiers.concat(this.modifiers);
return SIP.Utils.Promise.resolve()
.then(function () {
if (this.shouldAcquireMedia) {
return this.acquire(this.constraints).then(function () {
this.shouldAcquireMedia = false;
}.bind(this));
}
}.bind(this))
.then(function () {
return this.createOfferOrAnswer(options.RTCOfferOptions, modifiers);
}.bind(this))
.then(function (description) {
this.emit('getDescription', description);
return {
body: description.sdp,
contentType: this.CONTENT_TYPE
};
}.bind(this));
} },
/**
* Check if the Session Description Handler can handle the Content-Type described by a SIP Message
* @param {String} contentType The content type that is in the SIP Message
* @returns {boolean}
*/
hasDescription: { writable: true, value: function hasDescription(contentType) {
return contentType === this.CONTENT_TYPE;
} },
/**
* The modifier that should be used when the session would like to place the call on hold
* @param {String} [sdp] The description that will be modified
* @returns {Promise} Promise that resolves with modified SDP
*/
holdModifier: { writable: true, value: function holdModifier(description) {
if (!(/a=(sendrecv|sendonly|recvonly|inactive)/).test(description.sdp)) {
description.sdp = description.sdp.replace(/(m=[^\r]*\r\n)/g, '$1a=sendonly\r\n');
}
else {
description.sdp = description.sdp.replace(/a=sendrecv\r\n/g, 'a=sendonly\r\n');
description.sdp = description.sdp.replace(/a=recvonly\r\n/g, 'a=inactive\r\n');
}
return SIP.Utils.Promise.resolve(description);
} },
/**
* Set the remote description to the underlying media implementation
* @param {String} sessionDescription The description provided by a SIP message to be set on the media implementation
* @param {Object} [options] Options object to be used by getDescription
* @param {MediaStreamConstraints} [options.constraints] MediaStreamConstraints https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamConstraints
* @param {Object} [options.peerConnectionOptions] If this is set it will recreate the peer connection with the new options
* @param {Array} [modifiers] Array with one time use description modifiers
* @returns {Promise} Promise that resolves once the description is set
*/
setDescription: { writable: true, value: function setDescription(sessionDescription, options, modifiers) {
var _this = this;
var self = this;
options = options || {};
if (options.peerConnectionOptions) {
this.initPeerConnection(options.peerConnectionOptions);
}
modifiers = modifiers || [];
if (!Array.isArray(modifiers)) {
modifiers = [modifiers];
}
modifiers = modifiers.concat(this.modifiers);
var description = {
type: this.hasOffer('local') ? 'answer' : 'offer',
sdp: sessionDescription
};
return SIP.Utils.Promise.resolve()
.then(function () {
// Media should be acquired in getDescription unless we need to do it sooner for some reason (FF61+)
if (this.shouldAcquireMedia && this.options.alwaysAcquireMediaFirst) {
return this.acquire(this.constraints).then(function () {
this.shouldAcquireMedia = false;
}.bind(this));
}
}.bind(this))
.then(function () {
return SIP.Utils.reducePromises(modifiers, description);
})
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("setDescription", e, "The modifiers did not resolve successfully");
_this.logger.error(error.message);
self.emit('peerConnection-setRemoteDescriptionFailed', error);
throw error;
})
.then(function (modifiedDescription) {
self.emit('setDescription', modifiedDescription);
return self.peerConnection.setRemoteDescription(modifiedDescription);
})
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
// Check the original SDP for video, and ensure that we have want to do audio fallback
if ((/^m=video.+$/gm).test(sessionDescription) && !options.disableAudioFallback) {
// Do not try to audio fallback again
options.disableAudioFallback = true;
// Remove video first, then do the other modifiers
return _this.setDescription(sessionDescription, options, [SIP.Web.Modifiers.stripVideo].concat(modifiers));
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("setDescription", e);
_this.logger.error(error.error);
_this.emit('peerConnection-setRemoteDescriptionFailed', error);
throw error;
})
.then(function setRemoteDescriptionSuccess() {
if (self.peerConnection.getReceivers) {
self.emit('setRemoteDescription', self.peerConnection.getReceivers());
}
else {
self.emit('setRemoteDescription', self.peerConnection.getRemoteStreams());
}
self.emit('confirmed', self);
});
} },
/**
* Send DTMF via RTP (RFC 4733)
* @param {String} tones A string containing DTMF digits
* @param {Object} [options] Options object to be used by sendDtmf
* @returns {boolean} true if DTMF send is successful, false otherwise
*/
sendDtmf: { writable: true, value: function sendDtmf(tones, options) {
if (!this.dtmfSender && this.hasBrowserGetSenderSupport()) {
var senders = this.peerConnection.getSenders();
if (senders.length > 0) {
this.dtmfSender = senders[0].dtmf;
}
}
if (!this.dtmfSender && this.hasBrowserTrackSupport()) {
var streams = this.peerConnection.getLocalStreams();
if (streams.length > 0) {
var audioTracks = streams[0].getAudioTracks();
if (audioTracks.length > 0) {
this.dtmfSender = this.peerConnection.createDTMFSender(audioTracks[0]);
}
}
}
if (!this.dtmfSender) {
return false;
}
try {
this.dtmfSender.insertDTMF(tones, options.duration, options.interToneGap);
}
catch (e) {
if (e.type === "InvalidStateError" || e.type === "InvalidCharacterError") {
this.logger.error(e);
return false;
}
else {
throw e;
}
}
this.logger.log('DTMF sent via RTP: ' + tones.toString());
return true;
} },
getDirection: { writable: true, value: function getDirection() {
return this.direction;
} },
// Internal functions
createOfferOrAnswer: { writable: true, value: function createOfferOrAnswer(RTCOfferOptions, modifiers) {
var _this = this;
var self = this;
var methodName;
var pc = this.peerConnection;
RTCOfferOptions = RTCOfferOptions || {};
methodName = self.hasOffer('remote') ? 'createAnswer' : 'createOffer';
return pc[methodName](RTCOfferOptions)
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("createOfferOrAnswer", e, 'peerConnection-' + methodName + 'Failed');
_this.emit('peerConnection-' + methodName + 'Failed', error);
throw error;
})
.then(function (sdp) {
return SIP.Utils.reducePromises(modifiers, self.createRTCSessionDescriptionInit(sdp));
})
.then(function (sdp) {
self.resetIceGatheringComplete();
return pc.setLocalDescription(sdp);
})
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("createOfferOrAnswer", e, 'peerConnection-SetLocalDescriptionFailed');
_this.emit('peerConnection-SetLocalDescriptionFailed', error);
throw error;
})
.then(function onSetLocalDescriptionSuccess() {
return self.waitForIceGatheringComplete();
})
.then(function readySuccess() {
var localDescription = self.createRTCSessionDescriptionInit(self.peerConnection.localDescription);
return SIP.Utils.reducePromises(modifiers, localDescription);
})
.then(function (localDescription) {
self.setDirection(localDescription.sdp);
return localDescription;
})
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("createOfferOrAnswer", e);
_this.logger.error(error);
throw error;
});
} },
// Creates an RTCSessionDescriptionInit from an RTCSessionDescription
createRTCSessionDescriptionInit: { writable: true, value: function createRTCSessionDescriptionInit(RTCSessionDescription) {
return {
type: RTCSessionDescription.type,
sdp: RTCSessionDescription.sdp
};
} },
addDefaultIceCheckingTimeout: { writable: true, value: function addDefaultIceCheckingTimeout(peerConnectionOptions) {
if (peerConnectionOptions.iceCheckingTimeout === undefined) {
peerConnectionOptions.iceCheckingTimeout = 5000;
}
return peerConnectionOptions;
} },
addDefaultIceServers: { writable: true, value: function addDefaultIceServers(rtcConfiguration) {
if (!rtcConfiguration.iceServers) {
rtcConfiguration.iceServers = [{ urls: 'stun:stun.l.google.com:19302' }];
}
return rtcConfiguration;
} },
checkAndDefaultConstraints: { writable: true, value: function checkAndDefaultConstraints(constraints) {
var defaultConstraints = { audio: true, video: !this.options.alwaysAcquireMediaFirst };
constraints = constraints || defaultConstraints;
// Empty object check
if (Object.keys(constraints).length === 0 && constraints.constructor === Object) {
return defaultConstraints;
}
return constraints;
} },
hasBrowserTrackSupport: { writable: true, value: function hasBrowserTrackSupport() {
return Boolean(this.peerConnection.addTrack);
} },
hasBrowserGetSenderSupport: { writable: true, value: function hasBrowserGetSenderSupport() {
return Boolean(this.peerConnection.getSenders);
} },
initPeerConnection: { writable: true, value: function initPeerConnection(options) {
var self = this;
options = options || {};
options = this.addDefaultIceCheckingTimeout(options);
options.rtcConfiguration = options.rtcConfiguration || {};
options.rtcConfiguration = this.addDefaultIceServers(options.rtcConfiguration);
this.logger.log('initPeerConnection');
if (this.peerConnection) {
this.logger.log('Already have a peer connection for this session. Tearing down.');
this.resetIceGatheringComplete();
this.peerConnection.close();
}
this.peerConnection = new this.WebRTC.RTCPeerConnection(options.rtcConfiguration);
this.logger.log('New peer connection created');
if ('ontrack' in this.peerConnection) {
this.peerConnection.addEventListener('track', function (e) {
self.logger.log('track added');
self.observer.trackAdded();
self.emit('addTrack', e);
});
}
else {
this.logger.warn('Using onaddstream which is deprecated');
this.peerConnection.onaddstream = function (e) {
self.logger.log('stream added');
self.emit('addStream', e);
};
}
this.peerConnection.onicecandidate = function (e) {
self.emit('iceCandidate', e);
if (e.candidate) {
self.logger.log('ICE candidate received: ' + (e.candidate.candidate === null ? null : e.candidate.candidate.trim()));
}
else if (e.candidate === null) {
// indicates the end of candidate gathering
self.logger.log('ICE candidate gathering complete');
self.triggerIceGatheringComplete();
}
};
this.peerConnection.onicegatheringstatechange = function () {
self.logger.log('RTCIceGatheringState changed: ' + this.iceGatheringState);
switch (this.iceGatheringState) {
case 'gathering':
self.emit('iceGathering', this);
if (!self.iceGatheringTimer && options.iceCheckingTimeout) {
self.iceGatheringTimeout = false;
self.iceGatheringTimer = SIP.Timers.setTimeout(function () {
self.logger.log('RTCIceChecking Timeout Triggered after ' + options.iceCheckingTimeout + ' milliseconds');
self.iceGatheringTimeout = true;
self.triggerIceGatheringComplete();
}, options.iceCheckingTimeout);
}
break;
case 'complete':
self.triggerIceGatheringComplete();
break;
}
};
this.peerConnection.oniceconnectionstatechange = function () {
var stateEvent;
switch (this.iceConnectionState) {
case 'new':
stateEvent = 'iceConnection';
break;
case 'checking':
stateEvent = 'iceConnectionChecking';
break;
case 'connected':
stateEvent = 'iceConnectionConnected';
break;
case 'completed':
stateEvent = 'iceConnectionCompleted';
break;
case 'failed':
stateEvent = 'iceConnectionFailed';
break;
case 'disconnected':
stateEvent = 'iceConnectionDisconnected';
break;
case 'closed':
stateEvent = 'iceConnectionClosed';
break;
default:
self.logger.warn('Unknown iceConnection state:', this.iceConnectionState);
return;
}
self.emit(stateEvent, this);
};
} },
acquire: { writable: true, value: function acquire(constraints) {
var _this = this;
// Default audio & video to true
constraints = this.checkAndDefaultConstraints(constraints);
return new SIP.Utils.Promise(function (resolve, reject) {
/*
* Make the call asynchronous, so that ICCs have a chance
* to define callbacks to `userMediaRequest`
*/
this.logger.log('acquiring local media');
this.emit('userMediaRequest', constraints);
if (constraints.audio || constraints.video) {
this.WebRTC.getUserMedia(constraints)
.then(function (streams) {
this.observer.trackAdded();
this.emit('userMedia', streams);
resolve(streams);
}.bind(this)).catch(function (e) {
this.emit('userMediaFailed', e);
reject(e);
}.bind(this));
}
else {
// Local streams were explicitly excluded.
resolve([]);
}
}.bind(this))
.catch(function (e) {
// TODO: This propogates downwards
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("acquire", e, "unable to acquire streams");
_this.logger.error(error.message);
_this.logger.error(error.error);
throw error;
})
.then(function acquireSucceeded(streams) {
this.logger.log('acquired local media streams');
try {
// Remove old tracks
if (this.peerConnection.removeTrack) {
this.peerConnection.getSenders().forEach(function (sender) {
this.peerConnection.removeTrack(sender);
}, this);
}
return streams;
}
catch (e) {
return SIP.Utils.Promise.reject(e);
}
}.bind(this))
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("acquire", e, "error removing streams");
_this.logger.error(error.message);
_this.logger.error(error.error);
throw error;
})
.then(function addStreams(streams) {
try {
streams = [].concat(streams);
streams.forEach(function (stream) {
if (this.peerConnection.addTrack) {
stream.getTracks().forEach(function (track) {
this.peerConnection.addTrack(track, stream);
}, this);
}
else {
// Chrome 59 does not support addTrack
this.peerConnection.addStream(stream);
}
}, this);
}
catch (e) {
return SIP.Utils.Promise.reject(e);
}
return SIP.Utils.Promise.resolve();
}.bind(this))
.catch(function (e) {
if (e instanceof SIP.Exceptions.SessionDescriptionHandlerError) {
throw e;
}
var error = new SIP.Exceptions.SessionDescriptionHandlerError("acquire", e, "error adding stream");
_this.logger.error(error.message);
_this.logger.error(error.error);
throw error;
});
} },
hasOffer: { writable: true, value: function hasOffer(where) {
var offerState = 'have-' + where + '-offer';
return this.peerConnection.signalingState === offerState;
} },
// ICE gathering state handling
isIceGatheringComplete: { writable: true, value: function isIceGatheringComplete() {
return this.peerConnection.iceGatheringState === 'complete' || this.iceGatheringTimeout;
} },
resetIceGatheringComplete: { writable: true, value: function resetIceGatheringComplete() {
this.iceGatheringTimeout = false;
if (this.iceGatheringTimer) {
SIP.Timers.clearTimeout(this.iceGatheringTimer);
this.iceGatheringTimer = null;
}
if (this.iceGatheringDeferred) {
this.iceGatheringDeferred.reject();
this.iceGatheringDeferred = null;
}
} },
setDirection: { writable: true, value: function setDirection(sdp) {
var match = sdp.match(/a=(sendrecv|sendonly|recvonly|inactive)/);
if (match === null) {
this.direction = this.C.DIRECTION.NULL;
this.observer.directionChanged();
return;
}
var direction = match[1];
switch (direction) {
case this.C.DIRECTION.SENDRECV:
case this.C.DIRECTION.SENDONLY:
case this.C.DIRECTION.RECVONLY:
case this.C.DIRECTION.INACTIVE:
this.direction = direction;
break;
default:
this.direction = this.C.DIRECTION.NULL;
break;
}
this.observer.directionChanged();
} },
triggerIceGatheringComplete: { writable: true, value: function triggerIceGatheringComplete() {
if (this.isIceGatheringComplete()) {
this.emit('iceGatheringComplete', this);
if (this.iceGatheringTimer) {
SIP.Timers.clearTimeout(this.iceGatheringTimer);
this.iceGatheringTimer = null;
}
if (this.iceGatheringDeferred) {
this.iceGatheringDeferred.resolve();
this.iceGatheringDeferred = null;
}
}
} },
waitForIceGatheringComplete: { writable: true, value: function waitForIceGatheringComplete() {
if (this.isIceGatheringComplete()) {
return SIP.Utils.Promise.resolve();
}
else if (!this.isIceGatheringDeferred) {
this.iceGatheringDeferred = SIP.Utils.defer();
}
return this.iceGatheringDeferred.promise;
} }
});
return SessionDescriptionHandler;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)))
/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview SessionDescriptionHandlerObserver
*/
/* SessionDescriptionHandlerObserver
* @class SessionDescriptionHandler Observer Class.
* @param {SIP.Session} session
* @param {Object} [options]
*/
// Constructor
var SessionDescriptionHandlerObserver = function (session, options) {
this.session = session || {};
this.options = options || {};
};
SessionDescriptionHandlerObserver.prototype = {
trackAdded: function () {
this.session.emit('trackAdded');
},
directionChanged: function () {
this.session.emit('directionChanged');
},
};
module.exports = SessionDescriptionHandlerObserver;
/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @fileoverview Incoming SIP Message Sanity Check
*/
/**
* SIP message sanity check.
* @augments SIP
* @function
* @param {SIP.IncomingMessage} message
* @param {SIP.UA} ua
* @param {SIP.Transport} transport
* @returns {Boolean}
*/
module.exports = function (SIP) {
var sanityCheck, requests = [], responses = [], all = [];
// Reply
function reply(status_code, message, transport) {
var to, response = SIP.Utils.buildStatusLine(status_code), vias = message.getHeaders('via'), length = vias.length, idx = 0;
for (idx; idx < length; idx++) {
response += "Via: " + vias[idx] + "\r\n";
}
to = message.getHeader('To');
if (!message.to_tag) {
to += ';tag=' + SIP.Utils.newTag();
}
response += "To: " + to + "\r\n";
response += "From: " + message.getHeader('From') + "\r\n";
response += "Call-ID: " + message.call_id + "\r\n";
response += "CSeq: " + message.cseq + " " + message.method + "\r\n";
response += "\r\n";
transport.send(response);
}
/*
* Sanity Check for incoming Messages
*
* Requests:
* - _rfc3261_8_2_2_1_ Receive a Request with a non supported URI scheme
* - _rfc3261_16_3_4_ Receive a Request already sent by us
* Does not look at via sent-by but at sipjsId, which is inserted as
* a prefix in all initial requests generated by the ua
* - _rfc3261_18_3_request_ Body Content-Length
* - _rfc3261_8_2_2_2_ Merged Requests
*
* Responses:
* - _rfc3261_8_1_3_3_ Multiple Via headers
* - _rfc3261_18_1_2_ sent-by mismatch
* - _rfc3261_18_3_response_ Body Content-Length
*
* All:
* - Minimum headers in a SIP message
*/
// Sanity Check functions for requests
function rfc3261_8_2_2_1(message, ua, transport) {
if (!message.ruri || message.ruri.scheme !== 'sip') {
reply(416, message, transport);
return false;
}
}
function rfc3261_16_3_4(message, ua, transport) {
if (!message.to_tag) {
if (message.call_id.substr(0, 5) === ua.configuration.sipjsId) {
reply(482, message, transport);
return false;
}
}
}
function rfc3261_18_3_request(message, ua, transport) {
var len = SIP.Utils.str_utf8_length(message.body), contentLength = message.getHeader('content-length');
if (len < contentLength) {
reply(400, message, transport);
return false;
}
}
function rfc3261_8_2_2_2(message, ua, transport) {
var tr, idx, fromTag = message.from_tag, call_id = message.call_id, cseq = message.cseq;
if (!message.to_tag) {
if (message.method === SIP.C.INVITE) {
tr = ua.transactions.ist[message.via_branch];
if (tr) {
return;
}
else {
for (idx in ua.transactions.ist) {
tr = ua.transactions.ist[idx];
if (tr.request.from_tag === fromTag && tr.request.call_id === call_id && tr.request.cseq === cseq) {
reply(482, message, transport);
return false;
}
}
}
}
else {
tr = ua.transactions.nist[message.via_branch];
if (tr) {
return;
}
else {
for (idx in ua.transactions.nist) {
tr = ua.transactions.nist[idx];
if (tr.request.from_tag === fromTag && tr.request.call_id === call_id && tr.request.cseq === cseq) {
reply(482, message, transport);
return false;
}
}
}
}
}
}
// Sanity Check functions for responses
function rfc3261_8_1_3_3(message, ua) {
if (message.getHeaders('via').length > 1) {
ua.getLogger('sip.sanitycheck').warn('More than one Via header field present in the response. Dropping the response');
return false;
}
}
function rfc3261_18_1_2(message, ua) {
var viaHost = ua.configuration.viaHost;
if (message.via.host !== viaHost || message.via.port !== undefined) {
ua.getLogger('sip.sanitycheck').warn('Via sent-by in the response does not match UA Via host value. Dropping the response');
return false;
}
}
function rfc3261_18_3_response(message, ua) {
var len = SIP.Utils.str_utf8_length(message.body), contentLength = message.getHeader('content-length');
if (len < contentLength) {
ua.getLogger('sip.sanitycheck').warn('Message body length is lower than the value in Content-Length header field. Dropping the response');
return false;
}
}
// Sanity Check functions for requests and responses
function minimumHeaders(message, ua) {
var mandatoryHeaders = ['from', 'to', 'call_id', 'cseq', 'via'], idx = mandatoryHeaders.length;
while (idx--) {
if (!message.hasHeader(mandatoryHeaders[idx])) {
ua.getLogger('sip.sanitycheck').warn('Missing mandatory header field : ' + mandatoryHeaders[idx] + '. Dropping the response');
return false;
}
}
}
requests.push(rfc3261_8_2_2_1);
requests.push(rfc3261_16_3_4);
requests.push(rfc3261_18_3_request);
requests.push(rfc3261_8_2_2_2);
responses.push(rfc3261_8_1_3_3);
responses.push(rfc3261_18_1_2);
responses.push(rfc3261_18_3_response);
all.push(minimumHeaders);
sanityCheck = function (message, ua, transport) {
var len, pass;
len = all.length;
while (len--) {
pass = all[len](message, ua, transport);
if (pass === false) {
return false;
}
}
if (message instanceof SIP.IncomingRequest) {
len = requests.length;
while (len--) {
pass = requests[len](message, ua, transport);
if (pass === false) {
return false;
}
}
}
else if (message instanceof SIP.IncomingResponse) {
len = responses.length;
while (len--) {
pass = responses[len](message, ua, transport);
if (pass === false) {
return false;
}
}
}
//Everything is OK
return true;
};
SIP.sanityCheck = sanityCheck;
};
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var md5 = __webpack_require__(34);
/**
* @fileoverview SIP Digest Authentication
*/
/**
* SIP Digest Authentication.
* @augments SIP.
* @function Digest Authentication
* @param {SIP.UA} ua
*/
module.exports = function (Utils) {
var DigestAuthentication;
DigestAuthentication = function (ua) {
this.logger = ua.getLogger('sipjs.digestauthentication');
this.username = ua.configuration.authorizationUser;
this.password = ua.configuration.password;
this.cnonce = null;
this.nc = 0;
this.ncHex = '00000000';
this.response = null;
};
/**
* Performs Digest authentication given a SIP request and the challenge
* received in a response to that request.
* Returns true if credentials were successfully generated, false otherwise.
*
* @param {SIP.OutgoingRequest} request
* @param {Object} challenge
*/
DigestAuthentication.prototype.authenticate = function (request, challenge) {
// Inspect and validate the challenge.
this.algorithm = challenge.algorithm;
this.realm = challenge.realm;
this.nonce = challenge.nonce;
this.opaque = challenge.opaque;
this.stale = challenge.stale;
if (this.algorithm) {
if (this.algorithm !== 'MD5') {
this.logger.warn('challenge with Digest algorithm different than "MD5", authentication aborted');
return false;
}
}
else {
this.algorithm = 'MD5';
}
if (!this.realm) {
this.logger.warn('challenge without Digest realm, authentication aborted');
return false;
}
if (!this.nonce) {
this.logger.warn('challenge without Digest nonce, authentication aborted');
return false;
}
// 'qop' can contain a list of values (Array). Let's choose just one.
if (challenge.qop) {
if (challenge.qop.indexOf('auth') > -1) {
this.qop = 'auth';
}
else if (challenge.qop.indexOf('auth-int') > -1) {
this.qop = 'auth-int';
}
else {
// Otherwise 'qop' is present but does not contain 'auth' or 'auth-int', so abort here.
this.logger.warn('challenge without Digest qop different than "auth" or "auth-int", authentication aborted');
return false;
}
}
else {
this.qop = null;
}
// Fill other attributes.
this.method = request.method;
this.uri = request.ruri;
this.cnonce = Utils.createRandomToken(12);
this.nc += 1;
this.updateNcHex();
// nc-value = 8LHEX. Max value = 'FFFFFFFF'.
if (this.nc === 4294967296) {
this.nc = 1;
this.ncHex = '00000001';
}
// Calculate the Digest "response" value.
this.calculateResponse();
return true;
};
/**
* Generate Digest 'response' value.
* @private
*/
DigestAuthentication.prototype.calculateResponse = function () {
var ha1, ha2;
// HA1 = MD5(A1) = MD5(username:realm:password)
ha1 = md5(this.username + ":" + this.realm + ":" + this.password);
if (this.qop === 'auth') {
// HA2 = MD5(A2) = MD5(method:digestURI)
ha2 = md5(this.method + ":" + this.uri);
// response = MD5(HA1:nonce:nonceCount:credentialsNonce:qop:HA2)
this.response = md5(ha1 + ":" + this.nonce + ":" + this.ncHex + ":" + this.cnonce + ":auth:" + ha2);
}
else if (this.qop === 'auth-int') {
// HA2 = MD5(A2) = MD5(method:digestURI:MD5(entityBody))
ha2 = md5(this.method + ":" + this.uri + ":" + md5(this.body ? this.body : ""));
// response = MD5(HA1:nonce:nonceCount:credentialsNonce:qop:HA2)
this.response = md5(ha1 + ":" + this.nonce + ":" + this.ncHex + ":" + this.cnonce + ":auth-int:" + ha2);
}
else if (this.qop === null) {
// HA2 = MD5(A2) = MD5(method:digestURI)
ha2 = md5(this.method + ":" + this.uri);
// response = MD5(HA1:nonce:HA2)
this.response = md5(ha1 + ":" + this.nonce + ":" + ha2);
}
};
/**
* Return the Proxy-Authorization or WWW-Authorization header value.
*/
DigestAuthentication.prototype.toString = function () {
var auth_params = [];
if (!this.response) {
throw new Error('response field does not exist, cannot generate Authorization header');
}
auth_params.push('algorithm=' + this.algorithm);
auth_params.push('username="' + this.username + '"');
auth_params.push('realm="' + this.realm + '"');
auth_params.push('nonce="' + this.nonce + '"');
auth_params.push('uri="' + this.uri + '"');
auth_params.push('response="' + this.response + '"');
if (this.opaque) {
auth_params.push('opaque="' + this.opaque + '"');
}
if (this.qop) {
auth_params.push('qop=' + this.qop);
auth_params.push('cnonce="' + this.cnonce + '"');
auth_params.push('nc=' + this.ncHex);
}
return 'Digest ' + auth_params.join(', ');
};
/**
* Generate the 'nc' value as required by Digest in this.ncHex by reading this.nc.
* @private
*/
DigestAuthentication.prototype.updateNcHex = function () {
var hex = Number(this.nc).toString(16);
this.ncHex = '00000000'.substr(0, 8 - hex.length) + hex;
};
return DigestAuthentication;
};
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
;(function (root, factory) {
if (true) {
// CommonJS
module.exports = exports = factory(__webpack_require__(35));
}
else {}
}(this, function (CryptoJS) {
(function (Math) {
// Shortcuts
var C = CryptoJS;
var C_lib = C.lib;
var WordArray = C_lib.WordArray;
var Hasher = C_lib.Hasher;
var C_algo = C.algo;
// Constants table
var T = [];
// Compute constants
(function () {
for (var i = 0; i < 64; i++) {
T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
}
}());
/**
* MD5 hash algorithm.
*/
var MD5 = C_algo.MD5 = Hasher.extend({
_doReset: function () {
this._hash = new WordArray.init([
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476
]);
},
_doProcessBlock: function (M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
// Shortcuts
var offset_i = offset + i;
var M_offset_i = M[offset_i];
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Shortcuts
var H = this._hash.words;
var M_offset_0 = M[offset + 0];
var M_offset_1 = M[offset + 1];
var M_offset_2 = M[offset + 2];
var M_offset_3 = M[offset + 3];
var M_offset_4 = M[offset + 4];
var M_offset_5 = M[offset + 5];
var M_offset_6 = M[offset + 6];
var M_offset_7 = M[offset + 7];
var M_offset_8 = M[offset + 8];
var M_offset_9 = M[offset + 9];
var M_offset_10 = M[offset + 10];
var M_offset_11 = M[offset + 11];
var M_offset_12 = M[offset + 12];
var M_offset_13 = M[offset + 13];
var M_offset_14 = M[offset + 14];
var M_offset_15 = M[offset + 15];
// Working varialbes
var a = H[0];
var b = H[1];
var c = H[2];
var d = H[3];
// Computation
a = FF(a, b, c, d, M_offset_0, 7, T[0]);
d = FF(d, a, b, c, M_offset_1, 12, T[1]);
c = FF(c, d, a, b, M_offset_2, 17, T[2]);
b = FF(b, c, d, a, M_offset_3, 22, T[3]);
a = FF(a, b, c, d, M_offset_4, 7, T[4]);
d = FF(d, a, b, c, M_offset_5, 12, T[5]);
c = FF(c, d, a, b, M_offset_6, 17, T[6]);
b = FF(b, c, d, a, M_offset_7, 22, T[7]);
a = FF(a, b, c, d, M_offset_8, 7, T[8]);
d = FF(d, a, b, c, M_offset_9, 12, T[9]);
c = FF(c, d, a, b, M_offset_10, 17, T[10]);
b = FF(b, c, d, a, M_offset_11, 22, T[11]);
a = FF(a, b, c, d, M_offset_12, 7, T[12]);
d = FF(d, a, b, c, M_offset_13, 12, T[13]);
c = FF(c, d, a, b, M_offset_14, 17, T[14]);
b = FF(b, c, d, a, M_offset_15, 22, T[15]);
a = GG(a, b, c, d, M_offset_1, 5, T[16]);
d = GG(d, a, b, c, M_offset_6, 9, T[17]);
c = GG(c, d, a, b, M_offset_11, 14, T[18]);
b = GG(b, c, d, a, M_offset_0, 20, T[19]);
a = GG(a, b, c, d, M_offset_5, 5, T[20]);
d = GG(d, a, b, c, M_offset_10, 9, T[21]);
c = GG(c, d, a, b, M_offset_15, 14, T[22]);
b = GG(b, c, d, a, M_offset_4, 20, T[23]);
a = GG(a, b, c, d, M_offset_9, 5, T[24]);
d = GG(d, a, b, c, M_offset_14, 9, T[25]);
c = GG(c, d, a, b, M_offset_3, 14, T[26]);
b = GG(b, c, d, a, M_offset_8, 20, T[27]);
a = GG(a, b, c, d, M_offset_13, 5, T[28]);
d = GG(d, a, b, c, M_offset_2, 9, T[29]);
c = GG(c, d, a, b, M_offset_7, 14, T[30]);
b = GG(b, c, d, a, M_offset_12, 20, T[31]);
a = HH(a, b, c, d, M_offset_5, 4, T[32]);
d = HH(d, a, b, c, M_offset_8, 11, T[33]);
c = HH(c, d, a, b, M_offset_11, 16, T[34]);
b = HH(b, c, d, a, M_offset_14, 23, T[35]);
a = HH(a, b, c, d, M_offset_1, 4, T[36]);
d = HH(d, a, b, c, M_offset_4, 11, T[37]);
c = HH(c, d, a, b, M_offset_7, 16, T[38]);
b = HH(b, c, d, a, M_offset_10, 23, T[39]);
a = HH(a, b, c, d, M_offset_13, 4, T[40]);
d = HH(d, a, b, c, M_offset_0, 11, T[41]);
c = HH(c, d, a, b, M_offset_3, 16, T[42]);
b = HH(b, c, d, a, M_offset_6, 23, T[43]);
a = HH(a, b, c, d, M_offset_9, 4, T[44]);
d = HH(d, a, b, c, M_offset_12, 11, T[45]);
c = HH(c, d, a, b, M_offset_15, 16, T[46]);
b = HH(b, c, d, a, M_offset_2, 23, T[47]);
a = II(a, b, c, d, M_offset_0, 6, T[48]);
d = II(d, a, b, c, M_offset_7, 10, T[49]);
c = II(c, d, a, b, M_offset_14, 15, T[50]);
b = II(b, c, d, a, M_offset_5, 21, T[51]);
a = II(a, b, c, d, M_offset_12, 6, T[52]);
d = II(d, a, b, c, M_offset_3, 10, T[53]);
c = II(c, d, a, b, M_offset_10, 15, T[54]);
b = II(b, c, d, a, M_offset_1, 21, T[55]);
a = II(a, b, c, d, M_offset_8, 6, T[56]);
d = II(d, a, b, c, M_offset_15, 10, T[57]);
c = II(c, d, a, b, M_offset_6, 15, T[58]);
b = II(b, c, d, a, M_offset_13, 21, T[59]);
a = II(a, b, c, d, M_offset_4, 6, T[60]);
d = II(d, a, b, c, M_offset_11, 10, T[61]);
c = II(c, d, a, b, M_offset_2, 15, T[62]);
b = II(b, c, d, a, M_offset_9, 21, T[63]);
// Intermediate hash value
H[0] = (H[0] + a) | 0;
H[1] = (H[1] + b) | 0;
H[2] = (H[2] + c) | 0;
H[3] = (H[3] + d) | 0;
},
_doFinalize: function () {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var nBitsTotal = this._nDataBytes * 8;
var nBitsLeft = data.sigBytes * 8;
// Add padding
dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
var nBitsTotalL = nBitsTotal;
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
(((nBitsTotalH << 8) | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
(((nBitsTotalH << 24) | (nBitsTotalH >>> 8)) & 0xff00ff00)
);
dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotalL << 8) | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
(((nBitsTotalL << 24) | (nBitsTotalL >>> 8)) & 0xff00ff00)
);
data.sigBytes = (dataWords.length + 1) * 4;
// Hash final blocks
this._process();
// Shortcuts
var hash = this._hash;
var H = hash.words;
// Swap endian
for (var i = 0; i < 4; i++) {
// Shortcut
var H_i = H[i];
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
// Return final computed hash
return hash;
},
clone: function () {
var clone = Hasher.clone.call(this);
clone._hash = this._hash.clone();
return clone;
}
});
function FF(a, b, c, d, x, s, t) {
var n = a + ((b & c) | (~b & d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function GG(a, b, c, d, x, s, t) {
var n = a + ((b & d) | (c & ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function HH(a, b, c, d, x, s, t) {
var n = a + (b ^ c ^ d) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
function II(a, b, c, d, x, s, t) {
var n = a + (c ^ (b | ~d)) + x + t;
return ((n << s) | (n >>> (32 - s))) + b;
}
/**
* Shortcut function to the hasher's object interface.
*
* @param {WordArray|string} message The message to hash.
*
* @return {WordArray} The hash.
*
* @static
*
* @example
*
* var hash = CryptoJS.MD5('message');
* var hash = CryptoJS.MD5(wordArray);
*/
C.MD5 = Hasher._createHelper(MD5);
/**
* Shortcut function to the HMAC's object interface.
*
* @param {WordArray|string} message The message to hash.
* @param {WordArray|string} key The secret key.
*
* @return {WordArray} The HMAC.
*
* @static
*
* @example
*
* var hmac = CryptoJS.HmacMD5(message, key);
*/
C.HmacMD5 = Hasher._createHmacHelper(MD5);
}(Math));
return CryptoJS.MD5;
}));
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
;(function (root, factory) {
if (true) {
// CommonJS
module.exports = exports = factory();
}
else {}
}(this, function () {
/**
* CryptoJS core components.
*/
var CryptoJS = CryptoJS || (function (Math, undefined) {
/*
* Local polyfil of Object.create
*/
var create = Object.create || (function () {
function F() {};
return function (obj) {
var subtype;
F.prototype = obj;
subtype = new F();
F.prototype = null;
return subtype;
};
}())
/**
* CryptoJS namespace.
*/
var C = {};
/**
* Library namespace.
*/
var C_lib = C.lib = {};
/**
* Base object for prototypal inheritance.
*/
var Base = C_lib.Base = (function () {
return {
/**
* Creates a new object that inherits from this object.
*
* @param {Object} overrides Properties to copy into the new object.
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* field: 'value',
*
* method: function () {
* }
* });
*/
extend: function (overrides) {
// Spawn
var subtype = create(this);
// Augment
if (overrides) {
subtype.mixIn(overrides);
}
// Create default initializer
if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
subtype.init = function () {
subtype.$super.init.apply(this, arguments);
};
}
// Initializer's prototype is the subtype object
subtype.init.prototype = subtype;
// Reference supertype
subtype.$super = this;
return subtype;
},
/**
* Extends this object and runs the init method.
* Arguments to create() will be passed to init().
*
* @return {Object} The new object.
*
* @static
*
* @example
*
* var instance = MyType.create();
*/
create: function () {
var instance = this.extend();
instance.init.apply(instance, arguments);
return instance;
},
/**
* Initializes a newly created object.
* Override this method to add some logic when your objects are created.
*
* @example
*
* var MyType = CryptoJS.lib.Base.extend({
* init: function () {
* // ...
* }
* });
*/
init: function () {
},
/**
* Copies properties into this object.
*
* @param {Object} properties The properties to mix in.
*
* @example
*
* MyType.mixIn({
* field: 'value'
* });
*/
mixIn: function (properties) {
for (var propertyName in properties) {
if (properties.hasOwnProperty(propertyName)) {
this[propertyName] = properties[propertyName];
}
}
// IE won't copy toString using the loop above
if (properties.hasOwnProperty('toString')) {
this.toString = properties.toString;
}
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = instance.clone();
*/
clone: function () {
return this.init.prototype.extend(this);
}
};
}());
/**
* An array of 32-bit words.
*
* @property {Array} words The array of 32-bit words.
* @property {number} sigBytes The number of significant bytes in this word array.
*/
var WordArray = C_lib.WordArray = Base.extend({
/**
* Initializes a newly created word array.
*
* @param {Array} words (Optional) An array of 32-bit words.
* @param {number} sigBytes (Optional) The number of significant bytes in the words.
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.create();
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
* var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
*/
init: function (words, sigBytes) {
words = this.words = words || [];
if (sigBytes != undefined) {
this.sigBytes = sigBytes;
} else {
this.sigBytes = words.length * 4;
}
},
/**
* Converts this word array to a string.
*
* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
*
* @return {string} The stringified word array.
*
* @example
*
* var string = wordArray + '';
* var string = wordArray.toString();
* var string = wordArray.toString(CryptoJS.enc.Utf8);
*/
toString: function (encoder) {
return (encoder || Hex).stringify(this);
},
/**
* Concatenates a word array to this word array.
*
* @param {WordArray} wordArray The word array to append.
*
* @return {WordArray} This word array.
*
* @example
*
* wordArray1.concat(wordArray2);
*/
concat: function (wordArray) {
// Shortcuts
var thisWords = this.words;
var thatWords = wordArray.words;
var thisSigBytes = this.sigBytes;
var thatSigBytes = wordArray.sigBytes;
// Clamp excess bits
this.clamp();
// Concat
if (thisSigBytes % 4) {
// Copy one byte at a time
for (var i = 0; i < thatSigBytes; i++) {
var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
}
} else {
// Copy one word at a time
for (var i = 0; i < thatSigBytes; i += 4) {
thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
}
}
this.sigBytes += thatSigBytes;
// Chainable
return this;
},
/**
* Removes insignificant bits.
*
* @example
*
* wordArray.clamp();
*/
clamp: function () {
// Shortcuts
var words = this.words;
var sigBytes = this.sigBytes;
// Clamp
words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
words.length = Math.ceil(sigBytes / 4);
},
/**
* Creates a copy of this word array.
*
* @return {WordArray} The clone.
*
* @example
*
* var clone = wordArray.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone.words = this.words.slice(0);
return clone;
},
/**
* Creates a word array filled with random bytes.
*
* @param {number} nBytes The number of random bytes to generate.
*
* @return {WordArray} The random word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.lib.WordArray.random(16);
*/
random: function (nBytes) {
var words = [];
var r = (function (m_w) {
var m_w = m_w;
var m_z = 0x3ade68b1;
var mask = 0xffffffff;
return function () {
m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
var result = ((m_z << 0x10) + m_w) & mask;
result /= 0x100000000;
result += 0.5;
return result * (Math.random() > .5 ? 1 : -1);
}
});
for (var i = 0, rcache; i < nBytes; i += 4) {
var _r = r((rcache || Math.random()) * 0x100000000);
rcache = _r() * 0x3ade67b7;
words.push((_r() * 0x100000000) | 0);
}
return new WordArray.init(words, nBytes);
}
});
/**
* Encoder namespace.
*/
var C_enc = C.enc = {};
/**
* Hex encoding strategy.
*/
var Hex = C_enc.Hex = {
/**
* Converts a word array to a hex string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The hex string.
*
* @static
*
* @example
*
* var hexString = CryptoJS.enc.Hex.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var hexChars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
hexChars.push((bite >>> 4).toString(16));
hexChars.push((bite & 0x0f).toString(16));
}
return hexChars.join('');
},
/**
* Converts a hex string to a word array.
*
* @param {string} hexStr The hex string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Hex.parse(hexString);
*/
parse: function (hexStr) {
// Shortcut
var hexStrLength = hexStr.length;
// Convert
var words = [];
for (var i = 0; i < hexStrLength; i += 2) {
words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
}
return new WordArray.init(words, hexStrLength / 2);
}
};
/**
* Latin1 encoding strategy.
*/
var Latin1 = C_enc.Latin1 = {
/**
* Converts a word array to a Latin1 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The Latin1 string.
*
* @static
*
* @example
*
* var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
*/
stringify: function (wordArray) {
// Shortcuts
var words = wordArray.words;
var sigBytes = wordArray.sigBytes;
// Convert
var latin1Chars = [];
for (var i = 0; i < sigBytes; i++) {
var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
latin1Chars.push(String.fromCharCode(bite));
}
return latin1Chars.join('');
},
/**
* Converts a Latin1 string to a word array.
*
* @param {string} latin1Str The Latin1 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
*/
parse: function (latin1Str) {
// Shortcut
var latin1StrLength = latin1Str.length;
// Convert
var words = [];
for (var i = 0; i < latin1StrLength; i++) {
words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
}
return new WordArray.init(words, latin1StrLength);
}
};
/**
* UTF-8 encoding strategy.
*/
var Utf8 = C_enc.Utf8 = {
/**
* Converts a word array to a UTF-8 string.
*
* @param {WordArray} wordArray The word array.
*
* @return {string} The UTF-8 string.
*
* @static
*
* @example
*
* var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
*/
stringify: function (wordArray) {
try {
return decodeURIComponent(escape(Latin1.stringify(wordArray)));
} catch (e) {
throw new Error('Malformed UTF-8 data');
}
},
/**
* Converts a UTF-8 string to a word array.
*
* @param {string} utf8Str The UTF-8 string.
*
* @return {WordArray} The word array.
*
* @static
*
* @example
*
* var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
*/
parse: function (utf8Str) {
return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
}
};
/**
* Abstract buffered block algorithm template.
*
* The property blockSize must be implemented in a concrete subtype.
*
* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
*/
var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
/**
* Resets this block algorithm's data buffer to its initial state.
*
* @example
*
* bufferedBlockAlgorithm.reset();
*/
reset: function () {
// Initial values
this._data = new WordArray.init();
this._nDataBytes = 0;
},
/**
* Adds new data to this block algorithm's buffer.
*
* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
*
* @example
*
* bufferedBlockAlgorithm._append('data');
* bufferedBlockAlgorithm._append(wordArray);
*/
_append: function (data) {
// Convert string to WordArray, else assume WordArray already
if (typeof data == 'string') {
data = Utf8.parse(data);
}
// Append
this._data.concat(data);
this._nDataBytes += data.sigBytes;
},
/**
* Processes available data blocks.
*
* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
*
* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
*
* @return {WordArray} The processed data.
*
* @example
*
* var processedData = bufferedBlockAlgorithm._process();
* var processedData = bufferedBlockAlgorithm._process(!!'flush');
*/
_process: function (doFlush) {
// Shortcuts
var data = this._data;
var dataWords = data.words;
var dataSigBytes = data.sigBytes;
var blockSize = this.blockSize;
var blockSizeBytes = blockSize * 4;
// Count blocks ready
var nBlocksReady = dataSigBytes / blockSizeBytes;
if (doFlush) {
// Round up to include partial blocks
nBlocksReady = Math.ceil(nBlocksReady);
} else {
// Round down to include only full blocks,
// less the number of blocks that must remain in the buffer
nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
}
// Count words ready
var nWordsReady = nBlocksReady * blockSize;
// Count bytes ready
var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
// Process blocks
if (nWordsReady) {
for (var offset = 0; offset < nWordsReady; offset += blockSize) {
// Perform concrete-algorithm logic
this._doProcessBlock(dataWords, offset);
}
// Remove processed words
var processedWords = dataWords.splice(0, nWordsReady);
data.sigBytes -= nBytesReady;
}
// Return processed words
return new WordArray.init(processedWords, nBytesReady);
},
/**
* Creates a copy of this object.
*
* @return {Object} The clone.
*
* @example
*
* var clone = bufferedBlockAlgorithm.clone();
*/
clone: function () {
var clone = Base.clone.call(this);
clone._data = this._data.clone();
return clone;
},
_minBufferSize: 0
});
/**
* Abstract hasher template.
*
* @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
*/
var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
/**
* Configuration options.
*/
cfg: Base.extend(),
/**
* Initializes a newly created hasher.
*
* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
*
* @example
*
* var hasher = CryptoJS.algo.SHA256.create();
*/
init: function (cfg) {
// Apply config defaults
this.cfg = this.cfg.extend(cfg);
// Set initial values
this.reset();
},
/**
* Resets this hasher to its initial state.
*
* @example
*
* hasher.reset();
*/
reset: function () {
// Reset data buffer
BufferedBlockAlgorithm.reset.call(this);
// Perform concrete-hasher logic
this._doReset();
},
/**
* Updates this hasher with a message.
*
* @param {WordArray|string} messageUpdate The message to append.
*
* @return {Hasher} This hasher.
*
* @example
*
* hasher.update('message');
* hasher.update(wordArray);
*/
update: function (messageUpdate) {
// Append
this._append(messageUpdate);
// Update the hash
this._process();
// Chainable
return this;
},
/**
* Finalizes the hash computation.
* Note that the finalize operation is effectively a destructive, read-once operation.
*
* @param {WordArray|string} messageUpdate (Optional) A final message update.
*
* @return {WordArray} The hash.
*
* @example
*
* var hash = hasher.finalize();
* var hash = hasher.finalize('message');
* var hash = hasher.finalize(wordArray);
*/
finalize: function (messageUpdate) {
// Final message update
if (messageUpdate) {
this._append(messageUpdate);
}
// Perform concrete-hasher logic
var hash = this._doFinalize();
return hash;
},
blockSize: 512/32,
/**
* Creates a shortcut function to a hasher's object interface.
*
* @param {Hasher} hasher The hasher to create a helper for.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
*/
_createHelper: function (hasher) {
return function (message, cfg) {
return new hasher.init(cfg).finalize(message);
};
},
/**
* Creates a shortcut function to the HMAC's object interface.
*
* @param {Hasher} hasher The hasher to use in this HMAC helper.
*
* @return {Function} The shortcut function.
*
* @static
*
* @example
*
* var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
*/
_createHmacHelper: function (hasher) {
return function (message, key) {
return new C_algo.HMAC.init(hasher, key).finalize(message);
};
}
});
/**
* Algorithm namespace.
*/
var C_algo = C.algo = {};
return C;
}(Math));
return CryptoJS;
}));
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var Grammar = __webpack_require__(37);
module.exports = function (SIP) {
return {
parse: function parseCustom(input, startRule) {
var options = { startRule: startRule, SIP: SIP };
try {
Grammar.parse(input, options);
}
catch (e) {
options.data = -1;
}
return options.data;
}
};
};
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/*
* Generated by PEG.js 0.10.0.
*
* http://pegjs.org/
*/
function peg$subclass(child, parent) {
function ctor() { this.constructor = child; }
ctor.prototype = parent.prototype;
child.prototype = new ctor();
}
function peg$SyntaxError(message, expected, found, location) {
this.message = message;
this.expected = expected;
this.found = found;
this.location = location;
this.name = "SyntaxError";
if (typeof Error.captureStackTrace === "function") {
Error.captureStackTrace(this, peg$SyntaxError);
}
}
peg$subclass(peg$SyntaxError, Error);
peg$SyntaxError.buildMessage = function(expected, found) {
var DESCRIBE_EXPECTATION_FNS = {
literal: function(expectation) {
return "\"" + literalEscape(expectation.text) + "\"";
},
"class": function(expectation) {
var escapedParts = "",
i;
for (i = 0; i < expectation.parts.length; i++) {
escapedParts += expectation.parts[i] instanceof Array
? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
: classEscape(expectation.parts[i]);
}
return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
},
any: function(expectation) {
return "any character";
},
end: function(expectation) {
return "end of input";
},
other: function(expectation) {
return expectation.description;
}
};
function hex(ch) {
return ch.charCodeAt(0).toString(16).toUpperCase();
}
function literalEscape(s) {
return s
.replace(/\\/g, '\\\\')
.replace(/"/g, '\\"')
.replace(/\0/g, '\\0')
.replace(/\t/g, '\\t')
.replace(/\n/g, '\\n')
.replace(/\r/g, '\\r')
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
}
function classEscape(s) {
return s
.replace(/\\/g, '\\\\')
.replace(/\]/g, '\\]')
.replace(/\^/g, '\\^')
.replace(/-/g, '\\-')
.replace(/\0/g, '\\0')
.replace(/\t/g, '\\t')
.replace(/\n/g, '\\n')
.replace(/\r/g, '\\r')
.replace(/[\x00-\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
.replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x' + hex(ch); });
}
function describeExpectation(expectation) {
return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
}
function describeExpected(expected) {
var descriptions = new Array(expected.length),
i, j;
for (i = 0; i < expected.length; i++) {
descriptions[i] = describeExpectation(expected[i]);
}
descriptions.sort();
if (descriptions.length > 0) {
for (i = 1, j = 1; i < descriptions.length; i++) {
if (descriptions[i - 1] !== descriptions[i]) {
descriptions[j] = descriptions[i];
j++;
}
}
descriptions.length = j;
}
switch (descriptions.length) {
case 1:
return descriptions[0];
case 2:
return descriptions[0] + " or " + descriptions[1];
default:
return descriptions.slice(0, -1).join(", ")
+ ", or "
+ descriptions[descriptions.length - 1];
}
}
function describeFound(found) {
return found ? "\"" + literalEscape(found) + "\"" : "end of input";
}
return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
};
function peg$parse(input, options) {
options = options !== void 0 ? options : {};
var peg$FAILED = {},
peg$startRuleIndices = { Contact: 119, Name_Addr_Header: 156, Record_Route: 176, Request_Response: 81, SIP_URI: 45, Subscription_State: 186, Supported: 191, Require: 182, Via: 194, absoluteURI: 84, Call_ID: 118, Content_Disposition: 130, Content_Length: 135, Content_Type: 136, CSeq: 146, displayName: 122, Event: 149, From: 151, host: 52, Max_Forwards: 154, Min_SE: 213, Proxy_Authenticate: 157, quoted_string: 40, Refer_To: 178, Replaces: 179, Session_Expires: 210, stun_URI: 217, To: 192, turn_URI: 223, uuid: 226, WWW_Authenticate: 209, challenge: 158, sipfrag: 230, Referred_By: 231 },
peg$startRuleIndex = 119,
peg$consts = [
"\r\n",
peg$literalExpectation("\r\n", false),
/^[0-9]/,
peg$classExpectation([["0", "9"]], false, false),
/^[a-zA-Z]/,
peg$classExpectation([["a", "z"], ["A", "Z"]], false, false),
/^[0-9a-fA-F]/,
peg$classExpectation([["0", "9"], ["a", "f"], ["A", "F"]], false, false),
/^[\0-\xFF]/,
peg$classExpectation([["\0", "\xFF"]], false, false),
/^["]/,
peg$classExpectation(["\""], false, false),
" ",
peg$literalExpectation(" ", false),
"\t",
peg$literalExpectation("\t", false),
/^[a-zA-Z0-9]/,
peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false),
";",
peg$literalExpectation(";", false),
"/",
peg$literalExpectation("/", false),
"?",
peg$literalExpectation("?", false),
":",
peg$literalExpectation(":", false),
"@",
peg$literalExpectation("@", false),
"&",
peg$literalExpectation("&", false),
"=",
peg$literalExpectation("=", false),
"+",
peg$literalExpectation("+", false),
"$",
peg$literalExpectation("$", false),
",",
peg$literalExpectation(",", false),
"-",
peg$literalExpectation("-", false),
"_",
peg$literalExpectation("_", false),
".",
peg$literalExpectation(".", false),
"!",
peg$literalExpectation("!", false),
"~",
peg$literalExpectation("~", false),
"*",
peg$literalExpectation("*", false),
"'",
peg$literalExpectation("'", false),
"(",
peg$literalExpectation("(", false),
")",
peg$literalExpectation(")", false),
"%",
peg$literalExpectation("%", false),
function() {return " "; },
function() {return ':'; },
/^[!-~]/,
peg$classExpectation([["!", "~"]], false, false),
/^[\x80-\uFFFF]/,
peg$classExpectation([["\x80", "\uFFFF"]], false, false),
/^[\x80-\xBF]/,
peg$classExpectation([["\x80", "\xBF"]], false, false),
/^[a-f]/,
peg$classExpectation([["a", "f"]], false, false),
"`",
peg$literalExpectation("`", false),
"<",
peg$literalExpectation("<", false),
">",
peg$literalExpectation(">", false),
"\\",
peg$literalExpectation("\\", false),
"[",
peg$literalExpectation("[", false),
"]",
peg$literalExpectation("]", false),
"{",
peg$literalExpectation("{", false),
"}",
peg$literalExpectation("}", false),
function() {return "*"; },
function() {return "/"; },
function() {return "="; },
function() {return "("; },
function() {return ")"; },
function() {return ">"; },
function() {return "<"; },
function() {return ","; },
function() {return ";"; },
function() {return ":"; },
function() {return "\""; },
/^[!-']/,
peg$classExpectation([["!", "'"]], false, false),
/^[*-[]/,
peg$classExpectation([["*", "["]], false, false),
/^[\]-~]/,
peg$classExpectation([["]", "~"]], false, false),
function(contents) {
return contents; },
/^[#-[]/,
peg$classExpectation([["#", "["]], false, false),
/^[\0-\t]/,
peg$classExpectation([["\0", "\t"]], false, false),
/^[\x0B-\f]/,
peg$classExpectation([["\x0B", "\f"]], false, false),
/^[\x0E-\x7F]/,
peg$classExpectation([["\x0E", "\x7F"]], false, false),
function() {
options.data.uri = new options.SIP.URI(options.data.scheme, options.data.user, options.data.host, options.data.port);
delete options.data.scheme;
delete options.data.user;
delete options.data.host;
delete options.data.host_type;
delete options.data.port;
},
function() {
options.data.uri = new options.SIP.URI(options.data.scheme, options.data.user, options.data.host, options.data.port, options.data.uri_params, options.data.uri_headers);
delete options.data.scheme;
delete options.data.user;
delete options.data.host;
delete options.data.host_type;
delete options.data.port;
delete options.data.uri_params;
if (options.startRule === 'SIP_URI') { options.data = options.data.uri;}
},
"sips",
peg$literalExpectation("sips", true),
"sip",
peg$literalExpectation("sip", true),
function(uri_scheme) {
options.data.scheme = uri_scheme; },
function() {
options.data.user = decodeURIComponent(text().slice(0, -1));},
function() {
options.data.password = text(); },
function() {
options.data.host = text();
return options.data.host; },
function() {
options.data.host_type = 'domain';
return text(); },
/^[a-zA-Z0-9_\-]/,
peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "_", "-"], false, false),
/^[a-zA-Z0-9\-]/,
peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "-"], false, false),
function() {
options.data.host_type = 'IPv6';
return text(); },
"::",
peg$literalExpectation("::", false),
function() {
options.data.host_type = 'IPv6';
return text(); },
function() {
options.data.host_type = 'IPv4';
return text(); },
"25",
peg$literalExpectation("25", false),
/^[0-5]/,
peg$classExpectation([["0", "5"]], false, false),
"2",
peg$literalExpectation("2", false),
/^[0-4]/,
peg$classExpectation([["0", "4"]], false, false),
"1",
peg$literalExpectation("1", false),
/^[1-9]/,
peg$classExpectation([["1", "9"]], false, false),
function(port) {
port = parseInt(port.join(''));
options.data.port = port;
return port; },
"transport=",
peg$literalExpectation("transport=", true),
"udp",
peg$literalExpectation("udp", true),
"tcp",
peg$literalExpectation("tcp", true),
"sctp",
peg$literalExpectation("sctp", true),
"tls",
peg$literalExpectation("tls", true),
function(transport) {
if(!options.data.uri_params) options.data.uri_params={};
options.data.uri_params['transport'] = transport.toLowerCase(); },
"user=",
peg$literalExpectation("user=", true),
"phone",
peg$literalExpectation("phone", true),
"ip",
peg$literalExpectation("ip", true),
function(user) {
if(!options.data.uri_params) options.data.uri_params={};
options.data.uri_params['user'] = user.toLowerCase(); },
"method=",
peg$literalExpectation("method=", true),
function(method) {
if(!options.data.uri_params) options.data.uri_params={};
options.data.uri_params['method'] = method; },
"ttl=",
peg$literalExpectation("ttl=", true),
function(ttl) {
if(!options.data.params) options.data.params={};
options.data.params['ttl'] = ttl; },
"maddr=",
peg$literalExpectation("maddr=", true),
function(maddr) {
if(!options.data.uri_params) options.data.uri_params={};
options.data.uri_params['maddr'] = maddr; },
"lr",
peg$literalExpectation("lr", true),
function() {
if(!options.data.uri_params) options.data.uri_params={};
options.data.uri_params['lr'] = undefined; },
function(param, value) {
if(!options.data.uri_params) options.data.uri_params = {};
if (value === null){
value = undefined;
}
else {
value = value[1];
}
options.data.uri_params[param.toLowerCase()] = value;},
function(hname, hvalue) {
hname = hname.join('').toLowerCase();
hvalue = hvalue.join('');
if(!options.data.uri_headers) options.data.uri_headers = {};
if (!options.data.uri_headers[hname]) {
options.data.uri_headers[hname] = [hvalue];
} else {
options.data.uri_headers[hname].push(hvalue);
}},
function() {
// lots of tests fail if this isn't guarded...
if (options.startRule === 'Refer_To') {
options.data.uri = new options.SIP.URI(options.data.scheme, options.data.user, options.data.host, options.data.port, options.data.uri_params, options.data.uri_headers);
delete options.data.scheme;
delete options.data.user;
delete options.data.host;
delete options.data.host_type;
delete options.data.port;
delete options.data.uri_params;
}
},
"//",
peg$literalExpectation("//", false),
function() {
options.data.scheme= text(); },
peg$literalExpectation("SIP", true),
function() {
options.data.sip_version = text(); },
"INVITE",
peg$literalExpectation("INVITE", false),
"ACK",
peg$literalExpectation("ACK", false),
"VXACH",
peg$literalExpectation("VXACH", false),
"OPTIONS",
peg$literalExpectation("OPTIONS", false),
"BYE",
peg$literalExpectation("BYE", false),
"CANCEL",
peg$literalExpectation("CANCEL", false),
"REGISTER",
peg$literalExpectation("REGISTER", false),
"SUBSCRIBE",
peg$literalExpectation("SUBSCRIBE", false),
"NOTIFY",
peg$literalExpectation("NOTIFY", false),
"REFER",
peg$literalExpectation("REFER", false),
"PUBLISH",
peg$literalExpectation("PUBLISH", false),
function() {
options.data.method = text();
return options.data.method; },
function(status_code) {
options.data.status_code = parseInt(status_code.join('')); },
function() {
options.data.reason_phrase = text(); },
function() {
options.data = text(); },
function() {
var idx, length;
length = options.data.multi_header.length;
for (idx = 0; idx < length; idx++) {
if (options.data.multi_header[idx].parsed === null) {
options.data = null;
break;
}
}
if (options.data !== null) {
options.data = options.data.multi_header;
} else {
options.data = -1;
}},
function() {
var header;
if(!options.data.multi_header) options.data.multi_header = [];
try {
header = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
delete options.data.uri;
delete options.data.displayName;
delete options.data.params;
} catch(e) {
header = null;
}
options.data.multi_header.push( { 'position': peg$currPos,
'offset': location().start.offset,
'parsed': header
});},
function(displayName) {
displayName = text().trim();
if (displayName[0] === '\"') {
displayName = displayName.substring(1, displayName.length-1);
}
options.data.displayName = displayName; },
"q",
peg$literalExpectation("q", true),
function(q) {
if(!options.data.params) options.data.params = {};
options.data.params['q'] = q; },
"expires",
peg$literalExpectation("expires", true),
function(expires) {
if(!options.data.params) options.data.params = {};
options.data.params['expires'] = expires; },
function(delta_seconds) {
return parseInt(delta_seconds.join('')); },
"0",
peg$literalExpectation("0", false),
function() {
return parseFloat(text()); },
function(param, value) {
if(!options.data.params) options.data.params = {};
if (value === null){
value = undefined;
}
else {
value = value[1];
}
options.data.params[param.toLowerCase()] = value;},
"render",
peg$literalExpectation("render", true),
"session",
peg$literalExpectation("session", true),
"icon",
peg$literalExpectation("icon", true),
"alert",
peg$literalExpectation("alert", true),
function() {
if (options.startRule === 'Content_Disposition') {
options.data.type = text().toLowerCase();
}
},
"handling",
peg$literalExpectation("handling", true),
"optional",
peg$literalExpectation("optional", true),
"required",
peg$literalExpectation("required", true),
function(length) {
options.data = parseInt(length.join('')); },
function() {
options.data = text(); },
"text",
peg$literalExpectation("text", true),
"image",
peg$literalExpectation("image", true),
"audio",
peg$literalExpectation("audio", true),
"video",
peg$literalExpectation("video", true),
"application",
peg$literalExpectation("application", true),
"message",
peg$literalExpectation("message", true),
"multipart",
peg$literalExpectation("multipart", true),
"x-",
peg$literalExpectation("x-", true),
function(cseq_value) {
options.data.value=parseInt(cseq_value.join('')); },
function(expires) {options.data = expires; },
function(event_type) {
options.data.event = event_type.toLowerCase(); },
function() {
var tag = options.data.tag;
options.data = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
if (tag) {options.data.setParam('tag',tag)}
},
"tag",
peg$literalExpectation("tag", true),
function(tag) {options.data.tag = tag; },
function(forwards) {
options.data = parseInt(forwards.join('')); },
function(min_expires) {options.data = min_expires; },
function() {
options.data = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
},
"digest",
peg$literalExpectation("Digest", true),
"realm",
peg$literalExpectation("realm", true),
function(realm) { options.data.realm = realm; },
"domain",
peg$literalExpectation("domain", true),
"nonce",
peg$literalExpectation("nonce", true),
function(nonce) { options.data.nonce=nonce; },
"opaque",
peg$literalExpectation("opaque", true),
function(opaque) { options.data.opaque=opaque; },
"stale",
peg$literalExpectation("stale", true),
"true",
peg$literalExpectation("true", true),
function() { options.data.stale=true; },
"false",
peg$literalExpectation("false", true),
function() { options.data.stale=false; },
"algorithm",
peg$literalExpectation("algorithm", true),
"md5",
peg$literalExpectation("MD5", true),
"md5-sess",
peg$literalExpectation("MD5-sess", true),
function(algorithm) {
options.data.algorithm=algorithm.toUpperCase(); },
"qop",
peg$literalExpectation("qop", true),
"auth-int",
peg$literalExpectation("auth-int", true),
"auth",
peg$literalExpectation("auth", true),
function(qop_value) {
options.data.qop || (options.data.qop=[]);
options.data.qop.push(qop_value.toLowerCase()); },
function(rack_value) {
options.data.value=parseInt(rack_value.join('')); },
function() {
var idx, length;
length = options.data.multi_header.length;
for (idx = 0; idx < length; idx++) {
if (options.data.multi_header[idx].parsed === null) {
options.data = null;
break;
}
}
if (options.data !== null) {
options.data = options.data.multi_header;
} else {
options.data = -1;
}},
function() {
var header;
if(!options.data.multi_header) options.data.multi_header = [];
try {
header = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
delete options.data.uri;
delete options.data.displayName;
delete options.data.params;
} catch(e) {
header = null;
}
options.data.multi_header.push( { 'position': peg$currPos,
'offset': location().start.offset,
'parsed': header
});},
function() {
options.data = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
},
function() {
if (!(options.data.replaces_from_tag && options.data.replaces_to_tag)) {
options.data = -1;
}
},
function() {
options.data = {
call_id: options.data
};
},
"from-tag",
peg$literalExpectation("from-tag", true),
function(from_tag) {
options.data.replaces_from_tag = from_tag;
},
"to-tag",
peg$literalExpectation("to-tag", true),
function(to_tag) {
options.data.replaces_to_tag = to_tag;
},
"early-only",
peg$literalExpectation("early-only", true),
function() {
options.data.early_only = true;
},
function(head, r) {return r;},
function(head, tail) { return list(head, tail); },
function(value) {
if (options.startRule === 'Require') {
options.data = value || [];
}
},
function(rseq_value) {
options.data.value=parseInt(rseq_value.join('')); },
"active",
peg$literalExpectation("active", true),
"pending",
peg$literalExpectation("pending", true),
"terminated",
peg$literalExpectation("terminated", true),
function() {
options.data.state = text(); },
"reason",
peg$literalExpectation("reason", true),
function(reason) {
if (typeof reason !== 'undefined') options.data.reason = reason; },
function(expires) {
if (typeof expires !== 'undefined') options.data.expires = expires; },
"retry_after",
peg$literalExpectation("retry_after", true),
function(retry_after) {
if (typeof retry_after !== 'undefined') options.data.retry_after = retry_after; },
"deactivated",
peg$literalExpectation("deactivated", true),
"probation",
peg$literalExpectation("probation", true),
"rejected",
peg$literalExpectation("rejected", true),
"timeout",
peg$literalExpectation("timeout", true),
"giveup",
peg$literalExpectation("giveup", true),
"noresource",
peg$literalExpectation("noresource", true),
"invariant",
peg$literalExpectation("invariant", true),
function(value) {
if (options.startRule === 'Supported') {
options.data = value || [];
}
},
function() {
var tag = options.data.tag;
options.data = new options.SIP.NameAddrHeader(options.data.uri, options.data.displayName, options.data.params);
if (tag) {options.data.setParam('tag',tag)}
},
"ttl",
peg$literalExpectation("ttl", true),
function(via_ttl_value) {
options.data.ttl = via_ttl_value; },
"maddr",
peg$literalExpectation("maddr", true),
function(via_maddr) {
options.data.maddr = via_maddr; },
"received",
peg$literalExpectation("received", true),
function(via_received) {
options.data.received = via_received; },
"branch",
peg$literalExpectation("branch", true),
function(via_branch) {
options.data.branch = via_branch; },
"rport",
peg$literalExpectation("rport", true),
function() {
if(typeof response_port !== 'undefined')
options.data.rport = response_port.join(''); },
function(via_protocol) {
options.data.protocol = via_protocol; },
peg$literalExpectation("UDP", true),
peg$literalExpectation("TCP", true),
peg$literalExpectation("TLS", true),
peg$literalExpectation("SCTP", true),
function(via_transport) {
options.data.transport = via_transport; },
function() {
options.data.host = text(); },
function(via_sent_by_port) {
options.data.port = parseInt(via_sent_by_port.join('')); },
function(ttl) {
return parseInt(ttl.join('')); },
function(deltaSeconds) {
if (options.startRule === 'Session_Expires') {
options.data.deltaSeconds = deltaSeconds;
}
},
"refresher",
peg$literalExpectation("refresher", false),
"uas",
peg$literalExpectation("uas", false),
"uac",
peg$literalExpectation("uac", false),
function(endpoint) {
if (options.startRule === 'Session_Expires') {
options.data.refresher = endpoint;
}
},
function(deltaSeconds) {
if (options.startRule === 'Min_SE') {
options.data = deltaSeconds;
}
},
"stuns",
peg$literalExpectation("stuns", true),
"stun",
peg$literalExpectation("stun", true),
function(scheme) {
options.data.scheme = scheme; },
function(host) {
options.data.host = host; },
"?transport=",
peg$literalExpectation("?transport=", false),
"turns",
peg$literalExpectation("turns", true),
"turn",
peg$literalExpectation("turn", true),
function() {
options.data.transport = transport; },
function() {
options.data = text(); },
"Referred-By",
peg$literalExpectation("Referred-By", false),
"b",
peg$literalExpectation("b", false),
"cid",
peg$literalExpectation("cid", false)
],
peg$bytecode = [
peg$decode("2 \"\"6 7!"),
peg$decode("4\"\"\"5!7#"),
peg$decode("4$\"\"5!7%"),
peg$decode("4&\"\"5!7'"),
peg$decode(";'.# &;("),
peg$decode("4(\"\"5!7)"),
peg$decode("4*\"\"5!7+"),
peg$decode("2,\"\"6,7-"),
peg$decode("2.\"\"6.7/"),
peg$decode("40\"\"5!71"),
peg$decode("22\"\"6273.\x89 &24\"\"6475.} &26\"\"6677.q &28\"\"6879.e &2:\"\"6:7;.Y &2<\"\"6<7=.M &2>\"\"6>7?.A &2@\"\"6@7A.5 &2B\"\"6B7C.) &2D\"\"6D7E"),
peg$decode(";).# &;,"),
peg$decode("2F\"\"6F7G.} &2H\"\"6H7I.q &2J\"\"6J7K.e &2L\"\"6L7M.Y &2N\"\"6N7O.M &2P\"\"6P7Q.A &2R\"\"6R7S.5 &2T\"\"6T7U.) &2V\"\"6V7W"),
peg$decode("%%2X\"\"6X7Y/5#;#/,$;#/#$+#)(#'#(\"'#&'#/\"!&,)"),
peg$decode("%%$;$0#*;$&/,#; /#$+\")(\"'#&'#.\" &\"/=#$;$/�#*;$&&&#/'$8\":Z\" )(\"'#&'#"),
peg$decode(";..\" &\""),
peg$decode("%$;'.# &;(0)*;'.# &;(&/?#28\"\"6879/0$;//'$8#:[# )(#'#(\"'#&'#"),
peg$decode("%%$;2/�#*;2&&&#/g#$%$;.0#*;.&/,#;2/#$+\")(\"'#&'#0=*%$;.0#*;.&/,#;2/#$+\")(\"'#&'#&/#$+\")(\"'#&'#/\"!&,)"),
peg$decode("4\\\"\"5!7].# &;3"),
peg$decode("4^\"\"5!7_"),
peg$decode("4`\"\"5!7a"),
peg$decode(";!.) &4b\"\"5!7c"),
peg$decode("%$;).\x95 &2F\"\"6F7G.\x89 &2J\"\"6J7K.} &2L\"\"6L7M.q &2X\"\"6X7Y.e &2P\"\"6P7Q.Y &2H\"\"6H7I.M &2@\"\"6@7A.A &2d\"\"6d7e.5 &2R\"\"6R7S.) &2N\"\"6N7O/\x9E#0\x9B*;).\x95 &2F\"\"6F7G.\x89 &2J\"\"6J7K.} &2L\"\"6L7M.q &2X\"\"6X7Y.e &2P\"\"6P7Q.Y &2H\"\"6H7I.M &2@\"\"6@7A.A &2d\"\"6d7e.5 &2R\"\"6R7S.) &2N\"\"6N7O&&&#/\"!&,)"),
peg$decode("%$;).\x89 &2F\"\"6F7G.} &2L\"\"6L7M.q &2X\"\"6X7Y.e &2P\"\"6P7Q.Y &2H\"\"6H7I.M &2@\"\"6@7A.A &2d\"\"6d7e.5 &2R\"\"6R7S.) &2N\"\"6N7O/\x92#0\x8F*;).\x89 &2F\"\"6F7G.} &2L\"\"6L7M.q &2X\"\"6X7Y.e &2P\"\"6P7Q.Y &2H\"\"6H7I.M &2@\"\"6@7A.A &2d\"\"6d7e.5 &2R\"\"6R7S.) &2N\"\"6N7O&&&#/\"!&,)"),
peg$decode("2T\"\"6T7U.\xE3 &2V\"\"6V7W.\xD7 &2f\"\"6f7g.\xCB &2h\"\"6h7i.\xBF &2:\"\"6:7;.\xB3 &2D\"\"6D7E.\xA7 &22\"\"6273.\x9B &28\"\"6879.\x8F &2j\"\"6j7k.\x83 &;&.} &24\"\"6475.q &2l\"\"6l7m.e &2n\"\"6n7o.Y &26\"\"6677.M &2>\"\"6>7?.A &2p\"\"6p7q.5 &2r\"\"6r7s.) &;'.# &;("),
peg$decode("%$;).\u012B &2F\"\"6F7G.\u011F &2J\"\"6J7K.\u0113 &2L\"\"6L7M.\u0107 &2X\"\"6X7Y.\xFB &2P\"\"6P7Q.\xEF &2H\"\"6H7I.\xE3 &2@\"\"6@7A.\xD7 &2d\"\"6d7e.\xCB &2R\"\"6R7S.\xBF &2N\"\"6N7O.\xB3 &2T\"\"6T7U.\xA7 &2V\"\"6V7W.\x9B &2f\"\"6f7g.\x8F &2h\"\"6h7i.\x83 &28\"\"6879.w &2j\"\"6j7k.k &;&.e &24\"\"6475.Y &2l\"\"6l7m.M &2n\"\"6n7o.A &26\"\"6677.5 &2p\"\"6p7q.) &2r\"\"6r7s/\u0134#0\u0131*;).\u012B &2F\"\"6F7G.\u011F &2J\"\"6J7K.\u0113 &2L\"\"6L7M.\u0107 &2X\"\"6X7Y.\xFB &2P\"\"6P7Q.\xEF &2H\"\"6H7I.\xE3 &2@\"\"6@7A.\xD7 &2d\"\"6d7e.\xCB &2R\"\"6R7S.\xBF &2N\"\"6N7O.\xB3 &2T\"\"6T7U.\xA7 &2V\"\"6V7W.\x9B &2f\"\"6f7g.\x8F &2h\"\"6h7i.\x83 &28\"\"6879.w &2j\"\"6j7k.k &;&.e &24\"\"6475.Y &2l\"\"6l7m.M &2n\"\"6n7o.A &26\"\"6677.5 &2p\"\"6p7q.) &2r\"\"6r7s&&&#/\"!&,)"),
peg$decode("%;//?#2P\"\"6P7Q/0$;//'$8#:t# )(#'#(\"'#&'#"),
peg$decode("%;//?#24\"\"6475/0$;//'$8#:u# )(#'#(\"'#&'#"),
peg$decode("%;//?#2>\"\"6>7?/0$;//'$8#:v# )(#'#(\"'#&'#"),
peg$decode("%;//?#2T\"\"6T7U/0$;//'$8#:w# )(#'#(\"'#&'#"),
peg$decode("%;//?#2V\"\"6V7W/0$;//'$8#:x# )(#'#(\"'#&'#"),
peg$decode("%2h\"\"6h7i/0#;//'$8\":y\" )(\"'#&'#"),
peg$decode("%;//6#2f\"\"6f7g/'$8\":z\" )(\"'#&'#"),
peg$decode("%;//?#2D\"\"6D7E/0$;//'$8#:{# )(#'#(\"'#&'#"),
peg$decode("%;//?#22\"\"6273/0$;//'$8#:|# )(#'#(\"'#&'#"),
peg$decode("%;//?#28\"\"6879/0$;//'$8#:}# )(#'#(\"'#&'#"),
peg$decode("%;//0#;&/'$8\":~\" )(\"'#&'#"),
peg$decode("%;&/0#;//'$8\":~\" )(\"'#&'#"),
peg$decode("%;=/T#$;G.) &;K.# &;F0/*;G.) &;K.# &;F&/,$;>/#$+#)(#'#(\"'#&'#"),
peg$decode("4\x7F\"\"5!7\x80.A &4\x81\"\"5!7\x82.5 &4\x83\"\"5!7\x84.) &;3.# &;."),
peg$decode("%%;//Q#;&/H$$;J.# &;K0)*;J.# &;K&/,$;&/#$+$)($'#(#'#(\"'#&'#/\"!&,)"),
peg$decode("%;//]#;&/T$%$;J.# &;K0)*;J.# &;K&/\"!&,)/1$;&/($8$:\x85$!!)($'#(#'#(\"'#&'#"),
peg$decode(";..G &2L\"\"6L7M.; &4\x86\"\"5!7\x87./ &4\x83\"\"5!7\x84.# &;3"),
peg$decode("%2j\"\"6j7k/J#4\x88\"\"5!7\x89.5 &4\x8A\"\"5!7\x8B.) &4\x8C\"\"5!7\x8D/#$+\")(\"'#&'#"),
peg$decode("%;N/M#28\"\"6879/>$;O.\" &\"/0$;S/'$8$:\x8E$ )($'#(#'#(\"'#&'#"),
peg$decode("%;N/d#28\"\"6879/U$;O.\" &\"/G$;S/>$;_/5$;l.\" &\"/'$8&:\x8F& )(&'#(%'#($'#(#'#(\"'#&'#"),
peg$decode("%3\x90\"\"5$7\x91.) &3\x92\"\"5#7\x93/' 8!:\x94!! )"),
peg$decode("%;P/]#%28\"\"6879/,#;R/#$+\")(\"'#&'#.\" &\"/6$2:\"\"6:7;/'$8#:\x95# )(#'#(\"'#&'#"),
peg$decode("$;+.) &;-.# &;Q/2#0/*;+.) &;-.# &;Q&&&#"),
peg$decode("2<\"\"6<7=.q &2>\"\"6>7?.e &2@\"\"6@7A.Y &2B\"\"6B7C.M &2D\"\"6D7E.A &22\"\"6273.5 &26\"\"6677.) &24\"\"6475"),
peg$decode("%$;+._ &;-.Y &2<\"\"6<7=.M &2>\"\"6>7?.A &2@\"\"6@7A.5 &2B\"\"6B7C.) &2D\"\"6D7E0e*;+._ &;-.Y &2<\"\"6<7=.M &2>\"\"6>7?.A &2@\"\"6@7A.5 &2B\"\"6B7C.) &2D\"\"6D7E&/& 8!:\x96! )"),
peg$decode("%;T/J#%28\"\"6879/,#;^/#$+\")(\"'#&'#.\" &\"/#$+\")(\"'#&'#"),
peg$decode("%;U.) &;\\.# &;X/& 8!:\x97! )"),
peg$decode("%$%;V/2#2J\"\"6J7K/#$+\")(\"'#&'#0<*%;V/2#2J\"\"6J7K/#$+\")(\"'#&'#&/D#;W/;$2J\"\"6J7K.\" &\"/'$8#:\x98# )(#'#(\"'#&'#"),
peg$decode("$4\x99\"\"5!7\x9A/,#0)*4\x99\"\"5!7\x9A&&&#"),
peg$decode("%4$\"\"5!7%/?#$4\x9B\"\"5!7\x9C0)*4\x9B\"\"5!7\x9C&/#$+\")(\"'#&'#"),
peg$decode("%2l\"\"6l7m/?#;Y/6$2n\"\"6n7o/'$8#:\x9D# )(#'#(\"'#&'#"),
peg$decode("%%;Z/\xB3#28\"\"6879/\xA4$;Z/\x9B$28\"\"6879/\x8C$;Z/\x83$28\"\"6879/t$;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+-)(-'#(,'#(+'#(*'#()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u0790 &%2\x9E\"\"6\x9E7\x9F/\xA4#;Z/\x9B$28\"\"6879/\x8C$;Z/\x83$28\"\"6879/t$;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+,)(,'#(+'#(*'#()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u06F9 &%2\x9E\"\"6\x9E7\x9F/\x8C#;Z/\x83$28\"\"6879/t$;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+*)(*'#()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u067A &%2\x9E\"\"6\x9E7\x9F/t#;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+()(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u0613 &%2\x9E\"\"6\x9E7\x9F/\\#;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+&)(&'#(%'#($'#(#'#(\"'#&'#.\u05C4 &%2\x9E\"\"6\x9E7\x9F/D#;Z/;$28\"\"6879/,$;[/#$+$)($'#(#'#(\"'#&'#.\u058D &%2\x9E\"\"6\x9E7\x9F/,#;[/#$+\")(\"'#&'#.\u056E &%2\x9E\"\"6\x9E7\x9F/,#;Z/#$+\")(\"'#&'#.\u054F &%;Z/\x9B#2\x9E\"\"6\x9E7\x9F/\x8C$;Z/\x83$28\"\"6879/t$;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$++)(+'#(*'#()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u04C7 &%;Z/\xAA#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\x83$2\x9E\"\"6\x9E7\x9F/t$;Z/k$28\"\"6879/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+*)(*'#()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u0430 &%;Z/\xB9#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\x92$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/k$2\x9E\"\"6\x9E7\x9F/\\$;Z/S$28\"\"6879/D$;Z/;$28\"\"6879/,$;[/#$+))()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u038A &%;Z/\xC8#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xA1$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/z$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/S$2\x9E\"\"6\x9E7\x9F/D$;Z/;$28\"\"6879/,$;[/#$+()(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u02D5 &%;Z/\xD7#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xB0$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\x89$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/b$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/;$2\x9E\"\"6\x9E7\x9F/,$;[/#$+')(''#(&'#(%'#($'#(#'#(\"'#&'#.\u0211 &%;Z/\xFE#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xD7$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xB0$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\x89$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/b$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/;$2\x9E\"\"6\x9E7\x9F/,$;Z/#$+()(('#(''#(&'#(%'#($'#(#'#(\"'#&'#.\u0126 &%;Z/\u011C#%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xF5$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xCE$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\xA7$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/\x80$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/Y$%28\"\"6879/,#;Z/#$+\")(\"'#&'#.\" &\"/2$2\x9E\"\"6\x9E7\x9F/#$+()(('#(''#(&'#(%'#($'#(#'#(\"'#&'#/& 8!:\xA0! )"),
peg$decode("%;#/M#;#.\" &\"/?$;#.\" &\"/1$;#.\" &\"/#$+$)($'#(#'#(\"'#&'#"),
peg$decode("%;Z/;#28\"\"6879/,$;Z/#$+#)(#'#(\"'#&'#.# &;\\"),
peg$decode("%;]/o#2J\"\"6J7K/`$;]/W$2J\"\"6J7K/H$;]/?$2J\"\"6J7K/0$;]/'$8':\xA1' )(''#(&'#(%'#($'#(#'#(\"'#&'#"),
peg$decode("%2\xA2\"\"6\xA27\xA3/2#4\xA4\"\"5!7\xA5/#$+\")(\"'#&'#.\x98 &%2\xA6\"\"6\xA67\xA7/;#4\xA8\"\"5!7\xA9/,$;!/#$+#)(#'#(\"'#&'#.j &%2\xAA\"\"6\xAA7\xAB/5#;!/,$;!/#$+#)(#'#(\"'#&'#.B &%4\xAC\"\"5!7\xAD/,#;!/#$+\")(\"'#&'#.# &;!"),
peg$decode("%%;!.\" &\"/[#;!.\" &\"/M$;!.\" &\"/?$;!.\" &\"/1$;!.\" &\"/#$+%)(%'#($'#(#'#(\"'#&'#/' 8!:\xAE!! )"),
peg$decode("$%22\"\"6273/,#;`/#$+\")(\"'#&'#0<*%22\"\"6273/,#;`/#$+\")(\"'#&'#&"),
peg$decode(";a.A &;b.; &;c.5 &;d./ &;e.) &;f.# &;g"),
peg$decode("%3\xAF\"\"5*7\xB0/a#3\xB1\"\"5#7\xB2.G &3\xB3\"\"5#7\xB4.; &3\xB5\"\"5$7\xB6./ &3\xB7\"\"5#7\xB8.# &;6/($8\":\xB9\"! )(\"'#&'#"),
peg$decode("%3\xBA\"\"5%7\xBB/I#3\xBC\"\"5%7\xBD./ &3\xBE\"\"5\"7\xBF.# &;6/($8\":\xC0\"! )(\"'#&'#"),
peg$decode("%3\xC1\"\"5'7\xC2/1#;\x90/($8\":\xC3\"! )(\"'#&'#"),
peg$decode("%3\xC4\"\"5$7\xC5/1#;\xF0/($8\":\xC6\"! )(\"'#&'#"),
peg$decode("%3\xC7\"\"5&7\xC8/1#;T/($8\":\xC9\"! )(\"'#&'#"),
peg$decode("%3\xCA\"\"5\"7\xCB/N#%2>\"\"6>7?/,#;6/#$+\")(\"'#&'#.\" &\"/'$8\":\xCC\" )(\"'#&'#"),
peg$decode("%;h/P#%2>\"\"6>7?/,#;i/#$+\")(\"'#&'#.\" &\"/)$8\":\xCD\"\"! )(\"'#&'#"),
peg$decode("%$;j/�#*;j&&&#/\"!&,)"),
peg$decode("%$;j/�#*;j&&&#/\"!&,)"),
peg$decode(";k.) &;+.# &;-"),
peg$decode("2l\"\"6l7m.e &2n\"\"6n7o.Y &24\"\"6475.M &28\"\"6879.A &2<\"\"6<7=.5 &2@\"\"6@7A.) &2B\"\"6B7C"),
peg$decode("%26\"\"6677/n#;m/e$$%2<\"\"6<7=/,#;m/#$+\")(\"'#&'#0<*%2<\"\"6<7=/,#;m/#$+\")(\"'#&'#&/#$+#)(#'#(\"'#&'#"),
peg$decode("%;n/A#2>\"\"6>7?/2$;o/)$8#:\xCE#\"\" )(#'#(\"'#&'#"),
peg$decode("$;p.) &;+.# &;-/2#0/*;p.) &;+.# &;-&&&#"),
peg$decode("$;p.) &;+.# &;-0/*;p.) &;+.# &;-&"),
peg$decode("2l\"\"6l7m.e &2n\"\"6n7o.Y &24\"\"6475.M &26\"\"6677.A &28\"\"6879.5 &2@\"\"6@7A.) &2B\"\"6B7C"),
peg$decode(";\x91.# &;r"),
peg$decode("%;\x90/G#;'/>$;s/5$;'/,$;\x84/#$+%)(%'#($'#(#'#(\"'#&'#"),
peg$decode(";M.# &;t"),
peg$decode("%;\x7F/E#28\"\"6879/6$;u.# &;x/'$8#:\xCF# )(#'#(\"'#&'#"),
peg$decode("%;v.# &;w/J#%26\"\"6677/,#;\x83/#$+\")(\"'#&'#.\" &\"/#$+\")(\"'#&'#"),
peg$decode("%2\xD0\"\"6\xD07\xD1/:#;\x80/1$;w.\" &\"/#$+#)(#'#(\"'#&'#"),
peg$decode("%24\"\"6475/,#;{/#$+\")(\"'#&'#"),
peg$decode("%;z/3#$;y0#*;y&/#$+\")(\"'#&'#"),
peg$decode(";*.) &;+.# &;-"),
peg$decode(";+.\x8F &;-.\x89 &22\"\"6273.} &26\"\"6677.q &28\"\"6879.e &2:\"\"6:7;.Y &2<\"\"6<7=.M &2>\"\"6>7?.A &2@\"\"6@7A.5 &2B\"\"6B7C.) &2D\"\"6D7E"),
peg$decode("%;|/e#$%24\"\"6475/,#;|/#$+\")(\"'#&'#0<*%24\"\"6475/,#;|/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%$;~0#*;~&/e#$%22\"\"6273/,#;}/#$+\")(\"'#&'#0<*%22\"\"6273/,#;}/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("$;~0#*;~&"),
peg$decode(";+.w &;-.q &28\"\"6879.e &2:\"\"6:7;.Y &2<\"\"6<7=.M &2>\"\"6>7?.A &2@\"\"6@7A.5 &2B\"\"6B7C.) &2D\"\"6D7E"),
peg$decode("%%;\"/\x87#$;\".G &;!.A &2@\"\"6@7A.5 &2F\"\"6F7G.) &2J\"\"6J7K0M*;\".G &;!.A &2@\"\"6@7A.5 &2F\"\"6F7G.) &2J\"\"6J7K&/#$+\")(\"'#&'#/& 8!:\xD2! )"),
peg$decode(";\x81.# &;\x82"),
peg$decode("%%;O/2#2:\"\"6:7;/#$+\")(\"'#&'#.\" &\"/,#;S/#$+\")(\"'#&'#.\" &\""),
peg$decode("$;+.\x83 &;-.} &2B\"\"6B7C.q &2D\"\"6D7E.e &22\"\"6273.Y &28\"\"6879.M &2:\"\"6:7;.A &2<\"\"6<7=.5 &2>\"\"6>7?.) &2@\"\"6@7A/\x8C#0\x89*;+.\x83 &;-.} &2B\"\"6B7C.q &2D\"\"6D7E.e &22\"\"6273.Y &28\"\"6879.M &2:\"\"6:7;.A &2<\"\"6<7=.5 &2>\"\"6>7?.) &2@\"\"6@7A&&&#"),
peg$decode("$;y0#*;y&"),
peg$decode("%3\x92\"\"5#7\xD3/q#24\"\"6475/b$$;!/�#*;!&&&#/L$2J\"\"6J7K/=$$;!/�#*;!&&&#/'$8%:\xD4% )(%'#($'#(#'#(\"'#&'#"),
peg$decode("2\xD5\"\"6\xD57\xD6"),
peg$decode("2\xD7\"\"6\xD77\xD8"),
peg$decode("2\xD9\"\"6\xD97\xDA"),
peg$decode("2\xDB\"\"6\xDB7\xDC"),
peg$decode("2\xDD\"\"6\xDD7\xDE"),
peg$decode("2\xDF\"\"6\xDF7\xE0"),
peg$decode("2\xE1\"\"6\xE17\xE2"),
peg$decode("2\xE3\"\"6\xE37\xE4"),
peg$decode("2\xE5\"\"6\xE57\xE6"),
peg$decode("2\xE7\"\"6\xE77\xE8"),
peg$decode("2\xE9\"\"6\xE97\xEA"),
peg$decode("%;\x85.Y &;\x86.S &;\x88.M &;\x89.G &;\x8A.A &;\x8B.; &;\x8C.5 &;\x8F./ &;\x8D.) &;\x8E.# &;6/& 8!:\xEB! )"),
peg$decode("%;\x84/G#;'/>$;\x92/5$;'/,$;\x94/#$+%)(%'#($'#(#'#(\"'#&'#"),
peg$decode("%;\x93/' 8!:\xEC!! )"),
peg$decode("%;!/5#;!/,$;!/#$+#)(#'#(\"'#&'#"),
peg$decode("%$;*.A &;+.; &;-.5 &;3./ &;4.) &;'.# &;(0G*;*.A &;+.; &;-.5 &;3./ &;4.) &;'.# &;(&/& 8!:\xED! )"),
peg$decode("%;\xB6/Y#$%;A/,#;\xB6/#$+\")(\"'#&'#06*%;A/,#;\xB6/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%;9/N#%2:\"\"6:7;/,#;9/#$+\")(\"'#&'#.\" &\"/'$8\":\xEE\" )(\"'#&'#"),
peg$decode("%;:.c &%;\x98/Y#$%;A/,#;\x98/#$+\")(\"'#&'#06*%;A/,#;\x98/#$+\")(\"'#&'#&/#$+\")(\"'#&'#/& 8!:\xEF! )"),
peg$decode("%;L.# &;\x99/]#$%;B/,#;\x9B/#$+\")(\"'#&'#06*%;B/,#;\x9B/#$+\")(\"'#&'#&/'$8\":\xF0\" )(\"'#&'#"),
peg$decode("%;\x9A.\" &\"/>#;@/5$;M/,$;?/#$+$)($'#(#'#(\"'#&'#"),
peg$decode("%%;6/Y#$%;./,#;6/#$+\")(\"'#&'#06*%;./,#;6/#$+\")(\"'#&'#&/#$+\")(\"'#&'#.# &;H/' 8!:\xF1!! )"),
peg$decode(";\x9C.) &;\x9D.# &;\xA0"),
peg$decode("%3\xF2\"\"5!7\xF3/:#;</1$;\x9F/($8#:\xF4#! )(#'#(\"'#&'#"),
peg$decode("%3\xF5\"\"5'7\xF6/:#;</1$;\x9E/($8#:\xF7#! )(#'#(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\xF8!! )"),
peg$decode("%2\xF9\"\"6\xF97\xFA/o#%2J\"\"6J7K/M#;!.\" &\"/?$;!.\" &\"/1$;!.\" &\"/#$+$)($'#(#'#(\"'#&'#.\" &\"/'$8\":\xFB\" )(\"'#&'#"),
peg$decode("%;6/J#%;</,#;\xA1/#$+\")(\"'#&'#.\" &\"/)$8\":\xFC\"\"! )(\"'#&'#"),
peg$decode(";6.) &;T.# &;H"),
peg$decode("%;\xA3/Y#$%;B/,#;\xA4/#$+\")(\"'#&'#06*%;B/,#;\xA4/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%3\xFD\"\"5&7\xFE.G &3\xFF\"\"5'7\u0100.; &3\u0101\"\"5$7\u0102./ &3\u0103\"\"5%7\u0104.# &;6/& 8!:\u0105! )"),
peg$decode(";\xA5.# &;\xA0"),
peg$decode("%3\u0106\"\"5(7\u0107/M#;</D$3\u0108\"\"5(7\u0109./ &3\u010A\"\"5(7\u010B.# &;6/#$+#)(#'#(\"'#&'#"),
peg$decode("%;6/Y#$%;A/,#;6/#$+\")(\"'#&'#06*%;A/,#;6/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\u010C!! )"),
peg$decode("%;\xA9/& 8!:\u010D! )"),
peg$decode("%;\xAA/k#;;/b$;\xAF/Y$$%;B/,#;\xB0/#$+\")(\"'#&'#06*%;B/,#;\xB0/#$+\")(\"'#&'#&/#$+$)($'#(#'#(\"'#&'#"),
peg$decode(";\xAB.# &;\xAC"),
peg$decode("3\u010E\"\"5$7\u010F.S &3\u0110\"\"5%7\u0111.G &3\u0112\"\"5%7\u0113.; &3\u0114\"\"5%7\u0115./ &3\u0116\"\"5+7\u0117.# &;\xAD"),
peg$decode("3\u0118\"\"5'7\u0119./ &3\u011A\"\"5)7\u011B.# &;\xAD"),
peg$decode(";6.# &;\xAE"),
peg$decode("%3\u011C\"\"5\"7\u011D/,#;6/#$+\")(\"'#&'#"),
peg$decode(";\xAD.# &;6"),
peg$decode("%;6/5#;</,$;\xB1/#$+#)(#'#(\"'#&'#"),
peg$decode(";6.# &;H"),
peg$decode("%;\xB3/5#;./,$;\x90/#$+#)(#'#(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\u011E!! )"),
peg$decode("%;\x9E/' 8!:\u011F!! )"),
peg$decode("%;\xB6/^#$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/($8\":\u0120\"!!)(\"'#&'#"),
peg$decode("%%;7/e#$%2J\"\"6J7K/,#;7/#$+\")(\"'#&'#0<*%2J\"\"6J7K/,#;7/#$+\")(\"'#&'#&/#$+\")(\"'#&'#/\"!&,)"),
peg$decode("%;L.# &;\x99/]#$%;B/,#;\xB8/#$+\")(\"'#&'#06*%;B/,#;\xB8/#$+\")(\"'#&'#&/'$8\":\u0121\" )(\"'#&'#"),
peg$decode(";\xB9.# &;\xA0"),
peg$decode("%3\u0122\"\"5#7\u0123/:#;</1$;6/($8#:\u0124#! )(#'#(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\u0125!! )"),
peg$decode("%;\x9E/' 8!:\u0126!! )"),
peg$decode("%$;\x9A0#*;\x9A&/x#;@/o$;M/f$;?/]$$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/'$8%:\u0127% )(%'#($'#(#'#(\"'#&'#"),
peg$decode(";\xBE"),
peg$decode("%3\u0128\"\"5&7\u0129/k#;./b$;\xC1/Y$$%;A/,#;\xC1/#$+\")(\"'#&'#06*%;A/,#;\xC1/#$+\")(\"'#&'#&/#$+$)($'#(#'#(\"'#&'#.# &;\xBF"),
peg$decode("%;6/k#;./b$;\xC0/Y$$%;A/,#;\xC0/#$+\")(\"'#&'#06*%;A/,#;\xC0/#$+\")(\"'#&'#&/#$+$)($'#(#'#(\"'#&'#"),
peg$decode("%;6/;#;</2$;6.# &;H/#$+#)(#'#(\"'#&'#"),
peg$decode(";\xC2.G &;\xC4.A &;\xC6.; &;\xC8.5 &;\xC9./ &;\xCA.) &;\xCB.# &;\xC0"),
peg$decode("%3\u012A\"\"5%7\u012B/5#;</,$;\xC3/#$+#)(#'#(\"'#&'#"),
peg$decode("%;I/' 8!:\u012C!! )"),
peg$decode("%3\u012D\"\"5&7\u012E/\x97#;</\x8E$;D/\x85$;\xC5/|$$%$;'/�#*;'&&&#/,#;\xC5/#$+\")(\"'#&'#0C*%$;'/�#*;'&&&#/,#;\xC5/#$+\")(\"'#&'#&/,$;E/#$+&)(&'#(%'#($'#(#'#(\"'#&'#"),
peg$decode(";t.# &;w"),
peg$decode("%3\u012F\"\"5%7\u0130/5#;</,$;\xC7/#$+#)(#'#(\"'#&'#"),
peg$decode("%;I/' 8!:\u0131!! )"),
peg$decode("%3\u0132\"\"5&7\u0133/:#;</1$;I/($8#:\u0134#! )(#'#(\"'#&'#"),
peg$decode("%3\u0135\"\"5%7\u0136/]#;</T$%3\u0137\"\"5$7\u0138/& 8!:\u0139! ).4 &%3\u013A\"\"5%7\u013B/& 8!:\u013C! )/#$+#)(#'#(\"'#&'#"),
peg$decode("%3\u013D\"\"5)7\u013E/R#;</I$3\u013F\"\"5#7\u0140./ &3\u0141\"\"5(7\u0142.# &;6/($8#:\u0143#! )(#'#(\"'#&'#"),
peg$decode("%3\u0144\"\"5#7\u0145/\x93#;</\x8A$;D/\x81$%;\xCC/e#$%2D\"\"6D7E/,#;\xCC/#$+\")(\"'#&'#0<*%2D\"\"6D7E/,#;\xCC/#$+\")(\"'#&'#&/#$+\")(\"'#&'#/,$;E/#$+%)(%'#($'#(#'#(\"'#&'#"),
peg$decode("%3\u0146\"\"5(7\u0147./ &3\u0148\"\"5$7\u0149.# &;6/' 8!:\u014A!! )"),
peg$decode("%;6/Y#$%;A/,#;6/#$+\")(\"'#&'#06*%;A/,#;6/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%;\xCF/G#;./>$;\xCF/5$;./,$;\x90/#$+%)(%'#($'#(#'#(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\u014B!! )"),
peg$decode("%;\xD1/]#$%;A/,#;\xD1/#$+\")(\"'#&'#06*%;A/,#;\xD1/#$+\")(\"'#&'#&/'$8\":\u014C\" )(\"'#&'#"),
peg$decode("%;\x99/]#$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/'$8\":\u014D\" )(\"'#&'#"),
peg$decode("%;L.O &;\x99.I &%;@.\" &\"/:#;t/1$;?.\" &\"/#$+#)(#'#(\"'#&'#/]#$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/'$8\":\u014E\" )(\"'#&'#"),
peg$decode("%;\xD4/]#$%;B/,#;\xD5/#$+\")(\"'#&'#06*%;B/,#;\xD5/#$+\")(\"'#&'#&/'$8\":\u014F\" )(\"'#&'#"),
peg$decode("%;\x96/& 8!:\u0150! )"),
peg$decode("%3\u0151\"\"5(7\u0152/:#;</1$;6/($8#:\u0153#! )(#'#(\"'#&'#.g &%3\u0154\"\"5&7\u0155/:#;</1$;6/($8#:\u0156#! )(#'#(\"'#&'#.: &%3\u0157\"\"5*7\u0158/& 8!:\u0159! ).# &;\xA0"),
peg$decode("%%;6/k#$%;A/2#;6/)$8\":\u015A\"\"$ )(\"'#&'#0<*%;A/2#;6/)$8\":\u015A\"\"$ )(\"'#&'#&/)$8\":\u015B\"\"! )(\"'#&'#.\" &\"/' 8!:\u015C!! )"),
peg$decode("%;\xD8/Y#$%;A/,#;\xD8/#$+\")(\"'#&'#06*%;A/,#;\xD8/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%;\x99/Y#$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%$;!/�#*;!&&&#/' 8!:\u015D!! )"),
peg$decode("%;\xDB/Y#$%;B/,#;\xDC/#$+\")(\"'#&'#06*%;B/,#;\xDC/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%3\u015E\"\"5&7\u015F.; &3\u0160\"\"5'7\u0161./ &3\u0162\"\"5*7\u0163.# &;6/& 8!:\u0164! )"),
peg$decode("%3\u0165\"\"5&7\u0166/:#;</1$;\xDD/($8#:\u0167#! )(#'#(\"'#&'#.} &%3\xF5\"\"5'7\xF6/:#;</1$;\x9E/($8#:\u0168#! )(#'#(\"'#&'#.P &%3\u0169\"\"5+7\u016A/:#;</1$;\x9E/($8#:\u016B#! )(#'#(\"'#&'#.# &;\xA0"),
peg$decode("3\u016C\"\"5+7\u016D.k &3\u016E\"\"5)7\u016F._ &3\u0170\"\"5(7\u0171.S &3\u0172\"\"5'7\u0173.G &3\u0174\"\"5&7\u0175.; &3\u0176\"\"5*7\u0177./ &3\u0178\"\"5)7\u0179.# &;6"),
peg$decode(";1.\" &\""),
peg$decode("%%;6/k#$%;A/2#;6/)$8\":\u015A\"\"$ )(\"'#&'#0<*%;A/2#;6/)$8\":\u015A\"\"$ )(\"'#&'#&/)$8\":\u015B\"\"! )(\"'#&'#.\" &\"/' 8!:\u017A!! )"),
peg$decode("%;L.# &;\x99/]#$%;B/,#;\xE1/#$+\")(\"'#&'#06*%;B/,#;\xE1/#$+\")(\"'#&'#&/'$8\":\u017B\" )(\"'#&'#"),
peg$decode(";\xB9.# &;\xA0"),
peg$decode("%;\xE3/Y#$%;A/,#;\xE3/#$+\")(\"'#&'#06*%;A/,#;\xE3/#$+\")(\"'#&'#&/#$+\")(\"'#&'#"),
peg$decode("%;\xEA/k#;./b$;\xED/Y$$%;B/,#;\xE4/#$+\")(\"'#&'#06*%;B/,#;\xE4/#$+\")(\"'#&'#&/#$+$)($'#(#'#(\"'#&'#"),
peg$decode(";\xE5.; &;\xE6.5 &;\xE7./ &;\xE8.) &;\xE9.# &;\xA0"),
peg$decode("%3\u017C\"\"5#7\u017D/:#;</1$;\xF0/($8#:\u017E#! )(#'#(\"'#&'#"),
peg$decode("%3\u017F\"\"5%7\u0180/:#;</1$;T/($8#:\u0181#! )(#'#(\"'#&'#"),
peg$decode("%3\u0182\"\"5(7\u0183/F#;</=$;\\.) &;Y.# &;X/($8#:\u0184#! )(#'#(\"'#&'#"),
peg$decode("%3\u0185\"\"5&7\u0186/:#;</1$;6/($8#:\u0187#! )(#'#(\"'#&'#"),
peg$decode("%3\u0188\"\"5%7\u0189/O#%;</3#$;!0#*;!&/#$+\")(\"'#&'#.\" &\"/'$8\":\u018A\" )(\"'#&'#"),
peg$decode("%;\xEB/G#;;/>$;6/5$;;/,$;\xEC/#$+%)(%'#($'#(#'#(\"'#&'#"),
peg$decode("%3\x92\"\"5#7\xD3.# &;6/' 8!:\u018B!! )"),
peg$decode("%3\xB1\"\"5#7\u018C.G &3\xB3\"\"5#7\u018D.; &3\xB7\"\"5#7\u018E./ &3\xB5\"\"5$7\u018F.# &;6/' 8!:\u0190!! )"),
peg$decode("%;\xEE/D#%;C/,#;\xEF/#$+\")(\"'#&'#.\" &\"/#$+\")(\"'#&'#"),
peg$decode("%;U.) &;\\.# &;X/& 8!:\u0191! )"),
peg$decode("%%;!.\" &\"/[#;!.\" &\"/M$;!.\" &\"/?$;!.\" &\"/1$;!.\" &\"/#$+%)(%'#($'#(#'#(\"'#&'#/' 8!:\u0192!! )"),
peg$decode("%%;!/?#;!.\" &\"/1$;!.\" &\"/#$+#)(#'#(\"'#&'#/' 8!:\u0193!! )"),
peg$decode(";\xBE"),
peg$decode("%;\x9E/^#$%;B/,#;\xF3/#$+\")(\"'#&'#06*%;B/,#;\xF3/#$+\")(\"'#&'#&/($8\":\u0194\"!!)(\"'#&'#"),
peg$decode(";\xF4.# &;\xA0"),
peg$decode("%2\u0195\"\"6\u01957\u0196/L#;</C$2\u0197\"\"6\u01977\u0198.) &2\u0199\"\"6\u01997\u019A/($8#:\u019B#! )(#'#(\"'#&'#"),
peg$decode("%;\x9E/^#$%;B/,#;\xA0/#$+\")(\"'#&'#06*%;B/,#;\xA0/#$+\")(\"'#&'#&/($8\":\u019C\"!!)(\"'#&'#"),
peg$decode("%;6/5#;0/,$;\xF7/#$+#)(#'#(\"'#&'#"),
peg$decode("$;2.) &;4.# &;.0/*;2.) &;4.# &;.&"),
peg$decode("$;%0#*;%&"),
peg$decode("%;\xFA/;#28\"\"6879/,$;\xFB/#$+#)(#'#(\"'#&'#"),
peg$decode("%3\u019D\"\"5%7\u019E.) &3\u019F\"\"5$7\u01A0/' 8!:\u01A1!! )"),
peg$decode("%;\xFC/J#%28\"\"6879/,#;^/#$+\")(\"'#&'#.\" &\"/#$+\")(\"'#&'#"),
peg$decode("%;\\.) &;X.# &;\x82/' 8!:\u01A2!! )"),
peg$decode(";\".S &;!.M &2F\"\"6F7G.A &2J\"\"6J7K.5 &2H\"\"6H7I.) &2N\"\"6N7O"),
peg$decode("2L\"\"6L7M.\x95 &2B\"\"6B7C.\x89 &2<\"\"6<7=.} &2R\"\"6R7S.q &2T\"\"6T7U.e &2V\"\"6V7W.Y &2P\"\"6P7Q.M &2@\"\"6@7A.A &2D\"\"6D7E.5 &22\"\"6273.) &2>\"\"6>7?"),
peg$decode("%;\u0100/b#28\"\"6879/S$;\xFB/J$%2\u01A3\"\"6\u01A37\u01A4/,#;\xEC/#$+\")(\"'#&'#.\" &\"/#$+$)($'#(#'#(\"'#&'#"),
peg$decode("%3\u01A5\"\"5%7\u01A6.) &3\u01A7\"\"5$7\u01A8/' 8!:\u01A1!! )"),
peg$decode("%;\xEC/O#3\xB1\"\"5#7\xB2.6 &3\xB3\"\"5#7\xB4.* &$;+0#*;+&/'$8\":\u01A9\" )(\"'#&'#"),
peg$decode("%;\u0104/\x87#2F\"\"6F7G/x$;\u0103/o$2F\"\"6F7G/`$;\u0103/W$2F\"\"6F7G/H$;\u0103/?$2F\"\"6F7G/0$;\u0105/'$8):\u01AA) )()'#(('#(''#(&'#(%'#($'#(#'#(\"'#&'#"),
peg$decode("%;#/>#;#/5$;#/,$;#/#$+$)($'#(#'#(\"'#&'#"),
peg$decode("%;\u0103/,#;\u0103/#$+\")(\"'#&'#"),
peg$decode("%;\u0103/5#;\u0103/,$;\u0103/#$+#)(#'#(\"'#&'#"),
peg$decode("%;\x84/U#;'/L$;\x92/C$;'/:$;\x90/1$; .\" &\"/#$+&)(&'#(%'#($'#(#'#(\"'#&'#"),
peg$decode("%2\u01AB\"\"6\u01AB7\u01AC.) &2\u01AD\"\"6\u01AD7\u01AE/w#;0/n$;\u0108/e$$%;B/2#;\u0109.# &;\xA0/#$+\")(\"'#&'#0<*%;B/2#;\u0109.# &;\xA0/#$+\")(\"'#&'#&/#$+$)($'#(#'#(\"'#&'#"),
peg$decode(";\x99.# &;L"),
peg$decode("%2\u01AF\"\"6\u01AF7\u01B0/5#;</,$;\u010A/#$+#)(#'#(\"'#&'#"),
peg$decode("%;D/S#;,/J$2:\"\"6:7;/;$;,.# &;T/,$;E/#$+%)(%'#($'#(#'#(\"'#&'#")
],
peg$currPos = 0,
peg$savedPos = 0,
peg$posDetailsCache = [{ line: 1, column: 1 }],
peg$maxFailPos = 0,
peg$maxFailExpected = [],
peg$silentFails = 0,
peg$result;
if ("startRule" in options) {
if (!(options.startRule in peg$startRuleIndices)) {
throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
}
peg$startRuleIndex = peg$startRuleIndices[options.startRule];
}
function text() {
return input.substring(peg$savedPos, peg$currPos);
}
function location() {
return peg$computeLocation(peg$savedPos, peg$currPos);
}
function expected(description, location) {
location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
throw peg$buildStructuredError(
[peg$otherExpectation(description)],
input.substring(peg$savedPos, peg$currPos),
location
);
}
function error(message, location) {
location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)
throw peg$buildSimpleError(message, location);
}
function peg$literalExpectation(text, ignoreCase) {
return { type: "literal", text: text, ignoreCase: ignoreCase };
}
function peg$classExpectation(parts, inverted, ignoreCase) {
return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
}
function peg$anyExpectation() {
return { type: "any" };
}
function peg$endExpectation() {
return { type: "end" };
}
function peg$otherExpectation(description) {
return { type: "other", description: description };
}
function peg$computePosDetails(pos) {
var details = peg$posDetailsCache[pos], p;
if (details) {
return details;
} else {
p = pos - 1;
while (!peg$posDetailsCache[p]) {
p--;
}
details = peg$posDetailsCache[p];
details = {
line: details.line,
column: details.column
};
while (p < pos) {
if (input.charCodeAt(p) === 10) {
details.line++;
details.column = 1;
} else {
details.column++;
}
p++;
}
peg$posDetailsCache[pos] = details;
return details;
}
}
function peg$computeLocation(startPos, endPos) {
var startPosDetails = peg$computePosDetails(startPos),
endPosDetails = peg$computePosDetails(endPos);
return {
start: {
offset: startPos,
line: startPosDetails.line,
column: startPosDetails.column
},
end: {
offset: endPos,
line: endPosDetails.line,
column: endPosDetails.column
}
};
}
function peg$fail(expected) {
if (peg$currPos < peg$maxFailPos) { return; }
if (peg$currPos > peg$maxFailPos) {
peg$maxFailPos = peg$currPos;
peg$maxFailExpected = [];
}
peg$maxFailExpected.push(expected);
}
function peg$buildSimpleError(message, location) {
return new peg$SyntaxError(message, null, null, location);
}
function peg$buildStructuredError(expected, found, location) {
return new peg$SyntaxError(
peg$SyntaxError.buildMessage(expected, found),
expected,
found,
location
);
}
function peg$decode(s) {
var bc = new Array(s.length), i;
for (i = 0; i < s.length; i++) {
bc[i] = s.charCodeAt(i) - 32;
}
return bc;
}
function peg$parseRule(index) {
var bc = peg$bytecode[index],
ip = 0,
ips = [],
end = bc.length,
ends = [],
stack = [],
params, i;
while (true) {
while (ip < end) {
switch (bc[ip]) {
case 0:
stack.push(peg$consts[bc[ip + 1]]);
ip += 2;
break;
case 1:
stack.push(void 0);
ip++;
break;
case 2:
stack.push(null);
ip++;
break;
case 3:
stack.push(peg$FAILED);
ip++;
break;
case 4:
stack.push([]);
ip++;
break;
case 5:
stack.push(peg$currPos);
ip++;
break;
case 6:
stack.pop();
ip++;
break;
case 7:
peg$currPos = stack.pop();
ip++;
break;
case 8:
stack.length -= bc[ip + 1];
ip += 2;
break;
case 9:
stack.splice(-2, 1);
ip++;
break;
case 10:
stack[stack.length - 2].push(stack.pop());
ip++;
break;
case 11:
stack.push(stack.splice(stack.length - bc[ip + 1], bc[ip + 1]));
ip += 2;
break;
case 12:
stack.push(input.substring(stack.pop(), peg$currPos));
ip++;
break;
case 13:
ends.push(end);
ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
if (stack[stack.length - 1]) {
end = ip + 3 + bc[ip + 1];
ip += 3;
} else {
end = ip + 3 + bc[ip + 1] + bc[ip + 2];
ip += 3 + bc[ip + 1];
}
break;
case 14:
ends.push(end);
ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
if (stack[stack.length - 1] === peg$FAILED) {
end = ip + 3 + bc[ip + 1];
ip += 3;
} else {
end = ip + 3 + bc[ip + 1] + bc[ip + 2];
ip += 3 + bc[ip + 1];
}
break;
case 15:
ends.push(end);
ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
if (stack[stack.length - 1] !== peg$FAILED) {
end = ip + 3 + bc[ip + 1];
ip += 3;
} else {
end = ip + 3 + bc[ip + 1] + bc[ip + 2];
ip += 3 + bc[ip + 1];
}
break;
case 16:
if (stack[stack.length - 1] !== peg$FAILED) {
ends.push(end);
ips.push(ip);
end = ip + 2 + bc[ip + 1];
ip += 2;
} else {
ip += 2 + bc[ip + 1];
}
break;
case 17:
ends.push(end);
ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
if (input.length > peg$currPos) {
end = ip + 3 + bc[ip + 1];
ip += 3;
} else {
end = ip + 3 + bc[ip + 1] + bc[ip + 2];
ip += 3 + bc[ip + 1];
}
break;
case 18:
ends.push(end);
ips.push(ip + 4 + bc[ip + 2] + bc[ip + 3]);
if (input.substr(peg$currPos, peg$consts[bc[ip + 1]].length) === peg$consts[bc[ip + 1]]) {
end = ip + 4 + bc[ip + 2];
ip += 4;
} else {
end = ip + 4 + bc[ip + 2] + bc[ip + 3];
ip += 4 + bc[ip + 2];
}
break;
case 19:
ends.push(end);
ips.push(ip + 4 + bc[ip + 2] + bc[ip + 3]);
if (input.substr(peg$currPos, peg$consts[bc[ip + 1]].length).toLowerCase() === peg$consts[bc[ip + 1]]) {
end = ip + 4 + bc[ip + 2];
ip += 4;
} else {
end = ip + 4 + bc[ip + 2] + bc[ip + 3];
ip += 4 + bc[ip + 2];
}
break;
case 20:
ends.push(end);
ips.push(ip + 4 + bc[ip + 2] + bc[ip + 3]);
if (peg$consts[bc[ip + 1]].test(input.charAt(peg$currPos))) {
end = ip + 4 + bc[ip + 2];
ip += 4;
} else {
end = ip + 4 + bc[ip + 2] + bc[ip + 3];
ip += 4 + bc[ip + 2];
}
break;
case 21:
stack.push(input.substr(peg$currPos, bc[ip + 1]));
peg$currPos += bc[ip + 1];
ip += 2;
break;
case 22:
stack.push(peg$consts[bc[ip + 1]]);
peg$currPos += peg$consts[bc[ip + 1]].length;
ip += 2;
break;
case 23:
stack.push(peg$FAILED);
if (peg$silentFails === 0) {
peg$fail(peg$consts[bc[ip + 1]]);
}
ip += 2;
break;
case 24:
peg$savedPos = stack[stack.length - 1 - bc[ip + 1]];
ip += 2;
break;
case 25:
peg$savedPos = peg$currPos;
ip++;
break;
case 26:
params = bc.slice(ip + 4, ip + 4 + bc[ip + 3]);
for (i = 0; i < bc[ip + 3]; i++) {
params[i] = stack[stack.length - 1 - params[i]];
}
stack.splice(
stack.length - bc[ip + 2],
bc[ip + 2],
peg$consts[bc[ip + 1]].apply(null, params)
);
ip += 4 + bc[ip + 3];
break;
case 27:
stack.push(peg$parseRule(bc[ip + 1]));
ip += 2;
break;
case 28:
peg$silentFails++;
ip++;
break;
case 29:
peg$silentFails--;
ip++;
break;
default:
throw new Error("Invalid opcode: " + bc[ip] + ".");
}
}
if (ends.length > 0) {
end = ends.pop();
ip = ips.pop();
} else {
break;
}
}
return stack[0];
}
options.data = {}; // Object to which header attributes will be assigned during parsing
function list (head, tail) {
return [head].concat(tail);
}
peg$result = peg$parseRule(peg$startRuleIndex);
if (peg$result !== peg$FAILED && peg$currPos === input.length) {
return peg$result;
} else {
if (peg$result !== peg$FAILED && peg$currPos < input.length) {
peg$fail(peg$endExpectation());
}
throw peg$buildStructuredError(
peg$maxFailExpected,
peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
peg$maxFailPos < input.length
? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
: peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
);
}
}
module.exports = {
SyntaxError: peg$SyntaxError,
parse: peg$parse
};
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* @name SIP
* @namespace
*/
module.exports = function (SIP) {
var Modifiers;
function stripPayload(sdp, payload) {
var i;
var media_descs = [];
var current_media_desc;
var lines = sdp.split(/\r\n/);
for (i = 0; i < lines.length;) {
var line = lines[i];
if (/^m=(?:audio|video)/.test(line)) {
current_media_desc = {
index: i,
stripped: []
};
media_descs.push(current_media_desc);
}
else if (current_media_desc) {
var rtpmap = /^a=rtpmap:(\d+) ([^/]+)\//.exec(line);
if (rtpmap && payload === rtpmap[2]) {
lines.splice(i, 1);
current_media_desc.stripped.push(rtpmap[1]);
continue; // Don't increment 'i'
}
}
i++;
}
for (i = 0; i < media_descs.length; i++) {
var mline = lines[media_descs[i].index].split(' ');
// Ignore the first 3 parameters of the mline. The codec information is after that
for (var j = 3; j < mline.length;) {
if (media_descs[i].stripped.indexOf(mline[j]) !== -1) {
mline.splice(j, 1);
continue;
}
j++;
}
lines[media_descs[i].index] = mline.join(' ');
}
return lines.join('\r\n');
}
function stripMediaDescription(sdp, description) {
var descriptionRegExp = new RegExp("m=" + description + ".*$", "gm");
var groupRegExp = new RegExp("^a=group:.*$", "gm");
if (descriptionRegExp.test(sdp)) {
var midLineToRemove_1;
sdp = sdp.split(/^m=/gm).filter(function (section) {
if (section.substr(0, description.length) === description) {
midLineToRemove_1 = section.match(/^a=mid:.*$/gm);
if (midLineToRemove_1) {
midLineToRemove_1 = midLineToRemove_1[0].match(/:.+$/g)[0].substr(1);
}
return false;
}
return true;
}).join('m=');
var groupLine = sdp.match(groupRegExp);
if (groupLine && groupLine.length === 1) {
groupLine = groupLine[0];
var groupRegExpReplace = new RegExp("\ *" + midLineToRemove_1 + "[^\ ]*", "g");
groupLine = groupLine.replace(groupRegExpReplace, "");
sdp = sdp.split(groupRegExp).join(groupLine);
}
}
return sdp;
}
Modifiers = {
stripTcpCandidates: function (description) {
description.sdp = description.sdp.replace(/^a=candidate:\d+ \d+ tcp .*?\r\n/img, "");
return SIP.Utils.Promise.resolve(description);
},
stripTelephoneEvent: function (description) {
description.sdp = stripPayload(description.sdp, 'telephone-event');
return SIP.Utils.Promise.resolve(description);
},
cleanJitsiSdpImageattr: function (description) {
description.sdp = description.sdp.replace(/^(a=imageattr:.*?)(x|y)=\[0-/gm, "$1$2=[1:");
return SIP.Utils.Promise.resolve(description);
},
stripG722: function (description) {
description.sdp = stripPayload(description.sdp, 'G722');
return SIP.Utils.Promise.resolve(description);
},
stripRtpPayload: function (payload) {
return function (description) {
description.sdp = stripPayload(description.sdp, payload);
return SIP.Utils.Promise.resolve(description);
};
},
stripVideo: function (description) {
description.sdp = stripMediaDescription(description.sdp, "video");
return SIP.Utils.Promise.resolve(description);
},
addMidLines: function (description) {
var sdp = description.sdp;
if (sdp.search(/^a=mid.*$/gm) === -1) {
var mlines_1 = sdp.match(/^m=.*$/gm);
sdp = sdp.split(/^m=.*$/gm);
mlines_1.forEach(function (elem, idx) {
mlines_1[idx] = elem + '\na=mid:' + idx;
});
sdp.forEach(function (elem, idx) {
if (mlines_1[idx]) {
sdp[idx] = elem + mlines_1[idx];
}
});
sdp = sdp.join('');
description.sdp = sdp;
}
return SIP.Utils.Promise.resolve(description);
}
};
return Modifiers;
};
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
/**
* @fileoverview Simple
*/
/* Simple
* @class Simple
*/
module.exports = function (SIP) {
var C = {
STATUS_NULL: 0,
STATUS_NEW: 1,
STATUS_CONNECTING: 2,
STATUS_CONNECTED: 3,
STATUS_COMPLETED: 4
};
/*
* @param {Object} options
*/
var Simple = function (options) {
/*
* {
* media: {
* remote: {
* audio: <DOM element>,
* video: <DOM element>
* },
* local: {
* video: <DOM element>
* }
* },
* ua: {
* <UA Configuration Options>
* }
* }
*/
if (options.media.remote.video) {
this.video = true;
}
else {
this.video = false;
}
if (options.media.remote.audio) {
this.audio = true;
}
else {
this.audio = false;
}
if (!this.audio && !this.video) {
// Need to do at least audio or video
// Error
throw new Error('At least one remote audio or video element is required for Simple.');
}
this.options = options;
// https://stackoverflow.com/questions/7944460/detect-safari-browser
var browserUa = global.navigator.userAgent.toLowerCase();
var isSafari = false;
var isFirefox = false;
if (browserUa.indexOf('safari') > -1 && browserUa.indexOf('chrome') < 0) {
isSafari = true;
}
else if (browserUa.indexOf('firefox') > -1 && browserUa.indexOf('chrome') < 0) {
isFirefox = true;
}
var sessionDescriptionHandlerFactoryOptions = {};
if (isSafari) {
sessionDescriptionHandlerFactoryOptions.modifiers = [SIP.Web.Modifiers.stripG722];
}
if (isFirefox) {
sessionDescriptionHandlerFactoryOptions.alwaysAcquireMediaFirst = true;
}
if (!this.options.ua.uri) {
this.anonymous = true;
}
this.ua = new SIP.UA({
// User Configurable Options
uri: this.options.ua.uri,
authorizationUser: this.options.ua.authorizationUser,
password: this.options.ua.password,
displayName: this.options.ua.displayName,
// Undocumented "Advanced" Options
userAgentString: this.options.ua.userAgentString,
// Fixed Options
register: true,
sessionDescriptionHandlerFactoryOptions: sessionDescriptionHandlerFactoryOptions,
transportOptions: {
traceSip: this.options.ua.traceSip,
wsServers: this.options.ua.wsServers
}
});
this.state = C.STATUS_NULL;
this.logger = this.ua.getLogger('sip.simple');
this.ua.on('registered', function () {
this.emit('registered', this.ua);
}.bind(this));
this.ua.on('unregistered', function () {
this.emit('unregistered', this.ua);
}.bind(this));
this.ua.on('failed', function () {
this.emit('unregistered', this.ua);
}.bind(this));
this.ua.on('invite', function (session) {
// If there is already an active session reject the incoming session
if (this.state !== C.STATUS_NULL && this.state !== C.STATUS_COMPLETED) {
this.logger.warn('Rejecting incoming call. Simple only supports 1 call at a time');
session.reject();
return;
}
this.session = session;
this.setupSession();
this.emit('ringing', this.session);
}.bind(this));
this.ua.on('message', function (message) {
this.emit('message', message);
}.bind(this));
return this;
};
Simple.prototype = Object.create(SIP.EventEmitter.prototype);
Simple.C = C;
// Public
Simple.prototype.call = function (destination) {
if (!this.ua || !this.checkRegistration()) {
this.logger.warn('A registered UA is required for calling');
return;
}
if (this.state !== C.STATUS_NULL && this.state !== C.STATUS_COMPLETED) {
this.logger.warn('Cannot make more than a single call with Simple');
return;
}
// Safari hack, because you cannot call .play() from a non user action
if (this.options.media.remote.audio) {
this.options.media.remote.audio.autoplay = true;
}
if (this.options.media.remote.video) {
this.options.media.remote.video.autoplay = true;
}
if (this.options.media.local && this.options.media.local.video) {
this.options.media.local.video.autoplay = true;
this.options.media.local.video.volume = 0;
}
this.session = this.ua.invite(destination, {
sessionDescriptionHandlerOptions: {
constraints: {
audio: this.audio,
video: this.video
}
}
});
this.setupSession();
return this.session;
};
Simple.prototype.answer = function () {
if (this.state !== C.STATUS_NEW && this.state !== C.STATUS_CONNECTING) {
this.logger.warn('No call to answer');
return;
}
// Safari hack, because you cannot call .play() from a non user action
if (this.options.media.remote.audio) {
this.options.media.remote.audio.autoplay = true;
}
if (this.options.media.remote.video) {
this.options.media.remote.video.autoplay = true;
}
return this.session.accept({
sessionDescriptionHandlerOptions: {
constraints: {
audio: this.audio,
video: this.video
}
}
});
// emit call is active
};
Simple.prototype.reject = function () {
if (this.state !== C.STATUS_NEW && this.state !== C.STATUS_CONNECTING) {
this.logger.warn('Call is already answered');
return;
}
return this.session.reject();
};
Simple.prototype.hangup = function () {
if (this.state !== C.STATUS_CONNECTED && this.state !== C.STATUS_CONNECTING && this.state !== C.STATUS_NEW) {
this.logger.warn('No active call to hang up on');
return;
}
if (this.state !== C.STATUS_CONNECTED) {
return this.session.cancel();
}
else {
return this.session.bye();
}
};
Simple.prototype.hold = function () {
if (this.state !== C.STATUS_CONNECTED || this.session.local_hold) {
this.logger.warn('Cannot put call on hold');
return;
}
this.mute();
this.logger.log('Placing session on hold');
return this.session.hold();
};
Simple.prototype.unhold = function () {
if (this.state !== C.STATUS_CONNECTED || !this.session.local_hold) {
this.logger.warn('Cannot unhold a call that is not on hold');
return;
}
this.unmute();
this.logger.log('Placing call off hold');
return this.session.unhold();
};
Simple.prototype.mute = function () {
if (this.state !== C.STATUS_CONNECTED) {
this.logger.warn('An acitve call is required to mute audio');
return;
}
this.logger.log('Muting Audio');
this.toggleMute(true);
this.emit('mute', this);
};
Simple.prototype.unmute = function () {
if (this.state !== C.STATUS_CONNECTED) {
this.logger.warn('An active call is required to unmute audio');
return;
}
this.logger.log('Unmuting Audio');
this.toggleMute(false);
this.emit('unmute', this);
};
Simple.prototype.sendDTMF = function (tone) {
if (this.state !== C.STATUS_CONNECTED) {
this.logger.warn('An active call is required to send a DTMF tone');
return;
}
this.logger.log('Sending DTMF tone: ' + tone);
this.session.dtmf(tone);
};
Simple.prototype.message = function (destination, message) {
if (!this.ua || !this.checkRegistration()) {
this.logger.warn('A registered UA is required to send a message');
return;
}
if (!destination || !message) {
this.logger.warn('A destination and message are required to send a message');
return;
}
this.ua.message(destination, message);
};
// Private Helpers
Simple.prototype.checkRegistration = function () {
return (this.anonymous || (this.ua && this.ua.isRegistered()));
};
Simple.prototype.setupRemoteMedia = function () {
// If there is a video track, it will attach the video and audio to the same element
var pc = this.session.sessionDescriptionHandler.peerConnection;
var remoteStream;
if (pc.getReceivers) {
remoteStream = new global.window.MediaStream();
pc.getReceivers().forEach(function (receiver) {
var track = receiver.track;
if (track) {
remoteStream.addTrack(track);
}
});
}
else {
remoteStream = pc.getRemoteStreams()[0];
}
if (this.video) {
this.options.media.remote.video.srcObject = remoteStream;
this.options.media.remote.video.play().catch(function () {
this.logger.log('play was rejected');
}.bind(this));
}
else if (this.audio) {
this.options.media.remote.audio.srcObject = remoteStream;
this.options.media.remote.audio.play().catch(function () {
this.logger.log('play was rejected');
}.bind(this));
}
};
Simple.prototype.setupLocalMedia = function () {
if (this.video && this.options.media.local && this.options.media.local.video) {
var pc = this.session.sessionDescriptionHandler.peerConnection;
var localStream;
if (pc.getSenders) {
localStream = new global.window.MediaStream();
pc.getSenders().forEach(function (sender) {
var track = sender.track;
if (track && track.kind === 'video') {
localStream.addTrack(track);
}
});
}
else {
localStream = pc.getLocalStreams()[0];
}
this.options.media.local.video.srcObject = localStream;
this.options.media.local.video.volume = 0;
this.options.media.local.video.play();
}
};
Simple.prototype.cleanupMedia = function () {
if (this.video) {
this.options.media.remote.video.srcObject = null;
this.options.media.remote.video.pause();
if (this.options.media.local && this.options.media.local.video) {
this.options.media.local.video.srcObject = null;
this.options.media.local.video.pause();
}
}
if (this.audio) {
this.options.media.remote.audio.srcObject = null;
this.options.media.remote.audio.pause();
}
};
Simple.prototype.setupSession = function () {
this.state = C.STATUS_NEW;
this.emit('new', this.session);
this.session.on('progress', this.onProgress.bind(this));
this.session.on('accepted', this.onAccepted.bind(this));
this.session.on('rejected', this.onEnded.bind(this));
this.session.on('failed', this.onFailed.bind(this));
this.session.on('terminated', this.onEnded.bind(this));
};
Simple.prototype.destroyMedia = function () {
this.session.sessionDescriptionHandler.close();
};
Simple.prototype.toggleMute = function (mute) {
var pc = this.session.sessionDescriptionHandler.peerConnection;
if (pc.getSenders) {
pc.getSenders().forEach(function (sender) {
if (sender.track) {
sender.track.enabled = !mute;
}
});
}
else {
pc.getLocalStreams().forEach(function (stream) {
stream.getAudioTracks().forEach(function (track) {
track.enabled = !mute;
});
stream.getVideoTracks().forEach(function (track) {
track.enabled = !mute;
});
});
}
};
Simple.prototype.onAccepted = function () {
this.state = C.STATUS_CONNECTED;
this.emit('connected', this.session);
this.setupLocalMedia();
this.setupRemoteMedia();
this.session.sessionDescriptionHandler.on('addTrack', function () {
this.logger.log('A track has been added, triggering new remoteMedia setup');
this.setupRemoteMedia();
}.bind(this));
this.session.sessionDescriptionHandler.on('addStream', function () {
this.logger.log('A stream has been added, trigger new remoteMedia setup');
this.setupRemoteMedia();
}.bind(this));
this.session.on('hold', function () {
this.emit('hold', this.session);
}.bind(this));
this.session.on('unhold', function () {
this.emit('unhold', this.session);
}.bind(this));
this.session.on('dtmf', function (tone) {
this.emit('dtmf', tone);
}.bind(this));
this.session.on('bye', this.onEnded.bind(this));
};
Simple.prototype.onProgress = function () {
this.state = C.STATUS_CONNECTING;
this.emit('connecting', this.session);
};
Simple.prototype.onFailed = function () {
this.onEnded();
};
Simple.prototype.onEnded = function () {
this.state = C.STATUS_COMPLETED;
this.emit('ended', this.session);
this.cleanupMedia();
};
return Simple;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)))
/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {
var toplevel = global.window || global;
function getPrefixedProperty(object, name) {
if (object == null) {
return;
}
var capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
var prefixedNames = [name, 'webkit' + capitalizedName, 'moz' + capitalizedName];
for (var i in prefixedNames) {
var property = object[prefixedNames[i]];
if (property) {
return property.bind(object);
}
}
}
module.exports = {
WebSocket: toplevel.WebSocket,
Transport: __webpack_require__(10),
open: toplevel.open,
Promise: toplevel.Promise,
timers: toplevel,
// Console is not defined in ECMAScript, so just in case...
console: toplevel.console || {
debug: function () { },
log: function () { },
warn: function () { },
error: function () { }
},
addEventListener: getPrefixedProperty(toplevel, 'addEventListener'),
removeEventListener: getPrefixedProperty(toplevel, 'removeEventListener')
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(28)))
/***/ })
/******/ ]);
});