@oneuptime/common 12.0.21 → 12.0.23

package/Utils/NetworkDiscovery/AutoImportRuleMatcher.ts

@@ -0,0 +1,257 @@
+import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import NetworkDeviceMonitoringMethod from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+import CidrMatchUtil from "../NetworkSite/CidrMatchUtil";
+import RulePatternMatchUtil from "../Rules/RulePatternMatchUtil";
+import { monitoringMethodForDiscoveredHost } from "./DiscoveryImportEligibility";
+import ScanTargetUtil from "./ScanTargetUtil";
+
+/*
+ * Matching for network device auto-import rules: which discovered hosts a
+ * rule claims, and whether the rule set as a whole imports a host.
+ *
+ * Pure and dependency-free (no models beyond the host interface, no logger,
+ * no DB) so rule decisions are unit-testable — the same arrangement as
+ * CidrMatchUtil for site assignment rules and RulePatternMatchUtil for
+ * label/owner rules, both of which this reuses rather than re-implements.
+ *
+ * Semantics, mirroring the neighbouring rule engines:
+ *
+ *   - Populated conditions on one rule are ANDed; an empty condition is "not
+ *     configured" and skipped. A rule with NO conditions matches NOTHING
+ *     (the site-rule precedent: an all-wildcard rule is a typo, not a
+ *     match-everything).
+ *   - OR is expressed as multiple rules: a host imports when ANY import rule
+ *     matches it and NO exclusion rule matches it.
+ *   - Exclusion rules veto. "Never import X" needs to be writable without
+ *     regex negative-lookahead gymnastics, and a veto is how an operator
+ *     carves printers and phones out of a broad subnet rule.
+ */
+
+/*
+ * The rule columns matching reads. NetworkDeviceAutoImportRule rows satisfy
+ * this structurally, and tests can build literals.
+ */
+export interface AutoImportRuleCandidate {
+  ipMatchTarget?: string | null | undefined;
+  sysNamePattern?: string | null | undefined;
+  sysDescrPattern?: string | null | undefined;
+  /*
+   * Matched against the host's SNMP sysObjectID — the vendor's registered
+   * enterprise OID (1.3.6.1.4.1.<enterprise>...), the canonical vendor
+   * fingerprint. NOT the free-text pattern syntax of the two fields above:
+   * an OID is a dotted numeric arc, so this is a whole-string '*' glob
+   * (dots literal) or, with no '*', an arc-prefix test — see
+   * matchesOidPattern. Only hosts whose scan carried the field can match: a
+   * ping-only host, or one reported by a probe from before the field
+   * existed, never satisfies a configured sysObjectIdPattern.
+   */
+  sysObjectIdPattern?: string | null | undefined;
+  includePingOnlyHosts?: boolean | null | undefined;
+  isExclusion?: boolean | null | undefined;
+}
+
+/** How the rule set as a whole read one discovered host. */
+export interface AutoImportHostEvaluation {
+  // True when an import rule matched and no exclusion rule vetoed.
+  shouldImport: boolean;
+  // Import rules whose conditions (and ping-only gate) the host satisfied.
+  matchedRules: Array<AutoImportRuleCandidate>;
+  // The exclusion rule that vetoed, when one did.
+  excludedByRule?: AutoImportRuleCandidate | undefined;
+}
+
+/*
+ * Longest subject string a pattern is evaluated against. SNMP DisplayStrings
+ * top out at 255 octets, so anything longer only appears in a hostile or
+ * corrupt probe payload — and the jsonb these hosts come from is stored
+ * verbatim, unbounded. Patterns run through JavaScript's backtracking regex
+ * engine, whose worst case grows with subject length, so the subject is
+ * clamped before matching: a rule author writing a pathological pattern can
+ * only ever run it against a bounded string. (The same author already holds
+ * Edit permission on rules — this bounds the blast radius, it does not make
+ * hostile patterns free.)
+ */
+const MAX_PATTERN_SUBJECT_LENGTH: number = 500;
+
+function clampSubject(value: string | undefined): string | undefined {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  return value.length > MAX_PATTERN_SUBJECT_LENGTH
+    ? value.substring(0, MAX_PATTERN_SUBJECT_LENGTH)
+    : value;
+}
+
+/*
+ * Strips the leading dot some agents prefix OIDs with (".1.3.6.1.4.1.9...")
+ * so a pattern and a value in the two spellings still line up.
+ */
+function normalizeOid(value: string): string {
+  return value.startsWith(".") ? value.substring(1) : value;
+}
+
+/*
+ * OID-aware matching for the sysObjectID condition — deliberately NOT
+ * RulePatternMatchUtil, whose regex-FIRST semantics are systematically wrong
+ * for a dotted numeric arc: as a regex, "1.3.6.1.4.1.9.*" has every '.'
+ * matching any character and is unanchored, so it also matches enterprise
+ * 94, 990, 9148... — the exact vendors a "Cisco only" rule exists to keep
+ * out, in a pipeline that creates devices unattended. Here:
+ *
+ *   - A pattern containing '*' is a whole-string glob with LITERAL dots
+ *     (CidrMatchUtil's ReDoS-safe matcher): "1.3.6.1.4.1.9.*" matches the
+ *     Cisco subtree and nothing else.
+ *   - A pattern with no '*' is an arc-prefix test on sub-identifier
+ *     boundaries: "1.3.6.1.4.1.9" matches itself and everything under it,
+ *     and can never match "1.3.6.1.4.1.94" — the same comparison
+ *     SnmpVendorTemplateUtil.getEnterpriseNumber makes.
+ */
+export function matchesOidPattern(
+  value: string | undefined,
+  pattern: string,
+): boolean {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return false;
+  }
+
+  const oid: string = normalizeOid(value.trim());
+  const oidPattern: string = normalizeOid(pattern);
+
+  if (oidPattern.includes("*")) {
+    return CidrMatchUtil.hostnameMatchesWildcard(oid, oidPattern);
+  }
+
+  return oid === oidPattern || oid.startsWith(oidPattern + ".");
+}
+
+export class AutoImportRuleMatcher {
+  // True when the host answered ping but not SNMP.
+  private static isPingOnlyHost(host: DiscoveredNetworkDevice): boolean {
+    return (
+      monitoringMethodForDiscoveredHost(host) ===
+      NetworkDeviceMonitoringMethod.Monitor
+    );
+  }
+
+  /*
+   * True when this rule's populated conditions all match the host.
+   *
+   * The ping-only gate applies to IMPORT rules only: a host that never
+   * answered SNMP imports only through a rule that explicitly opted into
+   * ping-only hosts — an SNMP credential typo makes a whole subnet report as
+   * ping-only, and a rule silently importing hundreds of half-identified
+   * hosts on a typo is the failure mode this default exists to prevent. An
+   * EXCLUSION rule has no such gate: a veto is a veto whatever the host
+   * answered with.
+   */
+  public static ruleMatchesHost(
+    rule: AutoImportRuleCandidate,
+    host: DiscoveredNetworkDevice,
+  ): boolean {
+    const ipMatchTarget: string = (rule.ipMatchTarget || "").trim();
+    const sysNamePattern: string = (rule.sysNamePattern || "").trim();
+    const sysDescrPattern: string = (rule.sysDescrPattern || "").trim();
+    const sysObjectIdPattern: string = (rule.sysObjectIdPattern || "").trim();
+
+    // A rule with no conditions matches nothing — the site-rule precedent.
+    if (
+      !ipMatchTarget &&
+      !sysNamePattern &&
+      !sysDescrPattern &&
+      !sysObjectIdPattern
+    ) {
+      return false;
+    }
+
+    if (
+      !rule.isExclusion &&
+      !rule.includePingOnlyHosts &&
+      AutoImportRuleMatcher.isPingOnlyHost(host)
+    ) {
+      return false;
+    }
+
+    if (ipMatchTarget) {
+      if (
+        !host.ipAddress ||
+        !ScanTargetUtil.contains(ipMatchTarget, host.ipAddress)
+      ) {
+        return false;
+      }
+    }
+
+    /*
+     * Pattern semantics are RulePatternMatchUtil's, identical to label/owner
+     * rules: case-insensitive unanchored regex first, '*' glob fallback —
+     * so "contains WB1678" is written the same way here as everywhere else.
+     * A host missing the field never matches a configured pattern.
+     */
+    if (
+      sysNamePattern &&
+      !RulePatternMatchUtil.matches(clampSubject(host.sysName), sysNamePattern)
+    ) {
+      return false;
+    }
+
+    if (
+      sysDescrPattern &&
+      !RulePatternMatchUtil.matches(
+        clampSubject(host.sysDescr),
+        sysDescrPattern,
+      )
+    ) {
+      return false;
+    }
+
+    if (
+      sysObjectIdPattern &&
+      !matchesOidPattern(clampSubject(host.sysObjectId), sysObjectIdPattern)
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * What the whole rule set says about one host: import, and through which
+   * rules — or vetoed, and by which exclusion.
+   *
+   * Exclusions are evaluated first so the evaluation can short-circuit into
+   * an explainable answer: "excluded by rule R" beats "matched rules A and B
+   * and was then excluded" for the operator reading a dry run.
+   */
+  public static evaluateHost(
+    rules: Array<AutoImportRuleCandidate>,
+    host: DiscoveredNetworkDevice,
+  ): AutoImportHostEvaluation {
+    for (const rule of rules) {
+      if (
+        rule.isExclusion &&
+        AutoImportRuleMatcher.ruleMatchesHost(rule, host)
+      ) {
+        return {
+          shouldImport: false,
+          matchedRules: [],
+          excludedByRule: rule,
+        };
+      }
+    }
+
+    const matchedRules: Array<AutoImportRuleCandidate> = rules.filter(
+      (rule: AutoImportRuleCandidate): boolean => {
+        return (
+          !rule.isExclusion && AutoImportRuleMatcher.ruleMatchesHost(rule, host)
+        );
+      },
+    );
+
+    return {
+      shouldImport: matchedRules.length > 0,
+      matchedRules: matchedRules,
+    };
+  }
+}
+
+export default AutoImportRuleMatcher;

package/Utils/NetworkDiscovery/DiscoveredDeviceBuilder.ts

@@ -0,0 +1,183 @@
+import NetworkDevice from "../../Models/DatabaseModels/NetworkDevice";
+import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import NetworkDeviceMonitoringMethod from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+import ObjectID from "../../Types/ObjectID";
+import { monitoringMethodForDiscoveredHost } from "./DiscoveryImportEligibility";
+
+/*
+ * One discovered host -> one NetworkDevice, the same way everywhere.
+ *
+ * This mapping used to live inline in the Dashboard's Discovery page import
+ * loop. The server-side auto-import rule engine needs the identical recipe —
+ * a host imported by a rule and the same host imported by hand must be the
+ * same device — so the recipe lives here and both callers use it. Anything
+ * added to one path by editing this file is automatically added to the other.
+ */
+
+/*
+ * Longest device name the builder will emit.
+ *
+ * The name column is varchar(100) and the create path THROWS on overflow (no
+ * truncation), but the real ceiling is the slug: it is slugify(name) plus a
+ * dash and ten random digits into its own varchar(100), so a name over ~88
+ * characters fails the create with a slug-length error even though the name
+ * itself fits. SNMP sysName is a DisplayString of up to 255 octets, so
+ * over-long names are routine on real gear, and the collision fallback below
+ * appends up to 18 more characters (" (255.255.255.255)"). 80 leaves headroom
+ * for both.
+ */
+export const MAX_DEVICE_NAME_LENGTH: number = 80;
+
+// NetworkDevice.description is stored to 500 characters; sysDescr can be 255+.
+export const MAX_DEVICE_DESCRIPTION_LENGTH: number = 500;
+
+function truncate(value: string, maxLength: number): string {
+  return value.length > maxLength ? value.substring(0, maxLength) : value;
+}
+
+/** The name a discovered host imports under: its sysName, or its address. */
+export function buildDeviceName(host: DiscoveredNetworkDevice): string {
+  return truncate(
+    (host.sysName || "").trim() || host.ipAddress,
+    MAX_DEVICE_NAME_LENGTH,
+  );
+}
+
+/**
+ * The fallback name when `buildDeviceName`'s answer is already taken.
+ *
+ * Device names are unique per project, and two devices legitimately sharing a
+ * sysName (a factory default, a cloned config) is common on real estates. The
+ * address is what tells them apart, so it goes into the name — with the
+ * sysName cut down first so the composed string still fits under the same
+ * ceiling.
+ */
+export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
+  const suffix: string = ` (${host.ipAddress})`;
+  const baseName: string = buildDeviceName(host);
+
+  return (
+    truncate(baseName, Math.max(1, MAX_DEVICE_NAME_LENGTH - suffix.length)) +
+    suffix
+  );
+}
+
+/*
+ * The scan columns the builder copies onto an SNMP device. The
+ * NetworkDeviceDiscoveryScan model satisfies this structurally, so both the
+ * dashboard (holding a scan model) and the rule engine (holding a scan row it
+ * selected itself) can pass their scan straight in.
+ */
+export interface DiscoveredDeviceScanSource {
+  probeId?: ObjectID | undefined;
+  snmpVersion?: string | undefined;
+  snmpCommunityString?: string | undefined;
+  snmpPort?: number | undefined;
+  snmpV3SecurityLevel?: string | undefined;
+  snmpV3Username?: string | undefined;
+  snmpV3AuthProtocol?: string | undefined;
+  snmpV3AuthKey?: string | undefined;
+  snmpV3PrivProtocol?: string | undefined;
+  snmpV3PrivKey?: string | undefined;
+}
+
+/**
+ * The NetworkDevice a discovered host imports as.
+ *
+ * An SNMP-reachable host becomes a polled device carrying the scan's probe
+ * and credentials. A ping-only host becomes a monitor-backed device with no
+ * probe, no credentials and polling off: it is recorded so it can belong to a
+ * site and appear on the topology map, and binding a monitor to it stays a
+ * separate, deliberate step.
+ *
+ * The caller supplies the name (normally `buildDeviceName(host)`) so the
+ * name-collision retry can rebuild the same device under
+ * `buildFallbackDeviceName(host)` without re-deciding anything else.
+ */
+export function buildNetworkDeviceFromDiscoveredHost(data: {
+  projectId: ObjectID;
+  host: DiscoveredNetworkDevice;
+  scan: DiscoveredDeviceScanSource;
+  name?: string | undefined;
+  /*
+   * Turn on the device's vendor-health-template auto-apply. The rule
+   * engine sets this — a zero-touch import should end with health metrics,
+   * not an empty OID list waiting for a click. The manual Review dialog
+   * leaves it unset: an operator importing by hand gets the vendor banner
+   * and decides, which is the existing contract for hand-made devices.
+   */
+  autoApplyVendorHealthTemplate?: boolean | undefined;
+}): NetworkDevice {
+  const host: DiscoveredNetworkDevice = data.host;
+
+  const device: NetworkDevice = new NetworkDevice();
+  device.projectId = data.projectId;
+  device.name = data.name || buildDeviceName(host);
+  // The address is the device's hostname AND the registered-host dedup key.
+  device.hostname = host.ipAddress;
+
+  if (host.sysDescr) {
+    device.description = truncate(host.sysDescr, MAX_DEVICE_DESCRIPTION_LENGTH);
+  }
+
+  const monitoringMethod: NetworkDeviceMonitoringMethod =
+    monitoringMethodForDiscoveredHost(host);
+  device.monitoringMethod = monitoringMethod;
+
+  if (monitoringMethod === NetworkDeviceMonitoringMethod.Monitor) {
+    /*
+     * A ping-only host is never SNMP-polled, so the vendor-template
+     * auto-apply (which keys off a polled sysObjectID) stays off too.
+     */
+    device.isPollingEnabled = false;
+    return device;
+  }
+
+  if (data.autoApplyVendorHealthTemplate) {
+    device.autoApplyVendorHealthTemplate = true;
+  }
+
+  if (data.scan.probeId) {
+    // Re-wrapped: the scan may hold a serialized id rather than an ObjectID.
+    device.probeId = new ObjectID(data.scan.probeId.toString());
+  }
+
+  if (data.scan.snmpVersion) {
+    device.snmpVersion = data.scan.snmpVersion;
+  }
+
+  if (data.scan.snmpCommunityString) {
+    device.snmpCommunityString = data.scan.snmpCommunityString;
+  }
+
+  if (data.scan.snmpPort) {
+    device.snmpPort = data.scan.snmpPort;
+  }
+
+  // Carry the v3 credentials so a v3 scan imports as a v3 device.
+  if (data.scan.snmpV3SecurityLevel) {
+    device.snmpV3SecurityLevel = data.scan.snmpV3SecurityLevel;
+  }
+
+  if (data.scan.snmpV3Username) {
+    device.snmpV3Username = data.scan.snmpV3Username;
+  }
+
+  if (data.scan.snmpV3AuthProtocol) {
+    device.snmpV3AuthProtocol = data.scan.snmpV3AuthProtocol;
+  }
+
+  if (data.scan.snmpV3AuthKey) {
+    device.snmpV3AuthKey = data.scan.snmpV3AuthKey;
+  }
+
+  if (data.scan.snmpV3PrivProtocol) {
+    device.snmpV3PrivProtocol = data.scan.snmpV3PrivProtocol;
+  }
+
+  if (data.scan.snmpV3PrivKey) {
+    device.snmpV3PrivKey = data.scan.snmpV3PrivKey;
+  }
+
+  return device;
+}

package/Utils/NetworkDiscovery/DiscoveredHostUtil.ts

@@ -0,0 +1,95 @@
+import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+
+/*
+ * Normalisation for a scan's stored results, shared by every reader of the
+ * `discoveredDevices` jsonb column: the dashboard's Review dialog and the
+ * server-side auto-import rule engine. It moved here from the Dashboard's
+ * DiscoveredHostFilter when the engine appeared, for the reason spelled out
+ * on normalizeDiscoveredHosts below — a server that matched raw jsonb would
+ * re-hit every landmine the dialog already fixed.
+ */
+
+/*
+ * What a nullish or non-object entry in the jsonb reads as: nothing. Written
+ * as a type guard so the normalisation below narrows properly.
+ */
+function isDiscoveredHostObject(
+  host: unknown,
+): host is DiscoveredNetworkDevice {
+  return Boolean(host) && typeof host === "object";
+}
+
+/**
+ * The scan's rows, cleaned up so every rule downstream sees the same thing.
+ *
+ * `discoveredDevices` is jsonb written verbatim from the probe's payload, and
+ * the only guard on it checks that the VALUE is an array — never that its
+ * elements are shaped like hosts. Everything downstream keys off `ipAddress`,
+ * so three payload shapes that a probe should never send, but that nothing
+ * stops it sending, each broke something:
+ *
+ *   - A `null` element. Every predicate dereferences the host, so one null row
+ *     threw a TypeError the moment the operator clicked a filter button —
+ *     inside the modal body, during render.
+ *   - A non-string address. `10` is written into the selection record as the
+ *     key "10" (object keys are strings) but matched out of the imported-set
+ *     with `Set.has(10)`, which does not coerce — so the host imported and
+ *     then could never be retired, and pressing Import again duplicated it.
+ *   - The same address on two rows with different frozen `isAlreadyRegistered`
+ *     values. One checkbox governs both rows, but only one of them refused to
+ *     import, so whether a device already in the inventory got created a
+ *     second time depended on which order the probe happened to list them in.
+ *
+ * All three are fixed here rather than at each call site, so the row the
+ * operator sees, the badge above it, the list Import walks, and the hosts an
+ * auto-import rule evaluates can never be working from different readings of
+ * the same payload.
+ */
+export function normalizeDiscoveredHosts(
+  hosts: Array<DiscoveredNetworkDevice>,
+): Array<DiscoveredNetworkDevice> {
+  const cleaned: Array<DiscoveredNetworkDevice> = [];
+
+  for (const host of hosts) {
+    if (!isDiscoveredHostObject(host)) {
+      continue;
+    }
+
+    /*
+     * Trimmed as well as stringified: " " is not an address, but it is
+     * truthy, so it used to pass selectability and import as a Network Device
+     * whose hostname was a single space.
+     */
+    cleaned.push({
+      ...host,
+      ipAddress:
+        host.ipAddress === undefined || host.ipAddress === null
+          ? ""
+          : String(host.ipAddress).trim(),
+    });
+  }
+
+  // An address the scan reports as registered is registered on every row.
+  const registeredIpAddresses: Set<string> = new Set<string>();
+
+  for (const host of cleaned) {
+    if (host.ipAddress && host.isAlreadyRegistered) {
+      registeredIpAddresses.add(host.ipAddress);
+    }
+  }
+
+  if (registeredIpAddresses.size === 0) {
+    return cleaned;
+  }
+
+  return cleaned.map((host: DiscoveredNetworkDevice) => {
+    if (
+      host.isAlreadyRegistered ||
+      !registeredIpAddresses.has(host.ipAddress)
+    ) {
+      return host;
+    }
+
+    return { ...host, isAlreadyRegistered: true };
+  });
+}

package/Utils/NetworkDiscovery/DiscoveryImportEligibility.ts

@@ -0,0 +1,66 @@
+import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import NetworkDeviceMonitoringMethod from "../../Types/NetworkDevice/NetworkDeviceMonitoringMethod";
+
+/*
+ * Pure, react-free import rule for discovery scan results.
+ *
+ * Every host the sweep found alive is importable; what differs is HOW. A host
+ * that answered SNMP becomes a polled device with the scan's credentials. A
+ * host that answered only ping becomes a monitor-backed device: no probe, no
+ * credentials, health supplied later by a monitor the operator binds to it.
+ *
+ * Ping-only hosts used to be refused outright, on the reasoning that they
+ * would turn up as ARP/FDB endpoints once their switch was monitored. That is
+ * true only where a monitored switch sees them, and an endpoint is not a
+ * device — it cannot belong to a site, carry labels, own an owner rule, or be
+ * one end of a link. Issue #3023 is what that gap looks like from the outside:
+ * "devices I monitor manually don't appear in the topology at all".
+ *
+ * Lives in Common (it started life next to the Discovery page component)
+ * because the dashboard's Review dialog and the server-side auto-import rule
+ * engine both decide "how does this host import" through it, and the two must
+ * never disagree: the group a host is shown under in the dialog and the
+ * monitoring method a rule imports it with are the same decision.
+ */
+
+/**
+ * Which monitoring method a discovered host should be imported under.
+ *
+ * Only an EXPLICIT snmpReachable === false means ping-only: scans stored
+ * before the field existed carry undefined, and every host on those scans
+ * answered SNMP (ping-only sweeps did not exist yet), so legacy rows keep
+ * importing as SNMP devices.
+ */
+export function monitoringMethodForDiscoveredHost(
+  host: DiscoveredNetworkDevice | null | undefined,
+): NetworkDeviceMonitoringMethod {
+  /*
+   * Nullish hosts read as SNMP rather than throwing. `discoveredDevices` is
+   * jsonb written verbatim from the probe's payload and the only guard on it
+   * (DiscoveryScanOutcome.getDiscoveredHosts) checks that the VALUE is an
+   * array — never that its elements are objects. A single null element used
+   * to take the whole page down from inside a table cell or a modal body,
+   * where a thrown TypeError has nowhere useful to go. Every other kind of
+   * junk element (a number, a string, {}) already read as SNMP; null is now
+   * simply consistent with them.
+   */
+  return host?.snmpReachable === false
+    ? NetworkDeviceMonitoringMethod.Monitor
+    : NetworkDeviceMonitoringMethod.Snmp;
+}
+
+/** True when the discovered host can be imported as a Network Device. */
+export function isImportableDiscoveredHost(
+  _host: DiscoveredNetworkDevice,
+): boolean {
+  /*
+   * Every alive host now is. The predicate survives because the Discovery
+   * page filters and counts through it, and because it is the seam where a
+   * future "don't import X" rule for MANUAL review would belong. (The
+   * automatic path already has one: an auto-import exclusion rule vetoes
+   * hosts for the rule engine — deliberately without reaching into this
+   * dialog, where a human is looking at the list and unticking a host is
+   * the veto.)
+   */
+  return true;
+}