@ciphore/radiocli 0.2.3 → 0.2.5

package/vendor/node-airtunes2/lib/srp.js

@@ -0,0 +1,158 @@
+const bigInt = require('big-integer')
+const sha1 = require('js-sha1')
+const memoize = require('lodash/memoize')
+const { hexString2ArrayBuffer } = require('./util')
+
+// ...
+
+const groups = {
+  1024: {
+    N: new bigInt(
+      'EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C'
+      + '9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE4'
+      + '8E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B29'
+      + '7BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9A'
+      + 'FD5138FE8376435B9FC61D2FC0EB06E3', 16),
+
+    g: new bigInt(2),
+  },
+
+  2048: {
+    N: new bigInt(
+      'AC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC319294'
+      + '3DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310D'
+      + 'CD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FB'
+      + 'D5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF74'
+      + '7359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A'
+      + '436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D'
+      + '5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E73'
+      + '03CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB6'
+      + '94B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F'
+      + '9E4AFF73', 16),
+
+    g: new bigInt(2),
+  },
+}
+
+// ...
+
+class SRP {
+  constructor(group) {
+    this.group = group
+
+    this.N = groups[group].N
+    this.g = groups[group].g
+
+    this.A = memoize(this.A)
+    this.K = memoize(this.K)
+  }
+
+  // ...
+  // Private.
+
+  u(A, B) {
+    const A_buf = hexString2ArrayBuffer(A)
+    const B_buf = hexString2ArrayBuffer(B)
+
+    const result = new Uint8Array(A_buf.byteLength + B_buf.byteLength)
+    result.set(A_buf)
+    result.set(B_buf, A_buf.byteLength)
+
+    return sha1(result)
+  }
+
+  k() {
+    const padded_g = '0'.repeat((this.group / 4) - 1) + this.g.toString(16)
+
+    const N_buf = hexString2ArrayBuffer(this.N.toString(16))
+    const g_buf = hexString2ArrayBuffer(padded_g)
+
+    const result = new Uint8Array(N_buf.byteLength + g_buf.byteLength)
+    result.set(N_buf)
+    result.set(g_buf, N_buf.byteLength)
+
+    return sha1(result)
+  }
+
+  x(I, P, s) {
+    const s_buf = hexString2ArrayBuffer(s.toLowerCase())
+    const I_P_buf = hexString2ArrayBuffer(sha1(I + ':' + P))
+
+    const result = new Uint8Array(s_buf.byteLength + I_P_buf.byteLength)
+    result.set(s_buf)
+    result.set(I_P_buf, s_buf.byteLength)
+
+    return sha1(result)
+  };
+
+  S(B, k, x, a, u) {
+    B = new bigInt(B, 16)
+    k = new bigInt(k, 16)
+    x = new bigInt(x, 16)
+    a = new bigInt(a, 16)
+    u = new bigInt(u, 16)
+
+    return B.add(this.N.multiply(k)).subtract(this.g.modPow(x, this.N).multiply(k)).mod(this.N)
+      .modPow(a.add(u.multiply(x)), this.N)
+      .toString(16)
+  }
+
+  // ...
+  // Public.
+
+  A(a) {
+    return this.g.modPow(new bigInt(a, 16), this.N).toString(16)
+  }
+
+  K(I, P, s, a, B) {
+    const k = this.k()
+    const x = this.x(I, P, s)
+    const u = this.u(this.A(a), B)
+    const S = this.S(B, k, x, a, u)
+
+    // ...
+
+    const S_buf = hexString2ArrayBuffer(S)
+
+    let hash1 = new Uint8Array(S_buf.byteLength + 4)
+    hash1.set(S_buf)
+    hash1.set([0x00, 0x00, 0x00, 0x00], S_buf.byteLength)
+
+    let hash2 = new Uint8Array(S_buf.byteLength + 4)
+    hash2.set(S_buf)
+    hash2.set([0x00, 0x00, 0x00, 0x01], S_buf.byteLength)
+
+    return sha1(hash1) + sha1(hash2)
+  }
+
+  M1(I, P, s, a, B) {
+    // M1 = H( H(N) ^ H(g) | H(I) | s | PAD(A) | PAD(B) | K )
+    const A = this.A(a)
+    const K = this.K(I, P, s, a, B)
+
+    const hN = new Uint8Array(sha1.arrayBuffer(hexString2ArrayBuffer(this.N.toString(16))))
+    const hg = new Uint8Array(sha1.arrayBuffer([this.g.toString(16)]))
+
+    const hN_hg = new Uint8Array(20)
+    for (let i = 0; i < 20; i++) {
+      hN_hg[i] = hN[i] ^ hg[i]
+    }
+
+    const hI = sha1.arrayBuffer(I)
+
+    // ...
+
+    return sha1.create()
+      .update(hN_hg)
+      .update(hI)
+      .update(hexString2ArrayBuffer(s))
+      .update(hexString2ArrayBuffer(A))
+      .update(hexString2ArrayBuffer(B))
+      .update(hexString2ArrayBuffer(K))
+      .hex()
+  }
+}
+
+// ...
+
+module.exports = SRP

