9848661656

Committed 09 Jul 2024 12:05AM UTC coverage: 34.765% (-0.9%) from 35.636%

Build # 9848661656

Build Type

Pull #45

github

Committed by

web-flow

Commit Message

Fix: minor housekeeping. (#48)

Pull Request Pull Request #45: latest <- beta

Run Details

307 of 1222 branches covered (25.12%)

Branch coverage included in aggregate %.

30 of 111 new or added lines in 6 files covered. (27.03%)

6 existing lines in 2 files now uncovered.

1190 of 3084 relevant lines covered (38.59%)

29.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.68

/src/util/domain-formatter.ts

import assert from "assert";
import net from "net";
import { ServiceType } from "../CiaoService";
import { Protocol } from "../index";
import { getIPFromV4Mapped, isIPv4Mapped } from "./v4mapped";

function isProtocol(part: string): boolean {
  return part === "_" + Protocol.TCP || part === "_" + Protocol.UDP;
}

function isSub(part: string): boolean {
  return part === "_sub";
}

function removePrefixedUnderscore(part: string): string {
  return part.startsWith("_")? part.slice(1): part;
}

export interface PTRQueryDomain { // like _http._tcp.local
  domain: string; // most of the time it is just local
  protocol: Protocol;
  type: ServiceType | string;
}

export interface InstanceNameDomain { // like "My Great Device._hap._tcp.local"; _services._dns-sd._udp.local is a special case of this type
  domain: string; // most of the time it is just "local"
  protocol: Protocol;
  type: ServiceType | string;
  name: string;
}

export interface SubTypedNameDomain { // like _printer._sub._http._tcp.local
  domain: string; // most of the time it is just local
  protocol: Protocol;
  type: ServiceType | string;
  subtype: ServiceType | string;
}

export interface FQDNParts {
  name?: string; // exclude if you want to build a PTR domain name
  type: ServiceType | string;
  protocol?: Protocol; // default tcp
  domain?: string; // default local
}

export interface SubTypePTRParts { // like '_printer._sub._http._tcp.local'
  subtype: ServiceType | string; // !!! ensure this name matches
  type: ServiceType | string; // the main type
  protocol?: Protocol; // default tcp
  domain?: string; // default local
}

function isSubTypePTRParts(parts: FQDNParts | SubTypePTRParts): parts is SubTypePTRParts {
  return "subtype" in parts;
}

export function parseFQDN(fqdn: string): PTRQueryDomain | InstanceNameDomain | SubTypedNameDomain {
  const parts = fqdn.split(".");

  assert(parts.length >= 3, "Received illegal fqdn: " + fqdn);

  let i = parts.length - 1;

  let domain = "";
  while (!isProtocol(parts[i])) {
    domain = removePrefixedUnderscore(parts[i]) + (domain? "." + domain: "");
    i--;
  }

  assert(i >= 1, "Failed to parse illegal fqdn: " + fqdn);

  const protocol = removePrefixedUnderscore(parts[i--]) as Protocol;
  const type = removePrefixedUnderscore(parts[i--]);

  if (i < 0) {
    return {
      domain: domain,
      protocol: protocol,
      type: type,
    };
  } else if (isSub(parts[i])) {
    i--; // skip "_sub";
    assert(i === 0, "Received illegal formatted sub type fqdn: " + fqdn);

    const subtype = removePrefixedUnderscore(parts[i]);

    return {
      domain: domain,
      protocol: protocol,
      type: type,
      subtype: subtype,
    };
  } else {
    // the name can contain dots as of RFC 6763 4.1.1.
    const name = removePrefixedUnderscore(parts.slice(0, i + 1).join("."));

    return {
      domain: domain,
      protocol: protocol,
      type: type,
      name: name,
    };
  }
}

export function stringify(parts: FQDNParts | SubTypePTRParts): string {
  assert(parts.type, "type cannot be undefined");
  assert(parts.type.length <= 15, "type must not be longer than 15 characters");

  let prefix;
  if (isSubTypePTRParts(parts)) {
    prefix = `_${parts.subtype}._sub.`;
  } else {
    prefix = parts.name? `${parts.name}.`: "";
  }

  return `${prefix}_${parts.type}._${parts.protocol || Protocol.TCP}.${parts.domain || "local"}.`;
}

export function formatHostname(hostname: string, domain = "local"): string {
  assert(!hostname.endsWith("."), "hostname must not end with the root label!");
  const tld = "." + domain;
  return (!hostname.endsWith(tld)? hostname + tld: hostname) + ".";
}

export function removeTLD(hostname: string): string {
  if (hostname.endsWith(".")) { // check for the DNS root label
    hostname = hostname.substring(0, hostname.length - 1);
  }
  const lastDot = hostname.lastIndexOf(".");
  return hostname.slice(0, lastDot);
}

export function formatMappedIPv4Address(address: string): string {
  if (!isIPv4Mapped(address)) {
    assert(net.isIPv4(address), "Illegal argument. Must be an IPv4 address!");
  }

  assert(net.isIPv4(address), "Illegal argument. Must be an IPv4 address!");

  // Convert IPv4 address to its hexadecimal representation
  const hexParts = address.split(".").map(part => parseInt(part).toString(16).padStart(2, "0"));
  const ipv6Part = `::ffff:${hexParts.join("")}`;

  // Convert the hexadecimal representation to the standard IPv6 format
  return ipv6Part.replace(/(.{4})(.{4})$/, "$1:$2");
}

export function enlargeIPv6(address: string): string {
  assert(net.isIPv6(address), "Illegal argument. Must be ipv6 address!");

  const parts = address.split("::");
  
  // Initialize head and tail arrays
  const head = parts[0] ? parts[0].split(":") : [];
  const tail = parts[1] ? parts[1].split(":") : [];
  
  // Calculate the number of groups to fill in with "0000" when we expand
  const fill = new Array(8 - head.length - tail.length).fill("0000");
  
  // Combine it all and normalize each hextet to be 4 characters long
  return [...head, ...fill, ...tail].map(hextet => hextet.padStart(4, "0")).join(":");
}

export function shortenIPv6(address: string | string[]): string {
  if (typeof address === "string") {
    address = address.split(":");
  }

  for (let i = 0; i < address.length; i++) {
    const part = address[i];

    let j = 0;
    for (; j < Math.min(3, part.length - 1); j++) { // search for the first index which is non-zero, but leaving at least one zero
      if (part.charAt(j) !== "0") {
        break;
      }
    }

    address[i] = part.substr(j);
  }

  let longestBlockOfZerosIndex = -1;
  let longestBlockOfZerosLength = 0;

  for (let i = 0; i < address.length; i++) { // this is not very optimized, but it works
    if (address[i] !== "0") {
      continue;
    }

    let zerosCount = 1;
    let j = i + 1;
    for (; j < address.length; j++) {
      if (address[j] === "0") {
        zerosCount++;
      } else {
        break;
      }
    }

    if (zerosCount > longestBlockOfZerosLength) {
      longestBlockOfZerosIndex = i;
      longestBlockOfZerosLength = zerosCount;
    }

    i = j; // skip all the zeros we already checked + the one after that, we know that's not a zero
  }

  if (longestBlockOfZerosIndex !== -1) {
    const startOrEnd = longestBlockOfZerosIndex === 0 || (longestBlockOfZerosIndex + longestBlockOfZerosLength === 8);
    address[longestBlockOfZerosIndex] = startOrEnd? ":": "";

    if (longestBlockOfZerosLength > 1) {
      address.splice(longestBlockOfZerosIndex + 1, longestBlockOfZerosLength - 1);
    }
  }

  const result = address.join(":");

  if (result === ":") { // special case for the unspecified address
    return "::";
  }

  return result;
}

export function formatReverseAddressPTRName(address: string): string {
  if (net.isIPv4(address)) {
    const split = address.split(".").reverse();

    return split.join(".") + ".in-addr.arpa";
  } 

  if (!net.isIPv6(address)) {
    throw new Error("Supplied illegal ip address format: " + address);
  }

  if (isIPv4Mapped(address)) {
    return (getIPFromV4Mapped(address) as string).split(".").reverse().join(".") + ".in-addr.arpa";
  }

  address = enlargeIPv6(address).toUpperCase();

  const nibbleSplit = address.replace(/:/g, "").split("").reverse();
  assert(nibbleSplit.length === 32, "Encountered invalid ipv6 address length! " + nibbleSplit.length);

  return nibbleSplit.join(".") + ".ip6.arpa";
}

export function ipAddressFromReversAddressName(name: string): string {
  name = name.toLowerCase();

  if (name.endsWith(".in-addr.arpa")) {
    const split = name.replace(".in-addr.arpa", "").split(".").reverse();

    return split.join(".");
  } else if (name.endsWith(".ip6.arpa")) {
    const split = name.replace(".ip6.arpa", "").split(".").reverse();
    assert(split.length === 32, "Encountered illegal length for .ip6.arpa split!");

    const parts: string[] = [];
    for (let i = 0; i < split.length; i += 4) {
      parts.push(split.slice(i, i + 4).join(""));
    }

    return shortenIPv6(parts.join(":"));
  } else {
    throw new Error("Supplied unknown reverse address name format: " + name);
  }
}

export function getNetAddress(address: string, netmask: string): string {
  assert(net.isIP(address) === net.isIP(netmask), "IP address version must match. Netmask cannot have a version different from the address!");

  if (net.isIPv4(address)) {
    const addressParts = address.split(".");
    const netmaskParts = netmask.split(".");
    const netAddressParts = new Array(4);

    for (let i = 0; i < addressParts.length; i++) {
      const addressNum = parseInt(addressParts[i]);
      const netmaskNum = parseInt(netmaskParts[i]);

      netAddressParts[i] = (addressNum & netmaskNum).toString();
    }

    return netAddressParts.join(".");
  } else if (net.isIPv6(address)) {
    const addressParts = enlargeIPv6(address).split(":");
    const netmaskParts = enlargeIPv6(netmask).split(":");

    const netAddressParts = new Array(8);

    for (let i = 0; i < addressParts.length; i++) {
      const addressNum = parseInt(addressParts[i], 16);
      const netmaskNum = parseInt(netmaskParts[i], 16);

      netAddressParts[i] = (addressNum & netmaskNum).toString(16);
    }

    return shortenIPv6(enlargeIPv6(netAddressParts.join(":")));
  } else {
    throw new Error("Illegal argument. Address is not an ip address!");
  }
}

1	import assert from "assert";	24✔
2	import net from "net";	24✔
3	import { ServiceType } from "../CiaoService";
4	import { Protocol } from "../index";
5	import { getIPFromV4Mapped, isIPv4Mapped } from "./v4mapped";	24✔
6
7	function isProtocol(part: string): boolean {
8	return part === "_" + Protocol.TCP \|\| part === "_" + Protocol.UDP;	48✔
9	}
10
11	function isSub(part: string): boolean {
12	return part === "_sub";	12✔
13	}
14
15	function removePrefixedUnderscore(part: string): string {
16	return part.startsWith("_")? part.slice(1): part;	78✔
17	}
18
19	export interface PTRQueryDomain { // like _http._tcp.local
20	domain: string; // most of the time it is just local
21	protocol: Protocol;
22	type: ServiceType \| string;
23	}
24
25	export interface InstanceNameDomain { // like "My Great Device._hap._tcp.local"; _services._dns-sd._udp.local is a special case of this type
26	domain: string; // most of the time it is just "local"
27	protocol: Protocol;
28	type: ServiceType \| string;
29	name: string;
30	}
31
32	export interface SubTypedNameDomain { // like _printer._sub._http._tcp.local
33	domain: string; // most of the time it is just local
34	protocol: Protocol;
35	type: ServiceType \| string;
36	subtype: ServiceType \| string;
37	}
38
39	export interface FQDNParts {
40	name?: string; // exclude if you want to build a PTR domain name
41	type: ServiceType \| string;
42	protocol?: Protocol; // default tcp
43	domain?: string; // default local
44	}
45
46	export interface SubTypePTRParts { // like '_printer._sub._http._tcp.local'
47	subtype: ServiceType \| string; // !!! ensure this name matches
48	type: ServiceType \| string; // the main type
49	protocol?: Protocol; // default tcp
50	domain?: string; // default local
51	}
52
53	function isSubTypePTRParts(parts: FQDNParts \| SubTypePTRParts): parts is SubTypePTRParts {
54	return "subtype" in parts;	12✔
55	}
56
57	export function parseFQDN(fqdn: string): PTRQueryDomain \| InstanceNameDomain \| SubTypedNameDomain {	24✔
58	const parts = fqdn.split(".");	24✔
59
60	assert(parts.length >= 3, "Received illegal fqdn: " + fqdn);	24✔
61
62	let i = parts.length - 1;	21✔
63
64	let domain = "";	21✔
65	while (!isProtocol(parts[i])) {	21✔
66	domain = removePrefixedUnderscore(parts[i]) + (domain? "." + domain: "");	30✔
67	i--;	27✔
68	}
69
70	assert(i >= 1, "Failed to parse illegal fqdn: " + fqdn);	18✔
71
72	const protocol = removePrefixedUnderscore(parts[i--]) as Protocol;	18✔
73	const type = removePrefixedUnderscore(parts[i--]);	18✔
74
75	if (i < 0) {	18✔
76	return {	6✔
77	domain: domain,
78	protocol: protocol,
79	type: type,
80	};
81	} else if (isSub(parts[i])) {	12✔
82	i--; // skip "_sub";	3✔
83	assert(i === 0, "Received illegal formatted sub type fqdn: " + fqdn);	3✔
84
85	const subtype = removePrefixedUnderscore(parts[i]);	3✔
86
87	return {	3✔
88	domain: domain,
89	protocol: protocol,
90	type: type,
91	subtype: subtype,
92	};
93	} else {
94	// the name can contain dots as of RFC 6763 4.1.1.
95	const name = removePrefixedUnderscore(parts.slice(0, i + 1).join("."));	9✔
96
97	return {	9✔
98	domain: domain,
99	protocol: protocol,
100	type: type,
101	name: name,
102	};
103	}
104	}
105
106	export function stringify(parts: FQDNParts \| SubTypePTRParts): string {	24✔
107	assert(parts.type, "type cannot be undefined");	12✔
108	assert(parts.type.length <= 15, "type must not be longer than 15 characters");	12✔
109
110	let prefix;
111	if (isSubTypePTRParts(parts)) {	12✔
112	prefix = `_${parts.subtype}._sub.`;	3✔
113	} else {
114	prefix = parts.name? `${parts.name}.`: "";	9✔
115	}
116
117	return `${prefix}_${parts.type}._${parts.protocol \|\| Protocol.TCP}.${parts.domain \|\| "local"}.`;	12✔
118	}
119
120	export function formatHostname(hostname: string, domain = "local"): string {	24✔
121	assert(!hostname.endsWith("."), "hostname must not end with the root label!");	3✔
122	const tld = "." + domain;	3✔
123	return (!hostname.endsWith(tld)? hostname + tld: hostname) + ".";	3!
124	}
125
126	export function removeTLD(hostname: string): string {	24✔
127	if (hostname.endsWith(".")) { // check for the DNS root label	6✔
128	hostname = hostname.substring(0, hostname.length - 1);	3✔
129	}
130	const lastDot = hostname.lastIndexOf(".");	6✔
131	return hostname.slice(0, lastDot);	6✔
132	}
133
134	export function formatMappedIPv4Address(address: string): string {	24✔
NEW 135	if (!isIPv4Mapped(address)) {	×
NEW 136	assert(net.isIPv4(address), "Illegal argument. Must be an IPv4 address!");	×
137	}
138
NEW 139	assert(net.isIPv4(address), "Illegal argument. Must be an IPv4 address!");	×
140
141	// Convert IPv4 address to its hexadecimal representation
NEW 142	const hexParts = address.split(".").map(part => parseInt(part).toString(16).padStart(2, "0"));	×
NEW 143	const ipv6Part = `::ffff:${hexParts.join("")}`;	×
144
145	// Convert the hexadecimal representation to the standard IPv6 format
NEW 146	return ipv6Part.replace(/(.{4})(.{4})$/, "$1:$2");	×
147	}
148
149	export function enlargeIPv6(address: string): string {	24✔
150	assert(net.isIPv6(address), "Illegal argument. Must be ipv6 address!");	93✔
151
152	const parts = address.split("::");	93✔
153
154	// Initialize head and tail arrays
155	const head = parts[0] ? parts[0].split(":") : [];	93✔
156	const tail = parts[1] ? parts[1].split(":") : [];	93✔
157
158	// Calculate the number of groups to fill in with "0000" when we expand
159	const fill = new Array(8 - head.length - tail.length).fill("0000");	93✔
160
161	// Combine it all and normalize each hextet to be 4 characters long
162	return [...head, ...fill, ...tail].map(hextet => hextet.padStart(4, "0")).join(":");	744✔
163	}
164
165	export function shortenIPv6(address: string \| string[]): string {	24✔
166	if (typeof address === "string") {	63✔
167	address = address.split(":");	63✔
168	}
169
170	for (let i = 0; i < address.length; i++) {	63✔
171	const part = address[i];	504✔
172
173	let j = 0;	504✔
174	for (; j < Math.min(3, part.length - 1); j++) { // search for the first index which is non-zero, but leaving at least one zero	504✔
175	if (part.charAt(j) !== "0") {	765✔
176	break;	192✔
177	}
178	}
179
180	address[i] = part.substr(j);	504✔
181	}
182
183	let longestBlockOfZerosIndex = -1;	63✔
184	let longestBlockOfZerosLength = 0;	63✔
185
186	for (let i = 0; i < address.length; i++) { // this is not very optimized, but it works	63✔
187	if (address[i] !== "0") {	225✔
188	continue;	153✔
189	}
190
191	let zerosCount = 1;	72✔
192	let j = i + 1;	72✔
193	for (; j < address.length; j++) {	72✔
194	if (address[j] === "0") {	279✔
195	zerosCount++;	222✔
196	} else {
197	break;	57✔
198	}
199	}
200
201	if (zerosCount > longestBlockOfZerosLength) {	72✔
202	longestBlockOfZerosIndex = i;	66✔
203	longestBlockOfZerosLength = zerosCount;	66✔
204	}
205
206	i = j; // skip all the zeros we already checked + the one after that, we know that's not a zero	72✔
207	}
208
209	if (longestBlockOfZerosIndex !== -1) {	63✔
210	const startOrEnd = longestBlockOfZerosIndex === 0 \|\| (longestBlockOfZerosIndex + longestBlockOfZerosLength === 8);	63✔
211	address[longestBlockOfZerosIndex] = startOrEnd? ":": "";	63✔
212
213	if (longestBlockOfZerosLength > 1) {	63✔
214	address.splice(longestBlockOfZerosIndex + 1, longestBlockOfZerosLength - 1);	57✔
215	}
216	}
217
218	const result = address.join(":");	63✔
219
220	if (result === ":") { // special case for the unspecified address	63✔
221	return "::";	3✔
222	}
223
224	return result;	60✔
225	}
226
227	export function formatReverseAddressPTRName(address: string): string {	24✔
228	if (net.isIPv4(address)) {	15✔
229	const split = address.split(".").reverse();	3✔
230
231	return split.join(".") + ".in-addr.arpa";	3✔
232	}
233
234	if (!net.isIPv6(address)) {	12✔
235	throw new Error("Supplied illegal ip address format: " + address);	3✔
236	}
237
238	if (isIPv4Mapped(address)) {	9!
NEW 239	return (getIPFromV4Mapped(address) as string).split(".").reverse().join(".") + ".in-addr.arpa";	×
240	}
241
242	address = enlargeIPv6(address).toUpperCase();	9✔
243
244	const nibbleSplit = address.replace(/:/g, "").split("").reverse();	9✔
245	assert(nibbleSplit.length === 32, "Encountered invalid ipv6 address length! " + nibbleSplit.length);	9✔
246
247	return nibbleSplit.join(".") + ".ip6.arpa";	9✔
248	}
249
250	export function ipAddressFromReversAddressName(name: string): string {	24✔
251	name = name.toLowerCase();	15✔
252
253	if (name.endsWith(".in-addr.arpa")) {	15✔
254	const split = name.replace(".in-addr.arpa", "").split(".").reverse();	3✔
255
256	return split.join(".");	3✔
257	} else if (name.endsWith(".ip6.arpa")) {	12✔
258	const split = name.replace(".ip6.arpa", "").split(".").reverse();	9✔
259	assert(split.length === 32, "Encountered illegal length for .ip6.arpa split!");	9✔
260
261	const parts: string[] = [];	9✔
262	for (let i = 0; i < split.length; i += 4) {	9✔
263	parts.push(split.slice(i, i + 4).join(""));	72✔
264	}
265
266	return shortenIPv6(parts.join(":"));	9✔
267	} else {
268	throw new Error("Supplied unknown reverse address name format: " + name);	3✔
269	}
270	}
271
272	export function getNetAddress(address: string, netmask: string): string {	24✔
273	assert(net.isIP(address) === net.isIP(netmask), "IP address version must match. Netmask cannot have a version different from the address!");	21✔
274
275	if (net.isIPv4(address)) {	21✔
276	const addressParts = address.split(".");	12✔
277	const netmaskParts = netmask.split(".");	12✔
278	const netAddressParts = new Array(4);	12✔
279
280	for (let i = 0; i < addressParts.length; i++) {	12✔
281	const addressNum = parseInt(addressParts[i]);	48✔
282	const netmaskNum = parseInt(netmaskParts[i]);	48✔
283
284	netAddressParts[i] = (addressNum & netmaskNum).toString();	48✔
285	}
286
287	return netAddressParts.join(".");	12✔
288	} else if (net.isIPv6(address)) {	9✔
289	const addressParts = enlargeIPv6(address).split(":");	6✔
290	const netmaskParts = enlargeIPv6(netmask).split(":");	6✔
291
292	const netAddressParts = new Array(8);	6✔
293
294	for (let i = 0; i < addressParts.length; i++) {	6✔
295	const addressNum = parseInt(addressParts[i], 16);	48✔
296	const netmaskNum = parseInt(netmaskParts[i], 16);	48✔
297
298	netAddressParts[i] = (addressNum & netmaskNum).toString(16);	48✔
299	}
300
301	return shortenIPv6(enlargeIPv6(netAddressParts.join(":")));	6✔
302	} else {
303	throw new Error("Illegal argument. Address is not an ip address!");	3✔
304	}
305	}

homebridge / ciao / 9848661656

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous