homey-api 3.17.5 → 3.17.7

package/lib/HomeyAPI/HomeyAPIV3/DiscoveryNodeTransport.js

@@ -0,0 +1,589 @@
+'use strict';
+
+const Util = require('../../Util');
+
+const DNS_RECORD_TYPES = {
+  A: 0x0001,
+  AAAA: 0x001c,
+};
+
+const DNS_CLASS_IN = 0x0001;
+const DNS_CLASS_QU = 0x8000;
+
+function getNodeHttpModules() {
+  return {
+    http: require('node:http'),
+    https: require('node:https'),
+  };
+}
+
+function getDnsModule() {
+  return require('node:dns');
+}
+
+function getDgramModule() {
+  return require('node:dgram');
+}
+
+function getNetModule() {
+  return require('node:net');
+}
+
+function createAbortError(reason) {
+  const error = new Error(
+    typeof reason === 'string' && reason.length > 0 ? reason : 'The operation was aborted',
+  );
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  error.type = 'aborted';
+  return error;
+}
+
+function getHostname(url) {
+  try {
+    return new URL(url).hostname;
+  } catch (error) {
+    return null;
+  }
+}
+
+function normalizeHostname(hostname) {
+  return String(hostname || '')
+    .replace(/\.$/, '')
+    .toLowerCase();
+}
+
+function shouldUseResolverLookupForHostname(hostname) {
+  return normalizeHostname(hostname).endsWith('.homey.homeylocal.com');
+}
+
+function shouldUseMdnsLookupForHostname(hostname) {
+  return normalizeHostname(hostname).endsWith('.local');
+}
+
+function getMdnsQueryTypes(options) {
+  const family = Number(options?.family) || 0;
+
+  if (family === 6) {
+    return [DNS_RECORD_TYPES.AAAA];
+  }
+
+  return [DNS_RECORD_TYPES.A];
+}
+
+function getMdnsConfig() {
+  const host = process.env.HOMEY_DISCOVERY_MDNS_HOST || '224.0.0.251';
+  const port = Number(process.env.HOMEY_DISCOVERY_MDNS_PORT) || 5353;
+
+  return {
+    host,
+    port,
+    joinMulticast: host === '224.0.0.251',
+  };
+}
+
+function encodeDnsName(hostname) {
+  const labels = normalizeHostname(hostname).split('.');
+  const parts = [];
+
+  for (const label of labels) {
+    const encodedLabel = Buffer.from(label);
+    parts.push(Buffer.from([encodedLabel.length]));
+    parts.push(encodedLabel);
+  }
+
+  parts.push(Buffer.from([0]));
+
+  return Buffer.concat(parts);
+}
+
+function buildMdnsQuestion(hostname, type) {
+  const question = Buffer.alloc(4);
+  question.writeUInt16BE(type, 0);
+  question.writeUInt16BE(DNS_CLASS_IN | DNS_CLASS_QU, 2);
+
+  return Buffer.concat([encodeDnsName(hostname), question]);
+}
+
+function buildMdnsQuery(hostname, options) {
+  const types = getMdnsQueryTypes(options);
+  const header = Buffer.alloc(12);
+
+  header.writeUInt16BE(0, 0);
+  header.writeUInt16BE(0, 2);
+  header.writeUInt16BE(types.length, 4);
+
+  return Buffer.concat([
+    header,
+    ...types.map((type) => buildMdnsQuestion(hostname, type)),
+  ]);
+}
+
+function readDnsName(buffer, offset, visited = new Set()) {
+  const labels = [];
+  let cursor = offset;
+
+  while (cursor < buffer.length) {
+    const length = buffer[cursor];
+
+    if (length === 0) {
+      return {
+        name: labels.join('.'),
+        offset: cursor + 1,
+      };
+    }
+
+    if ((length & 0xc0) === 0xc0) {
+      if (cursor + 1 >= buffer.length) {
+        throw new Error('Invalid DNS name pointer');
+      }
+
+      const pointer = ((length & 0x3f) << 8) | buffer[cursor + 1];
+
+      if (visited.has(pointer)) {
+        throw new Error('Invalid DNS name compression loop');
+      }
+
+      visited.add(pointer);
+
+      const result = readDnsName(buffer, pointer, visited);
+
+      if (result.name) {
+        labels.push(result.name);
+      }
+
+      return {
+        name: labels.join('.'),
+        offset: cursor + 2,
+      };
+    }
+
+    const labelStart = cursor + 1;
+    const labelEnd = labelStart + length;
+
+    if (labelEnd > buffer.length) {
+      throw new Error('Invalid DNS label length');
+    }
+
+    labels.push(buffer.toString('utf8', labelStart, labelEnd));
+    cursor = labelEnd;
+  }
+
+  throw new Error('Invalid DNS name');
+}
+
+function decodeIPv6Address(buffer, offset) {
+  const segments = [];
+
+  for (let index = 0; index < 8; index++) {
+    segments.push(buffer.readUInt16BE(offset + index * 2).toString(16));
+  }
+
+  return segments.join(':');
+}
+
+function parseDnsAddresses(buffer, hostname) {
+  if (buffer.length < 12) {
+    return [];
+  }
+
+  const normalizedHostname = normalizeHostname(hostname);
+  const questionCount = buffer.readUInt16BE(4);
+  const answerCount = buffer.readUInt16BE(6);
+  const authorityCount = buffer.readUInt16BE(8);
+  const additionalCount = buffer.readUInt16BE(10);
+  const recordCount = answerCount + authorityCount + additionalCount;
+  const addresses = [];
+  let offset = 12;
+
+  for (let index = 0; index < questionCount; index++) {
+    const question = readDnsName(buffer, offset);
+    offset = question.offset + 4;
+
+    if (offset > buffer.length) {
+      return [];
+    }
+  }
+
+  for (let index = 0; index < recordCount; index++) {
+    const recordName = readDnsName(buffer, offset);
+    offset = recordName.offset;
+
+    if (offset + 10 > buffer.length) {
+      return [];
+    }
+
+    const type = buffer.readUInt16BE(offset);
+    const klass = buffer.readUInt16BE(offset + 2) & 0x7fff;
+    const dataLength = buffer.readUInt16BE(offset + 8);
+    const dataOffset = offset + 10;
+    const nextOffset = dataOffset + dataLength;
+
+    if (nextOffset > buffer.length) {
+      return [];
+    }
+
+    if (klass === DNS_CLASS_IN && normalizeHostname(recordName.name) === normalizedHostname) {
+      if (type === DNS_RECORD_TYPES.A && dataLength === 4) {
+        addresses.push({
+          address: Array.from(buffer.subarray(dataOffset, nextOffset)).join('.'),
+          family: 4,
+        });
+      } else if (type === DNS_RECORD_TYPES.AAAA && dataLength === 16) {
+        addresses.push({
+          address: decodeIPv6Address(buffer, dataOffset),
+          family: 6,
+        });
+      }
+    }
+
+    offset = nextOffset;
+  }
+
+  return addresses;
+}
+
+function selectLookupResult(addresses, options) {
+  const family = Number(options?.family) || 0;
+  let candidates = addresses;
+
+  if (family === 4 || family === 6) {
+    candidates = addresses.filter((address) => address.family === family);
+  }
+
+  if (!candidates.length) {
+    return null;
+  }
+
+  if (options?.all === true) {
+    return {
+      address: candidates.map((candidate) => ({
+        address: candidate.address,
+        family: candidate.family,
+      })),
+    };
+  }
+
+  return candidates[0];
+}
+
+function createResolverLookup(signal) {
+  const dns = getDnsModule();
+  const net = getNetModule();
+
+  return (hostname, options, callback) => {
+    let settled = false;
+    let handleAbort = null;
+    const resolver = new dns.Resolver();
+
+    const finish = (error, address, family) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+
+      if (signal && handleAbort) {
+        signal.removeEventListener('abort', handleAbort);
+      }
+
+      callback(error, address, family);
+    };
+
+    const ipFamily = net.isIP(hostname);
+
+    if (ipFamily) {
+      finish(null, hostname, ipFamily);
+      return;
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        finish(createAbortError(signal.reason));
+        return;
+      }
+
+      handleAbort = () => {
+        resolver.cancel();
+        finish(createAbortError(signal.reason));
+      };
+
+      signal.addEventListener('abort', handleAbort, { once: true });
+    }
+
+    const family = Number(options?.family) || 0;
+
+    if (family === 6) {
+      resolver.resolve6(hostname, (error, addresses) => {
+        if (error) {
+          finish(error);
+          return;
+        }
+
+        if (!Array.isArray(addresses) || addresses.length === 0) {
+          finish(new Error(`No DNS results for ${hostname}`));
+          return;
+        }
+
+        if (options?.all === true) {
+          finish(
+            null,
+            addresses.map((address) => ({
+              address,
+              family: 6,
+            })),
+          );
+          return;
+        }
+
+        finish(null, addresses[0], 6);
+      });
+
+      return;
+    }
+
+    resolver.resolve4(hostname, (resolve4Error, addresses) => {
+      if (settled) {
+        return;
+      }
+
+      if (!resolve4Error && Array.isArray(addresses) && addresses.length > 0) {
+        if (options?.all === true) {
+          finish(
+            null,
+            addresses.map((address) => ({
+              address,
+              family: 4,
+            })),
+          );
+          return;
+        }
+
+        finish(null, addresses[0], 4);
+        return;
+      }
+
+      resolver.resolve6(hostname, (resolve6Error, resolve6Addresses) => {
+        if (resolve6Error) {
+          finish(resolve4Error || resolve6Error);
+          return;
+        }
+
+        if (!Array.isArray(resolve6Addresses) || resolve6Addresses.length === 0) {
+          finish(resolve4Error || new Error(`No DNS results for ${hostname}`));
+          return;
+        }
+
+        if (options?.all === true) {
+          finish(
+            null,
+            resolve6Addresses.map((address) => ({
+              address,
+              family: 6,
+            })),
+          );
+          return;
+        }
+
+        finish(null, resolve6Addresses[0], 6);
+      });
+    });
+  };
+}
+
+function createMdnsLookup(signal) {
+  const dgram = getDgramModule();
+  const net = getNetModule();
+
+  return (hostname, options, callback) => {
+    let settled = false;
+    let handleAbort = null;
+    let sendTimers = [];
+    const mdnsConfig = getMdnsConfig();
+    const socket = mdnsConfig.joinMulticast
+      ? dgram.createSocket({ type: 'udp4', reuseAddr: true })
+      : dgram.createSocket('udp4');
+    const query = buildMdnsQuery(hostname, options);
+
+    const cleanup = () => {
+      sendTimers.forEach(clearTimeout);
+      sendTimers = [];
+
+      if (signal && handleAbort) {
+        signal.removeEventListener('abort', handleAbort);
+      }
+
+      socket.removeAllListeners('error');
+      socket.removeAllListeners('message');
+
+      try {
+        socket.close();
+      } catch (error) {
+        void error;
+      }
+    };
+
+    const finish = (error, address, family) => {
+      if (settled) {
+        return;
+      }
+
+      settled = true;
+      cleanup();
+      callback(error, address, family);
+    };
+
+    const ipFamily = net.isIP(hostname);
+
+    if (ipFamily) {
+      finish(null, hostname, ipFamily);
+      return;
+    }
+
+    if (signal) {
+      if (signal.aborted) {
+        finish(createAbortError(signal.reason));
+        return;
+      }
+
+      handleAbort = () => {
+        finish(createAbortError(signal.reason));
+      };
+
+      signal.addEventListener('abort', handleAbort, { once: true });
+    }
+
+    socket.on('error', (error) => {
+      finish(error);
+    });
+
+    socket.on('message', (message) => {
+      let addresses = [];
+
+      try {
+        addresses = parseDnsAddresses(message, hostname);
+      } catch (error) {
+        return;
+      }
+
+      const result = selectLookupResult(addresses, options);
+
+      if (!result) {
+        return;
+      }
+
+      if (options?.all === true) {
+        finish(null, result.address);
+        return;
+      }
+
+      finish(null, result.address, result.family);
+    });
+
+    socket.bind(mdnsConfig.joinMulticast ? mdnsConfig.port : 0, () => {
+      if (settled) {
+        return;
+      }
+
+      if (mdnsConfig.joinMulticast) {
+        try {
+          socket.addMembership(mdnsConfig.host);
+        } catch (error) {
+          void error;
+        }
+      }
+
+      const sendQuery = () => {
+        if (settled) {
+          return;
+        }
+
+        socket.send(query, mdnsConfig.port, mdnsConfig.host, (error) => {
+          if (error) {
+            finish(error);
+          }
+        });
+      };
+
+      sendQuery();
+      sendTimers = [250, 1000].map((delay) => setTimeout(sendQuery, delay));
+    });
+  };
+}
+
+function getLookup(url, signal) {
+  const hostname = getHostname(url);
+
+  if (typeof hostname !== 'string') {
+    return undefined;
+  }
+
+  if (shouldUseResolverLookupForHostname(hostname)) {
+    return createResolverLookup(signal);
+  }
+
+  if (shouldUseMdnsLookupForHostname(hostname)) {
+    return createMdnsLookup(signal);
+  }
+
+  return undefined;
+}
+
+function getAgent(url, signal) {
+  const { http, https } = getNodeHttpModules();
+  const lookup = getLookup(url, signal);
+
+  if (!lookup) {
+    return undefined;
+  }
+
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+
+  if (url.startsWith('https://')) {
+    return new https.Agent({
+      keepAlive: false,
+      lookup,
+    });
+  }
+
+  if (url.startsWith('http://')) {
+    return new http.Agent({
+      keepAlive: false,
+      lookup,
+    });
+  }
+
+  return undefined;
+}
+
+class DiscoveryNodeTransport {
+  static shouldUseForUrl(url) {
+    const hostname = getHostname(url);
+
+    return (
+      typeof hostname === 'string' &&
+      (
+        shouldUseResolverLookupForHostname(hostname) ||
+        shouldUseMdnsLookupForHostname(hostname)
+      )
+    );
+  }
+
+  static async fetch(url, options, timeoutDuration, timeoutMessage) {
+    return Util.fetch(
+      url,
+      options,
+      timeoutDuration,
+      timeoutMessage,
+      (resolvedOptions) => {
+        if (typeof resolvedOptions.agent === 'undefined') {
+          resolvedOptions.agent = getAgent(url, resolvedOptions.signal);
+        }
+      },
+    );
+  }
+}
+
+module.exports = DiscoveryNodeTransport;