Source: cam.js

  1. /**
  2.  * @namespace cam
  3.  * @description Common camera module
  4.  * @author Andrew D.Laptev <a.d.laptev@gmail.com>
  5.  * @licence MIT
  6.  */
  8. const http = require('http'),
  9. 	https = require('https'),
  10. 	crypto = require('crypto'),
  11. 	events = require('events'),
  12. 	url = require('url'),
  13. 	util = require('util'),
  14. 	linerase = require('./utils').linerase,
  15. 	parseSOAPString = require('./utils').parseSOAPString,
  16. 	parseString = require('xml2js').parseString,
  17. 	stripPrefix = require('xml2js').processors.stripPrefix,
  18. 	emptyFn = function() {};
  20. /**
  21.  * @callback Cam~MessageCallback
  22.  * @property {?Error} error
  23.  * @property {?string} message
  24.  */
  26. /**
  27.  * @callback Cam~ConnectionCallback
  28.  * @property {?Error} error
  29.  */
  31. /**
  32.  * @typedef Cam~Options
  33.  * @property {boolean} [useSecure] Set true if `https:`, defaults to false
  34.  * @property {object} [secureOpts] Set options for https like ca, cert, ciphers, rejectUnauthorized, secureOptions, secureProtocol, etc.
  35.  * @property {boolean} [useWSSecurity] Use WS-Security SOAP headers
  36.  * @property {string} hostname
  37.  * @property {string} [username]
  38.  * @property {string} [password]
  39.  * @property {number} [port=80]
  40.  * @property {string} [path=/onvif/device_service]
  41.  * @property {number} [timeout=120000]
  42.  * @property {boolean} [autoconnect=true] Set false if the camera should not connect automatically. The callback will not be executed.
  43.  * @property {boolean} [preserveAddress=false] Force using hostname and port from constructor for the services
  44.  */
  46. /**
  47.  * Camera class
  48.  * @param {Cam~Options} options
  49.  * @param {Cam~ConnectionCallback} [callback]
  50.  * @fires Cam#rawRequest
  51.  * @fires Cam#rawResponse
  52.  * @fires Cam#connect
  53.  * @fires Cam#event
  54.  * @fires Cam#warning
  55.  * @property presets
  56.  * @class
  57.  * @constructor
  58.  * @extends events.EventEmitter
  59.  * @example
  60.  * var
  61.  *   http = require('http'),
  62.  *   Cam = require('onvif').Cam;
  63.  *
  64.  * new Cam({
  65.  *   useSecure: <IS_SECURE>,
  66.  *   secureOpts: {...<SECURE_OPTIONS>}
  67.  *   hostname: <CAMERA_HOST>,
  68.  *   username: <USERNAME>,
  69.  *   password: <PASSWORD>
  70.  * }, function(err) {
  71.  *   this.absoluteMove({x: 1, y: 1, zoom: 1});
  72.  *   this.getStreamUri({protocol:'RTSP'}, function(err, stream) {
  73.  *     http.createServer(function (req, res) {
  74.  *       res.writeHead(200, {'Content-Type': 'text/html'});
  75.  *       res.end('<html><body>' +
  76.  *         '<embed type="application/x-vlc-plugin" target="' + stream.uri + '"></embed>' +
  77.  *         '</body></html>');
  78.  *     }).listen(3030);
  79.  *   });
  80.  * });
  81.  */
  82. var Cam = function(options, callback) {
  83. 	events.EventEmitter.call(this);
  84. 	callback = callback || emptyFn;
  85. 	this.useSecure = options.useSecure || false;
  86. 	this.secureOpts = options.secureOpts || {};
  87. 	this.hostname = options.hostname;
  88. 	this.username = options.username;
  89. 	this.password = options.password;
  90. 	this.port = options.port || (options.useSecure ? 443 : 80);
  91. 	this.path = options.path || '/onvif/device_service';
  92. 	this.timeout = options.timeout || 120000;
  93. 	this.agent = options.agent || false;
  94. 	/**
  95. 	 * Use WS-Security SOAP header
  96. 	 * @type {boolean}
  97. 	 */
  98. 	this.useWSSecurity = typeof options.useWSSecurity === 'boolean' ? options.useWSSecurity : true;
  99. 	this._nc = 0;
  100. 	/**
  101. 	 * Force using hostname and port from constructor for the services
  102. 	 * @type {boolean}
  103. 	 */
  104. 	this.preserveAddress = options.preserveAddress || false;
  106. 	this.events = {};
  107. 	/**
  108. 	 * Bind event handling to the `event` event
  109. 	 */
  110. 	this.on('newListener', function(name) {
  111. 		// if this is the first listener, start pulling subscription
  112. 		if (name === 'event' && this.listeners(name).length === 0) {
  113. 			setImmediate(function() {
  114. 				this._eventRequest();
  115. 			}.bind(this));
  116. 		}
  117. 	}.bind(this));
  119. 	if (options.autoconnect !== false) {
  120. 		setImmediate(function() {
  121. 			this.connect(callback);
  122. 		}.bind(this));
  123. 	}
  124. };
  126. // events.EventEmitter inheritance
  127. util.inherits(Cam, events.EventEmitter);
  129. /**
  130.  * Connect to the camera and fill device information properties
  131.  * @param {Cam~ConnectionCallback} callback
  132.  */
  133. Cam.prototype.connect = function(callback) {
  135. 	// Must execute getSystemDataAndTime (and wait for callback)
  136. 	// before any other ONVIF commands so that the time of the ONVIF device
  137. 	// is known
  139. 	this.getSystemDateAndTime(function(err, date, xml) {
  140. 		if (err) {
  141. 			return callback.call(this, err, null, xml);
  142. 		}
  143. 		// Next Step - Execute GetServices
  144. 		this.getServices(true, function(err) {
  145. 			if (err) {
  146. 				// Fall back to GetCapabilities. The original ONVIF spec did not include GetServices
  147. 				return this.getCapabilities(function(err, data, xml) {
  148. 					if (err) {
  149. 						return callback.call(this, err, null, xml);
  150. 					}
  151. 					return callUpstartFunctions.call(this);
  152. 				}.bind(this));
  153. 			}
  154. 			if (this.media2Support) {
  155. 				// Check Media2 works (workaround a buggy D-Link DCS-8635LH camera). Disable Media2 if there is an error.
  156. 				// This is inefficient as we also call GetProfiles in the upstart function
  157. 				this.getProfiles(function(err) {
  158. 					if (err) {
  159. 						this.media2Support = false; // don't use media2
  160. 					}
  161. 					return callUpstartFunctions.call(this);
  162. 				}.bind(this));
  163. 			} else {
  164. 				return callUpstartFunctions.call(this);
  165. 			}
  166. 		}.bind(this));
  168. 		function callUpstartFunctions() {
  169. 			var upstartFunctions = [];
  171. 			// Profile S
  172. 			if (this.uri && this.uri.media) {
  173. 				upstartFunctions.push(this.getProfiles);
  174. 				upstartFunctions.push(this.getVideoSources);
  175. 			}
  176. 			var count = upstartFunctions.length;
  177. 			var errCall = false;
  179. 			if (count > 0) {
  180. 				upstartFunctions.forEach(function(fun) {
  181. 					fun.call(this, function(err) {
  182. 						if (err) {
  183. 							if (callback && !errCall) {
  184. 								callback.call(this, err);
  185. 								errCall = true;
  186. 							}
  187. 						} else {
  188. 							if (!--count) {
  189. 								this.getActiveSources();
  190. 								/**
  191. 								 * Indicates that device is connected.
  192. 								 * @event Cam#connect
  193. 								 */
  194. 								this.emit('connect');
  195. 								if (callback) {
  196. 									return callback.call(this, err);
  197. 								}
  198. 							}
  199. 						}
  200. 					}.bind(this));
  201. 				}.bind(this));
  202. 			} else {
  203. 				this.emit('connect');
  204. 				if (callback) {
  205. 					return callback.call(this, false);
  206. 				}
  207. 			}
  208. 		}
  209. 	}.bind(this));
  210. };
  212. /**
  213.  * @callback Cam~RequestCallback
  214.  * @param {Error} err
  215.  * @param {object} [response] message
  216.  * @param {string} [xml] response
  217.  */
  219. /**
  220.  * Common camera request
  221.  * @param {object} options
  222.  * @param {string} [options.service] Name of service (ptz, media, etc)
  223.  * @param {string} [options.action] Name of the action. Not required, but desired
  224.  * @param {string} options.body SOAP body
  225.  * @param {string} [options.url] Defines another url to request instead of using the URLs from GetCapabilities/GetServices
  226.  * @param {number} options.replyTimeout timeout in milliseconds for the reply (after the socket has connected)
  227.  * @param {Cam~RequestCallback} callback response callback
  228.  * @private
  229.  */
  230. Cam.prototype._request = function(options, callback) {
  231. 	if (typeof callback !== 'function') {
  232. 		throw new Error('\'callback\' must be a function');
  233. 	}
  234. 	if (options.body === undefined) {
  235. 		throw new Error('\'options.body\' must be a defined');
  236. 	}
  238. 	// Generate the HTTP Content-Type 'action' string by parsing our outgoing ONVIF XML message with xml2js
  239. 	// xml2js returns a callback, so call _requestPart2 from the callback
  240. 	if (options.action === undefined || options.action === null) {
  241. 		let xml2jsOptions = {
  242. 			'xmlns': true, // Creates the $ns object that contains the full namepace and local name of each XML Tag
  243. 			tagNameProcessors: [stripPrefix] // Removes the namespace from each tag so we can parse Key:Value pairs of Tags
  244. 		};
  245. 		parseString(options.body, xml2jsOptions, (err, result) => {
  246. 			// Check for parsing errors
  247. 			if (err) {
  248. 				return callback(err);
  249. 			}
  250. 			// look for first Key:Value pairs that do not start with $ or $ns
  251. 			// for (const [key, value] of Object.entries(result['Envelope']['Body'][0])) {  // Node 7 or higher
  252. 			for (const key of Object.keys(result.Envelope.Body[0])) {
  253. 				const value = result.Envelope.Body[0][key];
  254. 				if (key.startsWith('$') === false) {
  255. 					options.action = value[0]['$ns'].uri + '/' + value[0]['$ns'].local;
  256. 					break;
  257. 				}
  258. 			}
  259. 			this._requestPart2.call(this, options, callback);
  260. 		});
  261. 	} else {
  262. 		this._requestPart2.call(this, options, callback);
  263. 	}
  264. };
  266. /**
  267.  * Common camera request part 2
  268.  * @param {Object} options
  269.  * @param {Object} options.headers If some of the headers must present (Digest auth)
  270.  * @param {string} options.action Name of the action
  271.  * @param {string} [options.service] Name of service (ptz, media, etc)
  272.  * @param {string} options.body SOAP body
  273.  * @param {string} [options.url] Defines another url to request instead of using the URLs from GetCapabilities/GetServices
  274.  * @param {number} options.replyTimeout timeout in milliseconds for the reply (after the socket has connected)
  275.  * @param {Cam~RequestCallback} callback response callback
  276.  * @private
  277.  */
  278. Cam.prototype._requestPart2 = function(options, callback) {
  279. 	const _this = this;
  280. 	let callbackExecuted = false;
  281. 	options.headers = options.headers || {};
  282. 	let reqOptions = options.url || {
  283. 		hostname: this.hostname,
  284. 		port: this.port,
  285. 		agent: this.agent //Supports things like https://www.npmjs.com/package/proxy-agent which provide SOCKS5 and other connections
  286. 		,
  287. 		path: options.service ?
  288. 			(this.uri && this.uri[options.service] ? this.uri[options.service].path : options.service) : this.path,
  289. 		timeout: this.timeout
  290. 	};
  291. 	reqOptions.headers = options.headers;
  292. 	Object.assign(reqOptions.headers, {
  293. 		'Content-Type': `application/soap+xml;charset=utf-8;action="${options.action}"`,
  294. 		'Content-Length': Buffer.byteLength(options.body, 'utf8') //options.body.length chinese will be wrong here
  295. 		,
  296. 		charset: 'utf-8'
  297. 	});
  299. 	reqOptions.method = 'POST';
  300. 	const httpLib = this.useSecure ? https : http;
  301. 	reqOptions = this.useSecure ? Object.assign({}, this.secureOpts, reqOptions) : reqOptions;
  302. 	const req = httpLib.request(reqOptions, function(res) {
  303. 		const wwwAuthenticate = res.headers['www-authenticate'];
  304. 		const statusCode = res.statusCode;
  305. 		if (statusCode === 401 && wwwAuthenticate !== undefined) {
  306. 			// Re-request with digest auth header
  307. 			res.destroy();
  308. 			options.headers.Authorization = _this.digestAuth(wwwAuthenticate, reqOptions);
  309. 			_this._requestPart2(options, callback);
  310. 		}
  311. 		const bufs = [];
  312. 		let length = 0;
  313. 		res.on('data', function(chunk) {
  314. 			bufs.push(chunk);
  315. 			length += chunk.length;
  316. 		});
  317. 		res.on('end', function() {
  318. 			if (callbackExecuted === true) {
  319. 				return;
  320. 			}
  321. 			callbackExecuted = true;
  322. 			var xml = Buffer.concat(bufs, length).toString('utf8');
  323. 			/**
  324. 			 * Indicates raw xml response from device.
  325. 			 * @event Cam#rawResponse
  326. 			 * @type {string} xml received from device
  327. 			 * @type {number} HTTP statusCode received from device
  328. 			 */
  329. 			_this.emit('rawResponse', xml, statusCode);
  330. 			parseSOAPString(xml, callback, statusCode); // xml and statusCode are passed in. Callback is the function called after the XML is parsed
  331. 		});
  332. 	});
  334. 	// Set the timeout for the reply (for data being received on the socket).
  335. 	// This timeout is used _after_ the socket has connected.
  336. 	// When pulling ONVIF Events, this will need to be set to a time larger than the Pull Request timeout
  337. 	// to ensure the socket does not get closed too early.
  338. 	// eg replyTimeout must be set to 75 seconds when the Pull Events timeout is 60 seconds
  339. 	req.setTimeout((options.replyTimeout ? options.replyTimeout : this.timeout), function() {
  340. 		if (callbackExecuted === true) {
  341. 			return;
  342. 		} else {
  343. 			callbackExecuted = true;
  344. 		}
  345. 		callback(new Error('Network timeout'));
  346. 		req.destroy();
  347. 	});
  349. 	req.on('error', function(err) {
  350. 		if (callbackExecuted === true) {
  351. 			return;
  352. 		}
  353. 		callbackExecuted = true;
  354. 		/* address, port number or IPCam error */
  355. 		if (err.code === 'ECONNREFUSED' && err.errno === 'ECONNREFUSED' && err.syscall === 'connect') {
  356. 			callback(err);
  357. 			/* network error */
  358. 		} else if (err.code === 'ECONNRESET' && err.errno === 'ECONNRESET' && err.syscall === 'read') {
  359. 			callback(err);
  360. 		} else {
  361. 			callback(err);
  362. 		}
  363. 	});
  364. 	/**
  365.      * Indicates raw xml request to device.
  366.      * @event Cam#rawRequest
  367.      * @type {Object}
  368.      */
  369. 	this.emit('rawRequest', options.body);
  370. 	req.write(options.body);
  371. 	req.end();
  372. };
  374. Cam.prototype._parseChallenge = function(digest) {
  375. 	const prefix = 'Digest ';
  376. 	const challenge = digest.substring(digest.indexOf(prefix) + prefix.length);
  377. 	const parts = challenge.split(',')
  378. 		.map(part => part.match(/^\s*?([a-zA-Z0-9]+)="?([^"]*)"?\s*?$/).slice(1));
  379. 	return Object.fromEntries(parts);
  380. };
  382. Cam.prototype.updateNC = function() {
  383. 	this._nc += 1;
  384. 	if (this._nc > 99999999) {
  385. 		this._nc = 1;
  386. 	}
  387. 	return String(this._nc).padStart(8, '0');
  388. };
  390. Cam.prototype.digestAuth = function(wwwAuthenticate, reqOptions) {
  391. 	const challenge = this._parseChallenge(wwwAuthenticate);
  392. 	const ha1 = crypto.createHash('md5');
  393. 	ha1.update([this.username, challenge.realm, this.password].join(':'));
  394. 	const ha2 = crypto.createHash('md5');
  395. 	ha2.update([reqOptions.method, reqOptions.path].join(':'));
  397. 	let cnonce = null;
  398. 	let nc = null;
  399. 	if (typeof challenge.qop === 'string') {
  400. 		const cnonceHash = crypto.createHash('md5');
  401. 		cnonceHash.update(Math.random().toString(36));
  402. 		cnonce = cnonceHash.digest('hex').substring(0, 8);
  403. 		nc = this.updateNC();
  404. 	}
  406. 	const response = crypto.createHash('md5');
  407. 	const responseParams = [
  408. 		ha1.digest('hex'),
  409. 		challenge.nonce
  410. 	];
  411. 	if (cnonce) {
  412. 		responseParams.push(nc);
  413. 		responseParams.push(cnonce);
  414. 	}
  416. 	responseParams.push(challenge.qop);
  417. 	responseParams.push(ha2.digest('hex'));
  418. 	response.update(responseParams.join(':'));
  420. 	const authParams = {
  421. 		username: this.username,
  422. 		realm: challenge.realm,
  423. 		nonce: challenge.nonce,
  424. 		uri: reqOptions.path,
  425. 		qop: challenge.qop,
  426. 		response: response.digest('hex'),
  427. 	};
  428. 	if (challenge.opaque) {
  429. 		authParams.opaque = challenge.opaque;
  430. 	}
  431. 	if (cnonce) {
  432. 		authParams.nc = nc;
  433. 		authParams.cnonce = cnonce;
  434. 	}
  435. 	return 'Digest ' + Object.entries(authParams).map(([key, value]) => `${key}="${value}"`).join(',');
  436. };
  438. /**
  439.  * @callback Cam~DateTimeCallback
  440.  * @property {?Error} error
  441.  * @property {Date} dateTime Date object of current device's dateTime
  442.  * @property {string} xml Raw SOAP response
  443.  */
  445. /**
  446.  * Receive date and time from cam
  447.  * @param {Cam~DateTimeCallback} callback
  448.  */
  449. Cam.prototype.getSystemDateAndTime = function(callback) {
  450. 	// The ONVIF spec says this should work without a Password as we need to know any difference in the
  451. 	// remote NVT's time relative to our own time clock (called the timeShift) before we can calculate the
  452. 	// correct timestamp in nonce SOAP Authentication header.
  453. 	// But.. Panasonic and Digital Barriers both have devices that implement ONVIF that only work with
  454. 	// authenticated getSystemDateAndTime. So for these devices we need to do an authenticated getSystemDateAndTime.
  455. 	// As 'timeShift' is not set, the local clock MUST be set to the correct time AND the NVT/Camera MUST be set to the correct time
  456. 	// if the camera implements Replay Attack Protection (eg Axis)
  457. 	this._request({
  458. 		// Try the Unauthenticated Request first. Do not use this._envelopeHeader() as we don't have timeShift yet.
  459. 		body: '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
  460.             '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
  461.             '<GetSystemDateAndTime xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  462.             '</s:Body>' +
  463.             '</s:Envelope>'
  464. 	}, function(err, data, xml, statusCode) {
  465. 		if (!err) {
  466. 			try {
  467. 				let systemDateAndTime = data[0]['getSystemDateAndTimeResponse'][0]['systemDateAndTime'][0];
  468. 				let dateTime = systemDateAndTime['UTCDateTime'] || systemDateAndTime['localDateTime'];
  469. 				let time;
  470. 				if (dateTime === undefined) {
  471. 					// Seen on a cheap Chinese camera from GWellTimes-IPC. Use the current time.
  472. 					time = new Date();
  473. 				} else {
  474. 					let dt = linerase(dateTime[0]);
  475. 					time = new Date(Date.UTC(dt.date.year, dt.date.month - 1, dt.date.day, dt.time.hour, dt.time.minute, dt.time.second));
  476. 				}
  477. 				if (!this.timeShift) {
  478. 					this.timeShift = time - (process.uptime() * 1000);
  479. 				}
  480. 				callback.call(this, err, time, xml);
  481. 			} catch (err) {
  482. 				callback.call(this, err, null, xml);
  483. 			}
  484. 		}
  485. 		if (err) {
  486. 			// some cameras return XML with 'sender not authorized'
  487. 			// One HikVision camera returned a 401 error code and the following HTML...
  488. 			//   <!DOCTYPE html><html><head><title>Document Error: Unauthorized</title></head><body><h2>Access Error: 401 -- Unauthorized</h2>
  489. 			//   <p>Authentication Error: Access Denied! Authorization required.</p></body></html>
  490. 			let xmlLowerCase = '';
  491. 			if (xml) {
  492. 				xmlLowerCase = xml.toLowerCase();
  493. 			}
  494. 			if (
  495. 				(statusCode && statusCode === 401)
  496. 				|| (xml && (xmlLowerCase.includes('sender not authorized') || xmlLowerCase.includes('unauthorized') || xmlLowerCase.includes('notauthorized')))
  497. 			) {
  498. 				// Try again with a Username and Password
  499. 				this._request({
  500. 					body: this._envelopeHeader() +
  501.                         '<GetSystemDateAndTime xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  502.                         this._envelopeFooter()
  503. 				}, function(err, data, xml) {
  504. 					try {
  505. 						let systemDateAndTime = data[0]['getSystemDateAndTimeResponse'][0]['systemDateAndTime'][0];
  506. 						let dateTime = systemDateAndTime['UTCDateTime'] || systemDateAndTime['localDateTime'];
  507. 						let time;
  508. 						if (dateTime === undefined) {
  509. 							// Seen on a cheap Chinese camera from GWellTimes-IPC. Use the current time.
  510. 							time = new Date();
  511. 						} else {
  512. 							let dt = linerase(dateTime[0]);
  513. 							time = new Date(Date.UTC(dt.date.year, dt.date.month - 1, dt.date.day, dt.time.hour, dt.time.minute, dt.time.second));
  514. 						}
  515. 						if (!this.timeShift) {
  516. 							this.timeShift = time - (process.uptime() * 1000);
  517. 						}
  518. 						callback.call(this, err, time, xml);
  519. 					} catch (err) {
  520. 						callback.call(this, err, null, xml);
  521. 					}
  522. 				}.bind(this));
  523. 			} else {
  524. 				callback.call(this, err, null, xml);
  525. 			}
  526. 		}
  527. 	}.bind(this));
  528. };
  531. /**
  532.  * @typedef {object} Cam~SystemDateAndTime
  533.  * @property {string} dayTimeType (Manual | NTP)
  534.  * @property {boolean} daylightSavings
  535.  * @property {string} timezone in POSIX 1003.1 format
  536.  * @property {number} hour
  537.  * @property {number} minute
  538.  * @property {number} second
  539.  * @property {number} year
  540.  * @property {number} month
  541.  * @property {number} day
  542.  */
  544. /**
  545.  * Set the device system date and time
  546.  * @param {object} options
  547.  * @param {Date} [options.dateTime]
  548.  * @param {string} options.dateTimeType (Manual | NTP)
  549.  * @param {boolean} [options.daylightSavings=false]
  550.  * @patam {string} [options.timezone]
  551.  * @param {Cam~DateTimeCallback} callback
  552.  */
  553. Cam.prototype.setSystemDateAndTime = function(options, callback) {
  554. 	if (['Manual', 'NTP'].indexOf(options.dateTimeType) === -1) {
  555. 		return callback(new Error('DateTimeType should be `Manual` or `NTP`'));
  556. 	}
  557. 	this._request({
  558. 		body: this._envelopeHeader() +
  559.             '<SetSystemDateAndTime xmlns="http://www.onvif.org/ver10/device/wsdl">' +
  560.             '<DateTimeType>' +
  561.             options.dateTimeType +
  562.             '</DateTimeType>' +
  563.             '<DaylightSavings>' +
  564.             (!!options.daylightSavings) +
  565.             '</DaylightSavings>' +
  566.             (options.timezone !== undefined ? '<TimeZone>' +
  567.                 '<TZ xmlns="http://www.onvif.org/ver10/schema">' +
  568.                 options.timezone +
  569.                 '</TZ>' +
  570.                 '</TimeZone>' : '') +
  571.             // ( options.dateTime !== undefined && options.dateTime.getDate instanceof Date ?
  572.             (options.dateTime !== undefined && options.dateTime instanceof Date ? '<UTCDateTime>' +
  573.                 '<Time xmlns="http://www.onvif.org/ver10/schema">' +
  574.                 '<Hour>' + options.dateTime.getUTCHours() + '</Hour>' +
  575.                 '<Minute>' + options.dateTime.getUTCMinutes() + '</Minute>' +
  576.                 '<Second>' + options.dateTime.getUTCSeconds() + '</Second>' +
  577.                 '</Time>' +
  578.                 '<Date xmlns="http://www.onvif.org/ver10/schema">' +
  579.                 '<Year>' + options.dateTime.getUTCFullYear() + '</Year>' +
  580.                 '<Month>' + (options.dateTime.getUTCMonth() + 1) + '</Month>' +
  581.                 '<Day>' + options.dateTime.getUTCDate() + '</Day>' +
  582.                 '</Date>' +
  583.                 '</UTCDateTime>' : '') +
  584.             '</SetSystemDateAndTime>' +
  585.             this._envelopeFooter()
  586. 	}, function(err, data, xml) {
  587. 		if (err || linerase(data).setSystemDateAndTimeResponse !== '') {
  588. 			return callback.call(this, linerase(data).setSystemDateAndTimeResponse !== '' ?
  589. 				new Error('Wrong `SetSystemDateAndTime` response') :
  590. 				err, data, xml);
  591. 		}
  592. 		//get new system time from device
  593. 		this.getSystemDateAndTime(callback);
  594. 	}.bind(this));
  595. };
  597. /**
  598.  * Capability list
  599.  * @typedef {object} Cam~Capabilities
  600.  * @property {object} device Device capabilities
  601.  * @property {string} device.XAddr Device service URI
  602.  * @property {object} [device.network] Network capabilities
  603.  * @property {boolean} device.network.IPFilter Indicates support for IP filtering
  604.  * @property {boolean} device.network.zeroConfiguration Indicates support for zeroconf
  605.  * @property {boolean} device.network.IPVersion6 Indicates support for IPv6
  606.  * @property {boolean} device.network.dynDNS Indicates support for dynamic DNS configuration
  607.  * @property {object} [device.system] System capabilities
  608.  * @property {boolean} device.system.discoveryResolve Indicates support for WS Discovery resolve requests
  609.  * @property {boolean} device.system.discoveryBye Indicates support for WS-Discovery Bye
  610.  * @property {boolean} device.system.remoteDiscovery Indicates support for remote discovery
  611.  * @property {boolean} device.system.systemBackup Indicates support for system backup through MTOM
  612.  * @property {boolean} device.system.systemLogging Indicates support for retrieval of system logging through MTOM
  613.  * @property {boolean} device.system.firmwareUpgrade Indicates support for firmware upgrade through MTOM
  614.  * @property {boolean} device.system.httpFirmwareUpgrade Indicates support for firmware upgrade through HTTP
  615.  * @property {boolean} device.system.httpSystemBackup Indicates support for system backup through HTTP
  616.  * @property {boolean} device.system.httpSystemLogging Indicates support for retrieval of system logging through HTTP
  617.  * @property {object} [device.IO] I/O capabilities
  618.  * @property {number} device.IO.inputConnectors Number of input connectors
  619.  * @property {number} device.IO.relayOutputs Number of relay outputs
  620.  * @property {object} [device.IO.extension]
  621.  * @property {boolean} device.IO.extension.auxiliary
  622.  * @property {object} device.IO.extension.auxiliaryCommands
  623.  * @property {object} [device.security] Security capabilities
  624.  * @property {boolean} device.security.'TLS1.1' Indicates support for TLS 1.1
  625.  * @property {boolean} device.security.'TLS1.2' Indicates support for TLS 1.2
  626.  * @property {boolean} device.security.onboardKeyGeneration Indicates support for onboard key generation
  627.  * @property {boolean} device.security.accessPolicyConfig Indicates support for access policy configuration
  628.  * @property {boolean} device.security.'X.509Token' Indicates support for WS-Security X.509 token
  629.  * @property {boolean} device.security.SAMLToken Indicates support for WS-Security SAML token
  630.  * @property {boolean} device.security.kerberosToken Indicates support for WS-Security Kerberos token
  631.  * @property {boolean} device.security.RELToken Indicates support for WS-Security REL token
  632.  * @property {object} events Event capabilities
  633.  * @property {string} events.XAddr Event service URI
  634.  * @property {boolean} events.WSSubscriptionPolicySupport Indicates whether or not WS Subscription policy is supported
  635.  * @property {boolean} events.WSPullPointSupport Indicates whether or not WS Pull Point is supported
  636.  * @property {boolean} events.WSPausableSubscriptionManagerInterfaceSupport Indicates whether or not WS Pausable Subscription Manager Interface is supported
  637.  * @property {object} imaging Imaging capabilities
  638.  * @property {string} imaging.XAddr Imaging service URI
  639.  * @property {object} media Media capabilities
  640.  * @property {string} media.XAddr Media service URI
  641.  * @property {object} media.streamingCapabilities Streaming capabilities
  642.  * @property {boolean} media.streamingCapabilities.RTPMulticast Indicates whether or not RTP multicast is supported
  643.  * @property {boolean} media.streamingCapabilities.RTP_TCP Indicates whether or not RTP over TCP is supported
  644.  * @property {boolean} media.streamingCapabilities.RTP_RTSP_TCP Indicates whether or not RTP/RTSP/TCP is supported
  645.  * @property {object} media.streamingCapabilities.extension
  646.  * @property {object} PTZ PTZ capabilities
  647.  * @property {string} PTZ.XAddr PTZ service URI
  648.  * @property {object} [extension]
  649.  * @property {object} extension.deviceIO DeviceIO capabilities
  650.  * @property {string} extension.deviceIO.XAddr DeviceIO service URI
  651.  * @property {number} extension.deviceIO.videoSources
  652.  * @property {number} extension.deviceIO.videoOutputs
  653.  * @property {number} extension.deviceIO.audioSources
  654.  * @property {number} extension.deviceIO.audioOutputs
  655.  * @property {number} extension.deviceIO.relayOutputs
  656.  * @property {object} [extension.extensions]
  657.  * @property {object} [extension.extensions.telexCapabilities]
  658.  * @property {object} [extension.extensions.scdlCapabilities]
  659.  */
  661. /**
  662.  * @callback Cam~GetCapabilitiesCallback
  663.  * @property {?Error} error
  664.  * @property {Cam~Capabilities} capabilities
  665.  * @property {string} xml Raw SOAP response
  666.  */
  668. /**
  669.  * This method has been replaced by the more generic GetServices method. For capabilities of individual services refer to the GetServiceCapabilities methods.
  670.  * @param {Cam~GetCapabilitiesCallback} [callback]
  671.  */
  672. Cam.prototype.getCapabilities = function(callback) {
  673. 	this._request({
  674. 		body: this._envelopeHeader() +
  675.             '<GetCapabilities xmlns="http://www.onvif.org/ver10/device/wsdl">' +
  676.             '<Category>All</Category>' +
  677.             '</GetCapabilities>' +
  678.             this._envelopeFooter()
  679. 	}, function(err, data, xml) {
  680. 		if (!err) {
  681. 			/**
  682.              * Device capabilities
  683.              * @name Cam#capabilities
  684.              * @type {Cam~Capabilities}
  685.              */
  686. 			this.capabilities = linerase(data[0]['getCapabilitiesResponse'][0]['capabilities'][0]);
  687. 			// fill Cam#uri property
  688. 			if (!this.uri) {
  689. 				/**
  690. 				 * Device service URIs
  691. 				 * @name Cam#uri
  692. 				 * @property {url} [PTZ]
  693. 				 * @property {url} [media]
  694. 				 * @property {url} [imaging]
  695. 				 * @property {url} [events]
  696. 				 * @property {url} [device]
  697. 				 */
  698. 				this.uri = {};
  699. 			}
  700. 			['PTZ', 'media', 'imaging', 'events', 'device'].forEach(function(name) {
  701. 				if (this.capabilities[name] && this.capabilities[name].XAddr) {
  702. 					this.uri[name.toLowerCase()] = this._parseUrl(this.capabilities[name].XAddr);
  703. 				}
  704. 			}.bind(this));
  705. 			// extensions, eg. deviceIO
  706. 			if (this.capabilities.extension) {
  707. 				Object.keys(this.capabilities.extension).forEach(function(ext) {
  708. 					// TODO think about complex extensions like `telexCapabilities` and `scdlCapabilities`
  709. 					if (this.capabilities.extension[ext].XAddr) {
  710. 						this.uri[ext] = url.parse(this.capabilities.extension[ext].XAddr);
  711. 					}
  712. 				}.bind(this));
  713. 			}
  714. 			// HACK for a Profile G NVR that has 'replay' but did not have 'recording' in GetCapabilities
  715. 			if ((this.uri['replay']) && !this.uri['recording']) {
  716. 				var tempRecorderXaddr = this.uri['replay'].href.replace('replay', 'recording');
  717. 				console.warn("WARNING: Adding " + tempRecorderXaddr + " for bad Profile G device");
  718. 				this.uri['recording'] = url.parse(tempRecorderXaddr);
  719. 			}
  720. 		}
  721. 		if (callback) {
  722. 			callback.call(this, err, this.capabilities, xml);
  723. 		}
  724. 	}.bind(this));
  725. };
  727. /**
  728.  * Returns the capabilities of the device service
  729.  * @param [callback]
  730.  */
  731. Cam.prototype.getServiceCapabilities = function(callback) {
  732. 	this._request({
  733. 		body: this._envelopeHeader() +
  734.             '<GetServiceCapabilities xmlns="http://www.onvif.org/ver10/device/wsdl" />' +
  735.             this._envelopeFooter()
  736. 	}, function(err, data, xml) {
  737. 		if (!err) {
  738. 			data = linerase(data);
  739. 			this.serviceCapabilities = {
  740. 				network: data.getServiceCapabilitiesResponse.capabilities.network.$,
  741. 				security: data.getServiceCapabilitiesResponse.capabilities.security.$,
  742. 				system: data.getServiceCapabilitiesResponse.capabilities.system.$
  743. 			};
  744. 			if (data.getServiceCapabilitiesResponse.capabilities.misc) {
  745. 				this.serviceCapabilities.auxiliaryCommands = data.getServiceCapabilitiesResponse.capabilities.misc.$.AuxiliaryCommands.split(' ');
  746. 			}
  747. 		}
  748. 		if (callback) {
  749. 			callback.call(this, err, this.serviceCapabilities, xml);
  750. 		}
  751. 	}.bind(this));
  752. };
  754. /**
  755.  * Active source
  756.  * @typedef {object} Cam~ActiveSource
  757.  * @property {string} sourceToken video source token
  758.  * @property {string} profileToken profile token
  759.  * @property {string} videoSourceConfigurationToken video source configuration token
  760.  * @property {object} [ptz] PTZ-object
  761.  * @property {string} ptz.name PTZ configuration name
  762.  * @property {string} ptz.token PTZ token
  763.  */
  765. /**
  766.  * Get active sources
  767.  * @private
  768.  */
  769. Cam.prototype.getActiveSources = function() {
  770. 	//NVT is a camera with one video source
  771. 	if (this.videoSources.$) {
  772. 		this.videoSources = [this.videoSources];
  773. 	}
  775. 	//The following code block supports a camera with a single video source
  776. 	//as well as encoders with multiple sources. By default, the first source is set to the activeSource.
  777. 	/**
  778.      * Default profiles for the device
  779.      * @name Cam#defaultProfiles
  780.      * @type {Array.<Cam~Profile>}
  781.      */
  782. 	this.defaultProfiles = [];
  783. 	/**
  784.      * Active video sources
  785.      * @name Cam#activeSources
  786.      * @type {Array.<Cam~ActiveSource>}
  787.      */
  788. 	this.activeSources = [];
  790. 	this.videoSources.forEach(function(videoSource, idx) {
  791. 		// let's choose first appropriate profile for our video source and make it default
  792. 		var videoSrcToken = videoSource.$.token,
  793. 			appropriateProfiles = this.profiles.filter(function(profile) {
  794. 				if (profile.videoSourceConfiguration &&  profile.videoEncoderConfiguration) {
  795. 					if (profile.videoSourceConfiguration.sourceToken === videoSrcToken || profile.videoSourceConfiguration.sourceToken === profile.videoSourceConfiguration.name) {
  796. 						return true;
  797. 					}
  798. 				}
  799. 			});
  800. 		if (appropriateProfiles.length === 0) {
  801. 			if (idx === 0) {
  802. 				throw new Error('Unrecognized configuration');
  803. 			} else {
  804. 				return;
  805. 			}
  806. 		}
  808. 		if (idx === 0) {
  809. 			/**
  810. 			 * Default selected profile for the device
  811. 			 * @name Cam#defaultProfile
  812. 			 * @type {Cam~Profile}
  813. 			 */
  814. 			this.defaultProfile = appropriateProfiles[0];
  815. 		}
  817. 		this.defaultProfiles[idx] = appropriateProfiles[0];
  819. 		this.activeSources[idx] = {
  820. 			sourceToken: videoSource.$.token,
  821. 			profileToken: this.defaultProfiles[idx].$.token,
  822. 			videoSourceConfigurationToken: this.defaultProfiles[idx].videoSourceConfiguration.$.token
  823. 		};
  824. 		if (this.defaultProfiles[idx].videoEncoderConfiguration) {
  825. 			var configuration = this.defaultProfiles[idx].videoEncoderConfiguration;
  826. 			this.activeSources[idx].encoding = configuration.encoding;
  827. 			this.activeSources[idx].width = configuration.resolution ? configuration.resolution.width : '';
  828. 			this.activeSources[idx].height = configuration.resolution ? configuration.resolution.height : '';
  829. 			this.activeSources[idx].fps = configuration.rateControl ? configuration.rateControl.frameRateLimit : '';
  830. 			this.activeSources[idx].bitrate = configuration.rateControl ? configuration.rateControl.bitrateLimit : '';
  831. 		}
  833. 		if (idx === 0) {
  834. 			/**
  835. 			 * Current active video source
  836. 			 * @name Cam#activeSource
  837. 			 * @type {Cam~ActiveSource}
  838. 			 */
  839. 			this.activeSource = this.activeSources[idx];
  840. 		}
  842. 		if (this.defaultProfiles[idx].PTZConfiguration) {
  843. 			this.activeSources[idx].ptz = {
  844. 				name: this.defaultProfiles[idx].PTZConfiguration.name,
  845. 				token: this.defaultProfiles[idx].PTZConfiguration.$.token
  846. 			};
  847. 			/* TODO Think about it
  848. 				if (idx === 0) {
  849. 					this.defaultProfile.PTZConfiguration = this.activeSources[idx].PTZConfiguration;
  850. 				}
  851. 			*/
  852. 		}
  853. 	}.bind(this));
  855. 	// If we haven't got any active source, send a warning
  856. 	if (this.activeSources.length === 0) {
  857. 		/**
  858. 		 * Indicates any warning.
  859. 		 * @event Cam#warning
  860. 		 * @type {string}
  861. 		 */
  862. 		this.emit('warning', 'There are no active sources at this device');
  863. 	}
  864. };
  866. /**
  867.  * @typedef {object} Cam~Service
  868.  * @property {string} namespace Namespace uri
  869.  * @property {string} XAddr Uri for requests
  870.  * @property {number} version.minor Minor version
  871.  * @property {number} version.major Major version
  872.  */
  874. /**
  875.  * @callback Cam~GetServicesCallback
  876.  * @property {?Error} error
  877.  * @property {Array.<Cam~Service>} services
  878.  * @property {string} xml Raw SOAP response
  879.  */
  881. /**
  882.  * Returns information about services on the device.
  883.  * @param {boolean} [includeCapability=true] Indicates if the service capabilities (untyped) should be included in the response.
  884.  * @param {Cam~GetServicesCallback} [callback]
  885.  */
  886. Cam.prototype.getServices = function(includeCapability, callback) {
  887. 	if (typeof includeCapability == 'function') {
  888. 		callback = includeCapability;
  889. 		includeCapability = true;
  890. 	}
  891. 	this._request({
  892. 		body: this._envelopeHeader() +
  893.             '<GetServices xmlns="http://www.onvif.org/ver10/device/wsdl">' +
  894.             '<IncludeCapability>' + includeCapability + '</IncludeCapability>' +
  895.             '</GetServices>' +
  896.             this._envelopeFooter(),
  897. 	}, function(err, data, xml) {
  898. 		if (!err) {
  899. 			/**
  900. 			 * Device services
  901. 			 * @name Cam#services
  902. 			 * @type {Array<Cam~Service>}
  903. 			 */
  904. 			this.services = linerase(data).getServicesResponse.service;
  906. 			// ONVIF Profile T introduced Media2 (ver20) so cameras from around 2020/2021 will have
  907. 			// two media entries in the ServicesResponse, one for Media (ver10/media) and one for Media2 (ver20/media)
  908. 			// This is so that existing VMS software can still access the video via the orignal ONVIF Media API
  909. 			// fill Cam#uri property
  910. 			if (!this.uri) {
  911. 				/**
  912. 				 * Device service URIs
  913. 				 * @name Cam#uri
  914. 				 * @property {url} [PTZ]
  915. 				 * @property {url} [media]
  916. 				 * @property {url} [media2]
  917. 				 * @property {url} [imaging]
  918. 				 * @property {url} [events]
  919. 				 * @property {url} [device]
  920. 				 */
  921. 				this.uri = {};
  922. 			}
  923. 			this.media2Support = false;
  924. 			this.services.forEach((service) => {
  925. 				// Look for services with namespaces and XAddr values
  926. 				if (Object.prototype.hasOwnProperty.call(service, 'namespace') && Object.prototype.hasOwnProperty.call(service, 'XAddr')) {
  927. 					// Only parse ONVIF namespaces. Axis cameras return Axis namespaces in GetServices
  928. 					let parsedNamespace = url.parse(service.namespace);
  929. 					if (parsedNamespace.hostname === 'www.onvif.org') {
  930. 						let namespaceSplitted = parsedNamespace.path.substring(1).split('/'); // remove leading Slash, then split
  931. 						// special case for Media and Media2 where cameras supporting Profile S and Profile T (2020/2021 models) have two media services
  932. 						if (namespaceSplitted[1] === 'media' && namespaceSplitted[0] === 'ver20') {
  933. 							this.media2Support = true;
  934. 							namespaceSplitted[1] = 'media2';
  935. 						}
  936. 						this.uri[namespaceSplitted[1]] = this._parseUrl(service.XAddr);
  937. 					}
  938. 				}
  939. 			});
  940. 		}
  941. 		if (callback) {
  942. 			callback.call(this, err, this.services, xml);
  943. 		}
  944. 	}.bind(this));
  945. };
  947. /**
  948.  * @typedef {object} Cam~DeviceInformation
  949.  * @property {string} manufacturer The manufactor of the device
  950.  * @property {string} model The device model
  951.  * @property {string} firmwareVersion The firmware version in the device
  952.  * @property {string} serialNumber The serial number of the device
  953.  * @property {string} hardwareId The hardware ID of the device
  954.  */
  956. /**
  957.  * @callback Cam~GetDeviceInformationCallback
  958.  * @property {?Error} error
  959.  * @property {Cam~DeviceInformation} deviceInformation Device information
  960.  * @property {string} xml Raw SOAP response
  961.  */
  963. /**
  964.  * Receive device information
  965.  * @param {Cam~GetDeviceInformationCallback} [callback]
  966.  */
  967. Cam.prototype.getDeviceInformation = function(callback) {
  968. 	this._request({
  969. 		body: this._envelopeHeader() +
  970.             '<GetDeviceInformation xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  971.             this._envelopeFooter()
  972. 	}, function(err, data, xml) {
  973. 		if (!err) {
  974. 			this.deviceInformation = linerase(data).getDeviceInformationResponse;
  975. 		}
  976. 		if (callback) {
  977. 			callback.call(this, err, this.deviceInformation, xml);
  978. 		}
  979. 	}.bind(this));
  980. };
  982. /**
  983.  * @typedef {object} Cam~HostnameInformation
  984.  * @property {boolean} fromDHCP Indicates whether the hostname is obtained from DHCP or not
  985.  * @property {string} [name] Indicates the hostname
  986.  */
  988. /**
  989.  * @callback Cam~GetHostnameCallback
  990.  * @property {?Error} error
  991.  * @property {Cam~HostnameInformation} hostnameInformation Hostname information
  992.  * @property {string} xml Raw SOAP response
  993.  */
  995. /**
  996.  * Receive hostname information
  997.  * @param {Cam~GetHostnameCallback} [callback]
  998.  */
  999. Cam.prototype.getHostname = function(callback) {
  1000. 	this._request({
  1001. 		body: this._envelopeHeader() +
  1002.             '<GetHostname xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  1003.             this._envelopeFooter()
  1004. 	}, function(err, data, xml) {
  1005. 		if (callback) {
  1006. 			callback.call(this, err, err ? null : linerase(data).getHostnameResponse.hostnameInformation, xml);
  1007. 		}
  1008. 	}.bind(this));
  1009. };
  1011. /**
  1012.  * @typedef {object} Cam~Scope
  1013.  * @property {string} scopeDef Indicates if the scope is fixed or configurable
  1014.  * @property {string} scopeItem Scope item URI
  1015.  */
  1017. /**
  1018.  * @callback Cam~getScopesCallback
  1019.  * @property {?Error} error
  1020.  * @property {Array<Cam~Scope>} scopes Scopes
  1021.  * @property {string} xml Raw SOAP response
  1022.  */
  1024. /**
  1025.  * Receive the scope parameters of a device
  1026.  * @param {Cam~getScopesCallback} callback
  1027.  */
  1028. Cam.prototype.getScopes = function(callback) {
  1029. 	this._request({
  1030. 		body: this._envelopeHeader() +
  1031.             '<GetScopes xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  1032.             this._envelopeFooter()
  1033. 	}, function(err, data, xml) {
  1034. 		if (!err) {
  1035. 			/**
  1036. 			 * Device scopes
  1037. 			 * @type {undefined|Array<Cam~Scope>}
  1038. 			 */
  1039. 			this.scopes = linerase(data).getScopesResponse.scopes;
  1040. 			if (this.scopes === undefined) {
  1041. 				this.scopes = [];
  1042. 			} else if (!Array.isArray(this.scopes)) {
  1043. 				this.scopes = [this.scopes];
  1044. 			}
  1045. 		}
  1046. 		if (callback) {
  1047. 			callback.call(this, err, this.scopes, xml);
  1048. 		}
  1049. 	}.bind(this));
  1050. };
  1052. /**
  1053.  * Set the scope parameters of a device
  1054.  * @param {Array<string>} scopes array of scope's uris
  1055.  * @param {Cam~getScopesCallback} callback
  1056.  */
  1057. Cam.prototype.setScopes = function(scopes, callback) {
  1058. 	this._request({
  1059. 		body: this._envelopeHeader() +
  1060.             '<SetScopes xmlns="http://www.onvif.org/ver10/device/wsdl">' +
  1061.             scopes.map(function(uri) { return '<Scopes>' + uri + '</Scopes>'; }).join('') +
  1062.             '</SetScopes>' +
  1063.             this._envelopeFooter()
  1064. 	}, function(err, data, xml) {
  1065. 		if (err || linerase(data).setScopesResponse !== '') {
  1066. 			return callback(linerase(data).setScopesResponse !== '' ? new Error('Wrong `SetScopes` response') : err, data, xml);
  1067. 		}
  1068. 		// get new scopes from device
  1069. 		this.getScopes(callback);
  1070. 	}.bind(this));
  1071. };
  1073. /**
  1074.  * /Device/ Reboot the device
  1075.  * @param {Cam~MessageCallback} callback
  1076.  */
  1077. Cam.prototype.systemReboot = function(callback) {
  1078. 	this._request({
  1079. 		service: 'deviceIO',
  1080. 		body: this._envelopeHeader() +
  1081.             '<SystemReboot xmlns="http://www.onvif.org/ver10/device/wsdl"/>' +
  1082.             this._envelopeFooter()
  1083. 	}, function(err, res, xml) {
  1084. 		if (!err) {
  1085. 			res = res[0].systemRebootResponse[0].message[0];
  1086. 		}
  1087. 		callback.call(this, err, res, xml);
  1088. 	});
  1089. };
  1091. /**
  1092.  * @callback Cam~SetSystemFactoryDefaultCallback
  1093.  * @property {?Error} error
  1094.  * @property {null}
  1095.  * @property {string} xml Raw SOAP response
  1096.  */
  1098. /**
  1099.  * Reset camera to factory default
  1100.  * @param {boolean} [hard=false] Reset network settings
  1101.  * @param {Cam~SetSystemFactoryDefaultCallback} callback
  1102.  */
  1103. Cam.prototype.setSystemFactoryDefault = function(hard, callback) {
  1104. 	if (callback === undefined) {
  1105. 		callback = hard;
  1106. 		hard = false;
  1107. 	}
  1108. 	let body = this._envelopeHeader() +
  1109.         '<SetSystemFactoryDefault xmlns="http://www.onvif.org/ver10/device/wsdl">' +
  1110.         '<FactoryDefault>' + (hard ? 'Hard' : 'Soft') + '</FactoryDefault>' +
  1111.         '</SetSystemFactoryDefault>' +
  1112.         this._envelopeFooter();
  1113. 	this._request({
  1114. 		service: 'device',
  1115. 		body: body,
  1116. 	}, function(err, res, xml) {
  1117. 		if (callback) {
  1118. 			callback.call(this, err, null, xml);
  1119. 		}
  1120. 	});
  1121. };
  1123. /**
  1124.  * Generate arguments for digest auth
  1125.  * @return {{passdigest: *, nonce: (*|String), timestamp: string}}
  1126.  * @private
  1127.  */
  1128. Cam.prototype._passwordDigest = function() {
  1129. 	let timestamp = (new Date((process.uptime() * 1000) + (this.timeShift || 0))).toISOString();
  1130. 	let nonce = Buffer.allocUnsafe(16);
  1131. 	nonce.writeUIntLE(Math.ceil(Math.random() * 0x100000000), 0, 4);
  1132. 	nonce.writeUIntLE(Math.ceil(Math.random() * 0x100000000), 4, 4);
  1133. 	nonce.writeUIntLE(Math.ceil(Math.random() * 0x100000000), 8, 4);
  1134. 	nonce.writeUIntLE(Math.ceil(Math.random() * 0x100000000), 12, 4);
  1135. 	let cryptoDigest = crypto.createHash('sha1');
  1136. 	cryptoDigest.update(Buffer.concat([nonce, Buffer.from(timestamp, 'ascii'), Buffer.from(this.password, 'ascii')]));
  1137. 	let passdigest = cryptoDigest.digest('base64');
  1138. 	return {
  1139. 		passdigest: passdigest,
  1140. 		nonce: nonce.toString('base64'),
  1141. 		timestamp: timestamp
  1142. 	};
  1143. };
  1145. /**
  1146.  * Envelope header for all SOAP messages
  1147.  * @property {boolean} [openHeader=false]
  1148.  * @returns {string}
  1149.  * @private
  1150.  */
  1151. Cam.prototype._envelopeHeader = function(openHeader) {
  1152. 	let header = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:a="http://www.w3.org/2005/08/addressing">' +
  1153.         '<s:Header>';
  1154. 	// Only insert Security if there is a username and password
  1155. 	if (this.useWSSecurity && this.username && this.password) {
  1156. 		const req = this._passwordDigest();
  1157. 		header += '<Security s:mustUnderstand="1" xmlns="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">' +
  1158. 			'<UsernameToken>' +
  1159. 			'<Username>' + this.username + '</Username>' +
  1160. 			'<Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest">' + req.passdigest + '</Password>' +
  1161. 			'<Nonce EncodingType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary">' + req.nonce + '</Nonce>' +
  1162. 			'<Created xmlns="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">' + req.timestamp + '</Created>' +
  1163. 			'</UsernameToken>' +
  1164. 			'</Security>';
  1165. 	}
  1166. 	if (!(openHeader !== undefined && openHeader)) {
  1167. 		header += '</s:Header>' +
  1168.             '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">';
  1169. 	}
  1170. 	return header;
  1171. };
  1173. /**
  1174.  * Envelope footer for all SOAP messages
  1175.  * @returns {string}
  1176.  * @private
  1177.  */
  1178. Cam.prototype._envelopeFooter = function() {
  1179. 	return '</s:Body>' +
  1180.         '</s:Envelope>';
  1181. };
  1183. /**
  1184.  * Parse url with an eye on `preserveAddress` property
  1185.  * @param {string} address
  1186.  * @returns {URL}
  1187.  * @private
  1188.  */
  1189. Cam.prototype._parseUrl = function(address) {
  1190. 	const parsedAddress = url.parse(address);
  1191. 	// If host for service and default host differs, also if preserve address property set
  1192. 	// we substitute host, hostname and port from settings then rebuild the href using .format
  1193. 	if (this.preserveAddress && (this.hostname !== parsedAddress.hostname || this.port !== parsedAddress.port)) {
  1194. 		parsedAddress.hostname = this.hostname;
  1195. 		parsedAddress.host = this.hostname + ':' + this.port;
  1196. 		parsedAddress.port = this.port;
  1197. 		parsedAddress.href = url.format(parsedAddress);
  1198. 	}
  1199. 	return parsedAddress;
  1200. };
  1202. module.exports = {
  1203. 	Cam: Cam
  1204. };
  1206. // extending Camera prototype
  1207. require('./device')(Cam);
  1208. require('./events')(Cam);
  1209. require('./media')(Cam);
  1210. require('./ptz')(Cam);
  1211. require('./imaging')(Cam);
  1212. require('./recording')(Cam);
  1213. require('./replay')(Cam);