package/vendor/node-airtunes2/lib/udp_servers.js

@@ -0,0 +1,214 @@
+const dgram = require('dgram')
+const events = require('events')
+const util = require('util')
+const async = require('async')
+const config = require('./config')
+const nu = require('./num_util')
+const ntp = require('./ntp')
+
+const UNBOUND = 0
+const BINDING = 1
+const BOUND = 2
+
+function UDPServers() {
+  events.EventEmitter.call(this)
+
+  this.status = UNBOUND
+
+  this.control = {
+    socket: null,
+    port: null,
+    name: 'control',
+  }
+
+  this.timing = {
+    socket: null,
+    port: null,
+    name: 'timing',
+  }
+
+  this.hosts = []
+}
+
+util.inherits(UDPServers, events.EventEmitter)
+
+UDPServers.prototype.bind = function (host) {
+  let self = this
+
+  this.hosts.push(host)
+
+  switch (this.status) {
+    case BOUND:
+      process.nextTick(function () {
+        self.emit('ports', null, this.control, this.timing)
+      })
+      return
+
+    case BINDING:
+      return
+  }
+
+  self = this
+  this.status = BINDING
+
+  // Timing socket
+  this.timing.socket = dgram.createSocket({ type: 'udp4', reuseAddr: true })
+
+  this.timing.socket.on('message', function (msg, rinfo) {
+    // only listen and respond on own hosts
+    if (self.hosts.indexOf(rinfo.address) < 0) return
+
+    var ts1 = msg.readUInt32BE(24)
+    var ts2 = msg.readUInt32BE(28)
+
+    var reply = new Buffer(32)
+    reply.writeUInt16BE(0x80d3, 0)
+    reply.writeUInt16BE(0x0007, 2)
+    reply.writeUInt32BE(0x00000000, 4)
+
+    reply.writeUInt32BE(ts1, 8)
+    reply.writeUInt32BE(ts2, 12)
+
+    var ntpTime = ntp.timestamp()
+
+    ntpTime.copy(reply, 16)
+    ntpTime.copy(reply, 24)
+
+    self.timing.socket.send(
+      reply, 0, reply.length,
+      rinfo.port, rinfo.address,
+    )
+  })
+
+  // Control socket
+  this.control.socket = dgram.createSocket({ type: 'udp4', reuseAddr: true })
+
+  this.control.socket.on('message', function (msg, rinfo) {
+    // only listen for own hosts
+    if (self.hosts.indexOf(rinfo.address) < 0) return
+
+    var resendRequested = msg.readUInt8(1) == (0x80 | 0x55)
+    // var serverSeq = msg.readUInt16BE(2);
+    if (resendRequested) {
+      const missedSeq = msg.readUInt16BE(4)
+      const count = msg.readUInt16BE(6)
+      self.emit('resendRequested', missedSeq, count)
+    }
+  })
+
+  // // Event socket
+  // this.event.socket = dgram.createSocket('udp4');
+
+  // this.event.socket.on('message', function(msg, rinfo) {
+
+  // // only listen and respond on own hosts
+  // if (self.hosts.indexOf(rinfo.address) < 0) return;
+  // });
+
+  // Find open ports
+  if (!(process.platform == 'darwin')) {
+    var current_port = config.udp_default_port
+
+    self.control.socket.bind(function (err) {
+      if (err) {
+        return cb(err)
+      }
+
+      self.control.port = self.control.socket.address().port
+    })
+    self.timing.socket.bind(function (err) {
+      if (err) {
+        return cb(err)
+      }
+
+      self.timing.port = self.timing.socket.address().port
+    })
+    let myInterval = setInterval(small, 100)
+    function small() {
+      if (self.timing.port != null && self.control.port != null) {
+        clearInterval(myInterval)
+        self.status = BOUND
+        self.emit('ports', null, self.control, self.timing)
+      }
+    }
+  }
+  else {
+    var to_bind = [this.control, this.timing]
+    var current_port = config.udp_default_port
+    async.whilst(
+      function (cb) { cb(null, to_bind.length > 0) },
+      function (cb) {
+        var nextPort = to_bind[0]
+        nextPort.socket.once('error', function (e) {
+          if (e.code === 'EADDRINUSE') {
+            // try next port
+            current_port++
+            cb()
+          }
+          else
+            // otherwise, report the error and cancel everything
+            cb(e)
+        })
+
+        nextPort.socket.once('listening', function () {
+          // socket successfully bound
+          to_bind.shift()
+          nextPort.port = current_port
+          current_port++
+          cb()
+        })
+
+        nextPort.socket.bind(current_port)
+      },
+      function (err) {
+        if (err) {
+          self.close()
+          self.emit('ports', err)
+        }
+        else {
+          self.status = BOUND
+          self.emit('ports', null, self.control, self.timing)
+        }
+      },
+    )
+  }
+}
+
+UDPServers.prototype.close = function () {
+  //
+  try {
+    this.status = UNBOUND
+
+    this.timing.socket.close()
+    this.timing.socket = null
+
+    this.control.socket.close()
+    this.control.socket = null
+  }
+  catch (e) { }
+
+  // this.event.socket.close();
+  // this.event.socket = null;
+}
+
+UDPServers.prototype.sendControlSync = function (seq, dev) {
+  if (this.status !== BOUND)
+    return
+
+  var packet = new Buffer(20)
+
+  packet.writeUInt16BE(0x80d4, 0)
+  packet.writeUInt16BE(0x0007, 2)
+  packet.writeUInt32BE(nu.low32(seq * config.frames_per_packet), 4)
+
+  var ntpTime = ntp.timestamp()
+  ntpTime.copy(packet, 8)
+
+  packet.writeUInt32BE(
+    nu.low32(seq * config.frames_per_packet
+      + config.sampling_rate * 2), 16,
+  )
+  this.control.socket.send(packet, 0, packet.length, dev.controlPort, dev.host)
+}
+
+module.exports = UDPServers

package/vendor/node-airtunes2/lib/util.js

@@ -0,0 +1,12 @@
+const hexString2ArrayBuffer
+  = hexString => new Uint8Array(hexString.match(/[\da-f]{2}/gi).map(h => parseInt(h, 16)))
+
+const buf2hex
+  = buffer => Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('')
+
+// ...
+
+module.exports = {
+  hexString2ArrayBuffer,
+  buf2hex,
+}

package/vendor/node-airtunes2/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "node-airtunes2",
+  "version": "2.5.0-radiocli.1",
+  "private": true,
+  "description": "an AirTunes v2 implementation: stream wirelessly to audio devices.",
+  "main": "./lib/index.js",
+  "licenses": [
+    {
+      "type": "AGPLv3"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bertrandda/node-airtunes2.git"
+  },
+  "radiocliLegacyPairing": "node:crypto",
+  "dependencies": {
+    "@noble/ed25519": "1.7.5",
+    "async": "3.2.6",
+    "axlsign": "git+https://github.com/ciderapp/curve25519-js.git#cae68782564b83ffa1c7c757e40a3944cb140290",
+    "big-integer": "1.6.52",
+    "bplist-creator": "0.1.1",
+    "bplist-parser": "0.3.2",
+    "chacha-js": "git+https://github.com/ciderapp/chacha20poly1305.git#f85941b8f5c62843a1459758cc3dbabad9f849cb",
+    "curve25519-js": "0.0.4",
+    "fast-srp-hap": "2.0.4",
+    "js-sha1": "0.7.0",
+    "lodash": "4.18.1",
+    "python-struct": "1.1.3"
+  }
+}

package/vendor/node-airtunes2/src/CADebugMacros.h

@@ -0,0 +1,257 @@
+/*	Copyright: 	� Copyright 2004 Apple Computer, Inc. All rights reserved.
+
+	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
+			("Apple") in consideration of your agreement to the following terms, and your
+			use, installation, modification or redistribution of this Apple software
+			constitutes acceptance of these terms.  If you do not agree with these terms,
+			please do not use, install, modify or redistribute this Apple software.
+
+			In consideration of your agreement to abide by the following terms, and subject
+			to these terms, Apple grants you a personal, non-exclusive license, under Apple�s
+			copyrights in this original Apple software (the "Apple Software"), to use,
+			reproduce, modify and redistribute the Apple Software, with or without
+			modifications, in source and/or binary forms; provided that if you redistribute
+			the Apple Software in its entirety and without modifications, you must retain
+			this notice and the following text and disclaimers in all such redistributions of
+			the Apple Software.  Neither the name, trademarks, service marks or logos of
+			Apple Computer, Inc. may be used to endorse or promote products derived from the
+			Apple Software without specific prior written permission from Apple.  Except as
+			expressly stated in this notice, no other rights or licenses, express or implied,
+			are granted by Apple herein, including but not limited to any patent rights that
+			may be infringed by your derivative works or by other works in which the Apple
+			Software may be incorporated.
+
+			The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+			WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+			WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+			PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+			COMBINATION WITH YOUR PRODUCTS.
+
+			IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+			CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+			GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+			ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
+			OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
+			(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
+			ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*=============================================================================
+	CADebugMacros.h
+
+=============================================================================*/
+#if !defined(__CADebugMacros_h__)
+#define __CADebugMacros_h__
+
+//=============================================================================
+//	CADebugMacros
+//=============================================================================
+
+//#define	CoreAudio_StopOnFailure			1
+//#define	CoreAudio_TimeStampMessages		1
+//#define	CoreAudio_ThreadStampMessages	1
+//#define	CoreAudio_FlushDebugMessages	1
+
+#define	CA4CCToCString(the4CC)	{ ((char*)&the4CC)[0], ((char*)&the4CC)[1], ((char*)&the4CC)[2], ((char*)&the4CC)[3], 0 }
+
+#if	DEBUG || CoreAudio_Debug
+	
+	// can be used to break into debugger immediately, also see CADebugger
+	#define BusError()		(*(long *)0 = 0)
+	
+	//	basic debugging print routines
+	#if	TARGET_OS_MAC && !TARGET_API_MAC_CARBON
+		extern pascal void DebugStr(const unsigned char* debuggerMsg);
+		#define	DebugMessage(msg)	DebugStr("\p"msg)
+		#define DebugMessageN1(msg, N1)
+		#define DebugMessageN2(msg, N1, N2)
+		#define DebugMessageN3(msg, N1, N2, N3)
+	#else
+		#include "CADebugPrintf.h"
+		
+		#if	CoreAudio_FlushDebugMessages && !CoreAudio_UseSysLog
+			#define	FlushRtn	;fflush(DebugPrintfFile)
+		#else
+			#define	FlushRtn
+		#endif
+		
+		#if		CoreAudio_ThreadStampMessages
+			#include <pthread.h>
+			#include "CAHostTimeBase.h"
+			#define	DebugMessage(msg)										DebugPrintfRtn(DebugPrintfFile, "%p %.4f: %s\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), msg) FlushRtn
+			#define DebugMessageN1(msg, N1)									DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1) FlushRtn
+			#define DebugMessageN2(msg, N1, N2)								DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2) FlushRtn
+			#define DebugMessageN3(msg, N1, N2, N3)							DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3) FlushRtn
+			#define DebugMessageN4(msg, N1, N2, N3, N4)						DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4) FlushRtn
+			#define DebugMessageN5(msg, N1, N2, N3, N4, N5)					DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5) FlushRtn
+			#define DebugMessageN6(msg, N1, N2, N3, N4, N5, N6)				DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6) FlushRtn
+			#define DebugMessageN7(msg, N1, N2, N3, N4, N5, N6, N7)			DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7) FlushRtn
+			#define DebugMessageN8(msg, N1, N2, N3, N4, N5, N6, N7, N8)		DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7, N8) FlushRtn
+			#define DebugMessageN9(msg, N1, N2, N3, N4, N5, N6, N7, N8, N9)	DebugPrintfRtn(DebugPrintfFile, "%p %.4f: "msg"\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7, N8, N9) FlushRtn
+		#elif	CoreAudio_TimeStampMessages
+			#include "CAHostTimeBase.h"
+			#define	DebugMessage(msg)										DebugPrintfRtn(DebugPrintfFile, "%.4f: %s\n", pthread_self(), ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), msg) FlushRtn
+			#define DebugMessageN1(msg, N1)									DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1) FlushRtn
+			#define DebugMessageN2(msg, N1, N2)								DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2) FlushRtn
+			#define DebugMessageN3(msg, N1, N2, N3)							DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3) FlushRtn
+			#define DebugMessageN4(msg, N1, N2, N3, N4)						DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4) FlushRtn
+			#define DebugMessageN5(msg, N1, N2, N3, N4, N5)					DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5) FlushRtn
+			#define DebugMessageN6(msg, N1, N2, N3, N4, N5, N6)				DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6) FlushRtn
+			#define DebugMessageN7(msg, N1, N2, N3, N4, N5, N6, N7)			DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7) FlushRtn
+			#define DebugMessageN8(msg, N1, N2, N3, N4, N5, N6, N7, N8)		DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7, N8) FlushRtn
+			#define DebugMessageN9(msg, N1, N2, N3, N4, N5, N6, N7, N8, N9)	DebugPrintfRtn(DebugPrintfFile, "%.4f: "msg"\n", ((Float64)(CAHostTimeBase::GetCurrentTimeInNanos()) / 1000000.0), N1, N2, N3, N4, N5, N6, N7, N8, N9) FlushRtn
+		#else
+			#define	DebugMessage(msg)										DebugPrintfRtn(DebugPrintfFile, "%s\n", msg) FlushRtn
+			#define DebugMessageN1(msg, N1)									DebugPrintfRtn(DebugPrintfFile, msg"\n", N1) FlushRtn
+			#define DebugMessageN2(msg, N1, N2)								DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2) FlushRtn
+			#define DebugMessageN3(msg, N1, N2, N3)							DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3) FlushRtn
+			#define DebugMessageN4(msg, N1, N2, N3, N4)						DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4) FlushRtn
+			#define DebugMessageN5(msg, N1, N2, N3, N4, N5)					DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4, N5) FlushRtn
+			#define DebugMessageN6(msg, N1, N2, N3, N4, N5, N6)				DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4, N5, N6) FlushRtn
+			#define DebugMessageN7(msg, N1, N2, N3, N4, N5, N6, N7)			DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4, N5, N6, N7) FlushRtn
+			#define DebugMessageN8(msg, N1, N2, N3, N4, N5, N6, N7, N8)		DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4, N5, N6, N7, N8) FlushRtn
+			#define DebugMessageN9(msg, N1, N2, N3, N4, N5, N6, N7, N8, N9)	DebugPrintfRtn(DebugPrintfFile, msg"\n", N1, N2, N3, N4, N5, N6, N7, N8, N9) FlushRtn
+		#endif
+	#endif
+	void	DebugPrint(const char *fmt, ...);	// can be used like printf
+	#define DEBUGPRINT(msg) DebugPrint msg		// have to double-parenthesize arglist (see Debugging.h)
+	#if VERBOSE
+		#define vprint(msg) DEBUGPRINT(msg)
+	#else
+		#define vprint(msg)
+	#endif
+	
+	#if	CoreAudio_StopOnFailure
+		#include "CADebugger.h"
+		#define STOP	CADebuggerStop()
+	#else
+		#define	STOP
+	#endif
+
+#else
+	#define	DebugMessage(msg)
+	#define DebugMessageN1(msg, N1)
+	#define DebugMessageN2(msg, N1, N2)
+	#define DebugMessageN3(msg, N1, N2, N3)
+	#define DebugMessageN4(msg, N1, N2, N3, N4)
+	#define DebugMessageN5(msg, N1, N2, N3, N4, N5)
+	#define DebugMessageN6(msg, N1, N2, N3, N4, N5, N6)
+	#define DebugMessageN7(msg, N1, N2, N3, N4, N5, N6, N7)
+	#define DebugMessageN8(msg, N1, N2, N3, N4, N5, N6, N7, N8)
+	#define DebugMessageN9(msg, N1, N2, N3, N4, N5, N6, N7, N8, N9)
+	#define DEBUGPRINT(msg)
+	#define vprint(msg)
+	#define	STOP
+#endif
+
+void	LogError(const char *fmt, ...);			// writes to syslog (and stderr if debugging)
+
+#define	Assert(inCondition, inMessage)													\
+			if(!(inCondition))															\
+			{																			\
+				DebugMessage(inMessage);												\
+				STOP;																	\
+			}
+
+#define	AssertNoError(inError, inMessage)												\
+			{																			\
+				SInt32 __E__err = (inError);											\
+				if(__E__err != 0)														\
+				{																		\
+					char __4CC_string[5];												\
+					*((SInt32*)__4CC_string) = __E__err;								\
+					__4CC_string[4] = 0;												\
+					DebugMessageN2(inMessage ", Error: %ld (%s)", __E__err, __4CC_string);		\
+					STOP;																\
+				}																		\
+			}
+
+#define	AssertNoKernelError(inError, inMessage)											\
+			{																			\
+				unsigned int __E__err = (unsigned int)(inError);						\
+				if(__E__err != 0)														\
+				{																		\
+					DebugMessageN1(inMessage ", Error: 0x%X", __E__err);				\
+					STOP;																\
+				}																		\
+			}
+
+#define	FailIf(inCondition, inHandler, inMessage)										\
+			if(inCondition)																\
+			{																			\
+				DebugMessage(inMessage);												\
+				STOP;																	\
+				goto inHandler;															\
+			}
+
+#define	FailWithAction(inCondition, inAction, inHandler, inMessage)						\
+			if(inCondition)																\
+			{																			\
+				DebugMessage(inMessage);												\
+				STOP;																	\
+				{ inAction; }															\
+				goto inHandler;															\
+			}
+
+#if defined(__cplusplus)
+
+#define	ThrowIf(inCondition, inException, inMessage)									\
+			if(inCondition)																\
+			{																			\
+				DebugMessage(inMessage);												\
+				STOP;																	\
+				throw (inException);													\
+			}
+
+#define	ThrowIfNULL(inPointer, inException, inMessage)									\
+			if((inPointer) == NULL)														\
+			{																			\
+				DebugMessage(inMessage);												\
+				STOP;																	\
+				throw (inException);													\
+			}
+
+#define	ThrowIfKernelError(inKernelError, inException, inMessage)						\
+			{																			\
+				kern_return_t __E__err = (inKernelError);								\
+				if(__E__err != 0)														\
+				{																		\
+					DebugMessageN1(inMessage ", Error: 0x%X", __E__err);				\
+					STOP;																\
+					throw (inException);												\
+				}																		\
+			}
+
+#define	ThrowIfError(inError, inException, inMessage)									\
+			{																			\
+				SInt32 __E__err = (inError);											\
+				if(__E__err != 0)														\
+				{																		\
+					char __4CC_string[5];												\
+					*((SInt32*)__4CC_string) = __E__err;								\
+					__4CC_string[4] = 0;												\
+					DebugMessageN2(inMessage ", Error: %ld (%s)", __E__err, __4CC_string);		\
+					STOP;																\
+					throw (inException);												\
+				}																		\
+			}
+
+#define	ThrowError(inError, inException, inMessage)										\
+			{																			\
+				SInt32 __E__err = (inError);											\
+				char __4CC_string[5];													\
+				*((SInt32*)__4CC_string) = __E__err;									\
+				__4CC_string[4] = 0;													\
+				DebugMessageN2(inMessage ", Error: %ld (%s)", __E__err, __4CC_string);  \
+				STOP;																	\
+				throw (inException);													\
+			}
+
+#define	SubclassResponsibility(inMethodName, inException)								\
+			{																			\
+				DebugMessage(inMethodName": Subclasses must implement this method");	\
+				throw (inException);													\
+			}
+
+#endif	//	defined(__cplusplus)
+
+#endif