docs: unified README and AGENTS.md for merged repo

Replace the KNELServerBuild README with a unified PFVCluster README covering both provisioning and cluster ops. Update AGENTS.md to document the merged repo layout, key scripts, and project context. Consolidate all documentation under docs/. 🤖 Generated with [Crush](https://github.com/charmassociates/crush) Assisted-by: GLM-5 via Crush <crush@charm.land>
refactor: reorganize merged repo into clean directory structure
2026-07-28 11:25:16 -05:00 · 2026-07-28 11:24:39 -05:00 · 2026-07-28 11:23:22 -05:00 · 2026-07-28 08:50:14 -05:00 · 2026-07-28 06:03:21 -05:00 · 2026-07-28 05:31:47 -05:00
161 changed files with 15581 additions and 145 deletions
@@ -17,3 +17,19 @@ __pycache__/
 *.tmp
 *.bak
 *.log.tmp
 # LOGFILENAME artifacts: the framework (Logging.sh + PrettyPrint.sh) appends
 # every print_info/print_error line to LOGFILENAME, defined as
 # "$0.<Weekday>-YYYY-MM-DD-HH:MM:SS.$$". Running any script that sources the
 # framework therefore drops a timestamped log file next to it.
 *.Monday-*
 *.Tuesday-*
 *.Wednesday-*
 *.Thursday-*
 *.Friday-*
 *.Saturday-*
 *.Sunday-*
 # Sensitive exports / runtime data
 dns-cluster-setup/.export/
 returned-logs/
@@ -1,157 +1,63 @@
-# AGENTS.md — Proxmox Performance Optimization Project
+# Agent Guidelines
-**Read this first.** This is a solo-founder R&D Proxmox cluster in a private
+This repo combines two formerly-separate projects:
-residence server room. Shoestring budget. Redundancy is NOT a concern — this
+- **Server provisioning** (formerly KNELServerBuild): `provisioning/`, `tests/`,
-is for batch jobs. Backups DO matter (PBS in use). Production lives elsewhere.
+  `vendor/`, `dns-cluster-setup/`
 - **Proxmox cluster ops** (formerly PFVCluster/perfopt): `perf/`, `netinfra/`,
  `switches/`, `returned-logs/`
-**Four .md files exist:**
+## Repository Layout
 - `AGENTS.md` (this file) -- operating context for the AI agent
 - `PROJECT.md` -- comprehensive board-ready report for the user
 - `K8S.md` -- kubernetes architecture deep-dive (for a future session)
 - `TODO.md` -- pending user actions (tsys2 hardware commands, Friday plan)
-## Current state (as of 2026-07-27)
+- **Vendored framework**: `KNELShellFramework` lives at
  `vendor/git@git.knownelement.com/29418/KNEL/KNELShellFramework/`. Its includes
  are under `Framework-Includes/` there. Never assume `./Framework-Includes`
  exists relative to the repo root.
 - **Self-locating scripts**: All provisioning scripts derive their own location
  via `BASH_SOURCE` and compute `PROJECT_ROOT_PATH` from it. They must never
  depend on the current working directory. Run from anywhere.
 - **Local config files are the source of truth**: Configs in
  `provisioning/ConfigFiles/` are read with `cat`/`cp`. Do NOT re-introduce
  `curl ${DL_ROOT}/...` downloads — that CDN is deprecated.
 - **Non-bash agents**: Some files under `provisioning/Agents/` carry a `.sh`
  extension but are PHP (e.g. `mysql.sh`, shebang `#!/usr/bin/php`). Syntax
  checkers must skip these.
 - **Proxmox hosts** are standalone installs managed via **PDM** (Proxmox
  Datacenter Manager). SSH keys deployed to root on all hosts.
 - **SSH in Crush**: Direct ssh/scp is blocked in the Crush bash environment.
  Use the wrapper scripts: `tests/remote.sh`, `dns-cluster-setup/remote-dns.sh`,
  or the `deploy-check.sh` / `deploy-tuning.sh` patterns.
-### DONE — 5 of 7 hosts fully optimized and validated
+## Git Commit Requirements
-| Host | Status | Notes |
+1. **Commit atomically**: each logical change its own commit.
-|------|--------|-------|
+2. **Conventional commit format**: `feat(scope): desc`, `fix(scope): desc`,
-| pfv-tsys1 | COMPLETE | 11 VMs, infra host, USB for HA/CA |
+   `docs: desc`, `refactor(scope): desc`, `test(scope): desc`, `chore: desc`.
-| pfv-tsys3 | COMPLETE | 1 VM, laptop, kernel 7.0.14 (skewed) |
+3. **Verbose messages**: title (50 chars max), blank line, body explaining
-| pfv-tsys6 | COMPLETE | 5 VMs, bond layer3+4, LACP 1.83 Gbps confirmed |
+   WHAT and WHY, footer with attribution.
 | pfv-tsys7 | COMPLETE | 4 VMs, bond layer3+4, LACP 1.83 Gbps confirmed |
 | pfv-tsys9 | COMPLETE | 5 VMs, validated this session, **storage NIC is USB dongle** |
-### PENDING — 2 hosts blocked on physical hardware work (Friday)
+## Autonomous Git Workflow
-| Host | Blocker | What's staged |
+Agents are authorized to commit AND push autonomously. After each logical unit
-|------|---------|---------------|
+of work: stage, commit, push to `origin/main`. Group changes so each commit is
-| **pfv-tsys4** | PCIe NIC (replace USB dongle) + RAM (16→64GB) | All sysctl/tuned/NFS applied. DO NOT reboot until hardware installed. |
+coherent on its own.
 | **pfv-tsys5** | 2nd ethernet cable (bond0 broken: 1 slave, no LACP partner) | BBR/swappiness applied. NFS staged. Reboot after cable + layer3+4 hash. |
 ### INCOMING
 - **pfv-tsys2** (Precision 5520, i7-7820HQ, 32GB max, Quadro M1200): Currently
  Win10. Will be rebuilt as Proxmox. K8s-dedicated host. **Hardware validated
  2026-07-27: 2 SSDs (Samsung 960 PRO NVMe 512GB + Samsung 850 EVO SATA 1TB)
  -- best local storage in fleet. Both NICs are USB dongles (ASIX + Realtek)
  -- unavoidable on laptop, no PCIe NIC option.**
 - **tsys5 NVMe**: PCI NVMe drive being added Friday. Recommend local-only
  (not NFS-exported) for VM images.
 ## Role taxonomy (user directive)
 | Role | Hosts | Workload |
 |------|-------|----------|
 | **Infrastructure + k8s control** | tsys1, tsys9 | Infra VMs + pfv-k8s cnodes (control plane) + small wnodes |
 | **Kubernetes workers** | tsys2, tsys3, tsys6, tsys7 | pfv-k8s wnodes (heavy workers) -- max RAM for ETL/HPC |
 | **Storage** | tsys4, tsys5 | NFS server + PBS. tsys5 also runs sectestbed. |
 Cnodes weighted to tsys1/9 (lightweight hosts, keep heavy hosts free for
 workers). Wnodes: one per hypervisor host across the fleet. Production lives
 on a VPS in Reston VA (Cloudron) -- this cluster is R&D only.
 ## Critical VM-layer findings (re-audited 2026-07-27 21:50)
 1. **4 of 5 cnodes still on tsys4 NFS** (cnode5 moved to tsys5 S2). Need 2
   more moves (cnode3→S3, cnode4→S2) for etcd quorum survival. User has been
   actively rebalancing via PDM -- storage distribution improved 90/10 to 73/27.
 2. **Both -01/-02 pairs (netinfra, UCS) on tsys4 NFS.** TODO today: move
   netinfra-02 to S3, ucs-02 to S2 (both tsys5 HDD).
 3. **No k8s node uses SSD/NVMe yet.** tsys3 has 349 GB unused local NVMe
   (Samsung PM961), tsys9 has 136 GB local SSD. Deferred to k8s session.
 4. **tsys6/7 local-lvm is USB 2.0 portable HDD** (~30 MB/s). Slower than NFS.
   Do NOT use for VM storage. User accepts OS-on-USB for these hosts.
 5. **Storage philosophy:** NVMe/SSD = k8s scratch + ultix-streaming (dev
   workstation). Spinning rust = all infrastructure VMs.
 6. **Hosts are standalone, managed via PDM** (Proxmox Datacenter Manager).
   VM migration between nodes is done through PDM UI, not manual disk copy.
 ## Storage network IPs (VLAN1000, 10.100.100.0/24)
 ```
 tsys1=.1  tsys3=.3  tsys4=.4  tsys5=.5  tsys6=.6  tsys7=.7  tsys9=.9
 ```
 ## NFS export topology
 **tsys4 exports (primary, overloaded):**
 - D2 = WDC Red 3TB HDD — most VMs live here
 - D5 = Hitachi 2TB HDD
 - (sda Hitachi 1.8T at /mnt/albert — not NFS shared)
 - (sdd WDC 1T — idle, unmounted, removable)
 - (sdf WDC 4.5T SMR at /mnt/backup — PBS target)
 **tsys5 exports (fast-tier hub -- consolidated Friday):**
 - S1/S2/S3 = Seagate 1TB HDD each
 - S4 = Toshiba 500GB HDD
 - T5-SSD = Samsung 860 PRO 256GB SSD (existing)
 - **D3 = SK hynix SC300 512GB SSD** (moving from tsys4 USB to tsys5 SAS Friday)
 - **NVMe (local, new Friday)** — local-only, wnode-tsys5 boot + HPC scratch
 **tsys5 hardware:** LSI SAS1068E (8-port, 5 free) + Intel ICH10 SATA (6-port,
 2 free) + 2x Renesas USB 3.0 xHCI. Plenty of room for the SSD + NVMe.
 **Friday change:** D3 export repoints from pfv-tsys4-nfs-stor to
 pfv-tsys5-nfs-stor. Update storage.cfg cluster-wide. VMs on D3 (currently
 none of significance — it's 99% empty) keep working after remount.
 ## SSH access
 SSH keys deployed to root on all hosts. Direct ssh/scp blocked in Crush bash;
 use `deploy-check.sh` / `deploy-tuning.sh` wrapper patterns instead.
 ## Critical lessons (do NOT regress)
 1. NFS `options` line in storage.cfg must NOT include `version=4.2` — Proxmox
   sets NFS version separately. Use only `options nconnect=4,noatime`.
 2. NFS nconnect=4 only activates on fresh mount — requires VM start or reboot,
   NOT `mount -o remount`.
 3. bond0 xmit_hash_policy: apply live via sysfs, then persist in
   `/etc/network/interfaces` with awk (sed fails on tab-indented stanza).
 4. Always shellcheck before shipping: `docker run --rm -v "$PWD:/mnt"
   koalaman/shellcheck:stable --severity=style scripts/*.sh`
 5. The hosts are **standalone Proxmox installs** (not a pvecm cluster), but
   managed collectively via **Proxmox Datacenter Manager (PDM)**. PDM supports
   VM migration between nodes via the UI. NFS exports are visible to all nodes;
   local storage migration is done through PDM's "Storage Migrate" function.
 6. **Storage philosophy:** NVMe/SSD is for k8s worker scratch + ultix-streaming
   (developer workstation for "cluster of 1" pre-prod jobs). Spinning rust
   hosts all infrastructure VMs (UCS, netinfra, LibreNMS, SIEM).
 ## Friday walkthrough (user action)
 ### Step 1: tsys5 storage cable + NVMe
 1. Plug 2nd ethernet cable into tsys5 storage NIC
 2. Verify: `cat /proc/net/bonding/bond0` — need "Number of ports: 2" + partner MAC
 3. Apply: `echo "layer3+4" > /sys/class/net/bond0/bonding/xmit_hash_policy`
 4. Install PCI NVMe, format as directory storage (local-only)
 5. Reboot tsys5
 ### Step 2: tsys4 hardware install
 1. Install PCIe NIC + add RAM (16→64 GB)
 2. Update `/etc/network/interfaces` — replace `enx8cae4ccda926` with new NIC
 3. Reboot tsys4 (PBS VM restarts — OK)
 ### Step 3: Post-hardware validation
 1. `iperf-full-matrix.sh` — re-test all paths
 2. `validate-fixes.sh pfv-tsys4` and `validate-fixes.sh pfv-tsys5`
 3. Update PROJECT.md with post-hardware numbers
 ## Version control
 This project is tracked in a local git repo (`main` branch). Use **atomic
 commits with conventional commit messages** (e.g., `docs: add disk utilization
 to storage section`, `feat: add tsys9 validation support`). Never push to
 remote unless explicitly asked.
 ## Key scripts
 | Script | Purpose |
 |--------|---------|
-| `scripts/check.sh` | Read-only data collector |
+| `provisioning/SetupNewSystem.sh` | Full server provisioning (packages, hardening, 2FA) |
-| `scripts/apply-tunings.sh` | Tier 0 tunings (dry-run/apply/rollback) |
+| `tests/vm-validation.sh` | End-to-end deploy + validate on sandbox VM |
-| `scripts/fix-bond-nfs.sh` | Fix NFS options + bond hash |
+| `tests/run-tests.sh` | Project test suite (unit/security/validation) |
-| `validate-fixes.sh` | Validation of all applied changes |
+| `dns-cluster-setup/setup.sh` | Technitium DNS cluster replication |
-| `iperf-full-matrix.sh` | Full iperf suite |
+| `perf/deploy-check.sh` | Deploy read-only data collector to hosts |
-| `deploy-check.sh` | Deploy check.sh to hosts via SSH |
+| `perf/deploy-tuning.sh` | Deploy perf tunings to hosts |
 | `perf/validate-fixes.sh` | Validate applied tuning changes |
 | `perf/iperf-full-matrix.sh` | Full iperf throughput suite |
 ## Project context
 This is a solo-founder R&D Proxmox cluster in a private residence. Shoestring
 budget. Redundancy is not a concern for the R&D cluster. Backups DO matter
 (PBS in use). Production lives on a VPS in Reston VA (Cloudron). See
 `docs/PROJECT.md` for the comprehensive fleet report and `docs/TODO.md` for
 pending hardware work.
@@ -0,0 +1,235 @@
 GNU AFFERO GENERAL PUBLIC LICENSE
 Version 3, 19 November 2007
 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
                            Preamble
 The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.
 The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.
 When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.
 Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.
 A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.
 The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.
 An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.
 The precise terms and conditions for copying, distribution and modification follow.
                       TERMS AND CONDITIONS
 0. Definitions.
 "This License" refers to version 3 of the GNU Affero General Public License.
 "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.
 "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.
 To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.
 A "covered work" means either the unmodified Program or a work based on the Program.
 To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.
 To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.
 An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.
 1. Source Code.
 The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.
 A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.
 The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.
 The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those
 subprograms and other parts of the work.
 The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.
 The Corresponding Source for a work in source code form is that same work.
 2. Basic Permissions.
 All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.
 You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.
 Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.
 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.
 When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.
 4. Conveying Verbatim Copies.
 You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.
 You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.
 5. Conveying Modified Source Versions.
 You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:
    a) The work must carry prominent notices stating that you modified it, and giving a relevant date.
    b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".
    c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
    d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.
 A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.
 6. Conveying Non-Source Forms.
 You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:
    a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.
    b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.
    c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.
    d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.
    e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.
 A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.
 A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.
 "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.
 If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).
 The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.
 Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.
 7. Additional Terms.
 "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.
 When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.
 Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:
    a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or
    b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or
    c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or
    d) Limiting the use for publicity purposes of names of licensors or authors of the material; or
    e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or
    f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.
 All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.
 If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.
 Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.
 8. Termination.
 You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).
 However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.
 Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.
 Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.
 9. Acceptance Not Required for Having Copies.
 You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.
 10. Automatic Licensing of Downstream Recipients.
 Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.
 An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.
 You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.
 11. Patents.
 A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".
 A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.
 Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.
 In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.
 If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent
 license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.
 If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.
 A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.
 Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.
 12. No Surrender of Others' Freedom.
 If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may
 not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.
 13. Remote Network Interaction; Use with the GNU General Public License.
 Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.
 Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.
 14. Revised Versions of this License.
 The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.
 Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.
 If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.
 Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.
 15. Disclaimer of Warranty.
 THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
 16. Limitation of Liability.
 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 17. Interpretation of Sections 15 and 16.
 If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.
 END OF TERMS AND CONDITIONS
            How to Apply These Terms to Your New Programs
 If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.
 To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.
     FetchApply
     Copyright (C) 2024  VpTechnicalOperations
     This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
     This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
     You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.
 Also add information on how to contact you by electronic and paper mail.
 If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.
 You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <http://www.gnu.org/licenses/>.
@@ -0,0 +1,70 @@
 # PFVCluster
 Unified infrastructure repo for the Known Element Enterprises Proxmox R&D cluster.
 Combines server provisioning, Proxmox cluster operations, and DNS infrastructure.
 ## Directory Structure
 ```
 provisioning/        Server provisioning (SetupNewSystem.sh, security hardening,
                     2FA, NTP/DNS config, SNMP, Dell OMSA)
 tests/               Test suite + VM validation harness
 dns-cluster-setup/   Technitium DNS cluster replication scripts
 perf/                Proxmox performance tuning, fleet audit, iperf, switch diagnostics
 netinfra/            pfv-netinfra-01/02 DNS/NTP setup + audit scripts
 switches/            Switch configuration captures
 docs/                All documentation (PROJECT.md, SECURITY.md, tailscale.md, etc.)
 vendor/              Vendored KNELShellFramework
 ```
 ## Quick Start
 ### Provision a new server
 ```bash
 sudo bash provisioning/SetupNewSystem.sh
 ```
 Installs packages, applies security hardening (SSH, SCAP-STIG, 2FA, Wazuh),
 configures NTP/DNS/SNMP/syslog/postfix.
 ### Validate provisioning on the sandbox VM
 ```bash
 VM_ID=6000 ./tests/vm-validation.sh all
 ```
 Snapshots, deploys, runs the test suite, auto-rolls back on failure.
 ### Run the test suite
 ```bash
 ./tests/run-tests.sh all
 ```
 ### Deploy DNS cluster setup
 ```bash
 cd dns-cluster-setup/
 ./setup.sh all
 ```
 ### Deploy perf tunings to hosts
 ```bash
 cd perf/
 ./deploy-check.sh    # read-only data collection
 ./deploy-tuning.sh   # apply sysctl/tuned/NFS tunings
 ```
 ## Key Documentation
 | Doc | Contents |
 |-----|----------|
 | `docs/PROJECT.md` | Comprehensive fleet report (7 hosts, VM inventory, storage) |
 | `docs/SECURITY.md` | Security architecture and hardening details |
 | `docs/tailscale.md` | Tailscale vs managed DNS analysis |
 | `docs/DEPLOYMENT.md` | Deployment procedures |
 | `docs/TODO.md` | Pending hardware work (tsys2/4/5) |
 | `dns-cluster-setup/README.md` | DNS cluster setup guide |
 ## Architecture
 - **Proxmox hosts**: 7 standalone PVE installs managed via PDM
 - **DNS**: Technitium (authoritative) + Pi-hole (recursive) on pfv-netinfra-01/02
 - **NTP**: pfv-netinfra-01/02 (redundant, LAN IPs)
 - **Production**: Cloudron VPS in Reston VA (this cluster is R&D only)
 - **Backups**: Proxmox Backup Server (PBS)
@@ -0,0 +1,183 @@
 # Technitium DNS Cluster Setup
 Replicates the production Technitium DNS Server from `tailscale-router` to the
 `pfv-netinfra-01/02` pair and configures them as a primary/secondary cluster
 with automatic zone transfers.
 ## Architecture
 ```
 tailscale-router (PRODUCTION — READ ONLY)
   └─ tsys-dns container (technitium/dns-server)
      └─ 124 zones (knel.net + reverse DNS)
      └─ Users + 2FA in auth.config
                │
          docker cp (export)
                │
                ▼
 ┌─ pfv-netinfra-01 (192.168.3.252) ──── PRIMARY ──────────┐
 │  tsys-dns container (Technitium on :5300)                │
 │  pihole container (Pi-hole on :53 → Technitium :5300)   │
 │  All zones are Primary                                   │
 │  Zone transfer allowed from 192.168.3.253               │
 └──────────────────────────────────────────────────────────┘
                │
          AXFR / IXFR + NOTIFY (DNS zone transfer, port 5300)
                │
                ▼
 ┌─ pfv-netinfra-02 (192.168.3.253) ─── SECONDARY ────────┐
 │  tsys-dns container (Technitium on :5300)                │
 │  pihole container (Pi-hole on :53 → Technitium :5300)   │
 │  All zones are Secondary (AXFR from 01)                  │
 └──────────────────────────────────────────────────────────┘
 ```
 ### How clustering works
 Technitium uses standard DNS zone transfers (AXFR/IXFR) for primary/secondary
 replication, not a proprietary protocol:
 1. **Primary (01)** holds all zones as authoritative primary zones.
 2. **Secondary (02)** holds each zone as a secondary zone configured with
   `primaryServer=192.168.3.252:5300`.
 3. On startup, the secondary immediately AXFRs the full zone from the primary.
 4. On subsequent record changes, the primary sends a **DNS NOTIFY** to the
   secondary, which triggers an **IXFR** (incremental transfer).
 5. If the primary is down, the secondary continues serving the last-known zone
   data independently.
 ### Credentials and 2FA
 The production `auth.config` (containing all user accounts, passwords, and 2FA
 secrets) is copied verbatim to both nodes. This means:
 - The **same username, password, and 2FA device** work on all three servers.
 - The web console is at `http://<host>:5380/` on each node.
 - No credential changes are needed.
 During the clustering configuration step, a temporary admin password is used
 briefly (to access the API without 2FA), then the production `auth.config` is
 restored. See "Security notes" below.
 ## Prerequisites
 - SSH key access to all hosts as `localuser` with passwordless sudo.
 - The `remote-dns.sh` wrapper must be able to reach all hosts via Tailscale FQDN.
 - Docker + Docker Compose on netinfra-01/02 (already installed).
 - The production Technitium on tailscale-router must be running.
 ## Usage
 ```bash
 cd dns-cluster-setup/
 # Step-by-step (recommended for first run):
 ./setup.sh export      # 1. Export config from tailscale-router (READ-ONLY)
 ./setup.sh deploy01    # 2. Deploy to netinfra-01 as primary
 ./setup.sh deploy02    # 3. Deploy to netinfra-02 as secondary clone
 ./setup.sh cluster     # 4. Configure clustering (01→02 zone transfers)
 ./setup.sh verify      # 5. Run all verification tests
 # Or all at once:
 ./setup.sh all
 ```
 ### Configuration overrides
 All defaults can be overridden via environment variables:
 | Variable | Default | Description |
 |---|---|---|
 | `PRIMARY_IP` | `192.168.3.252` | netinfra-01 LAN IP |
 | `SECONDARY_IP` | `192.168.3.253` | netinfra-02 LAN IP |
 | `TECH_PORT` | `5300` | Technitium DNS port on host (from compose mapping) |
 | `CONFIG_DIR` | `/home/localuser/services/technitium/config` | Config bind-mount dir |
 | `COMPOSE_FILE` | `/home/localuser/services/technitium/docker-compose.yml` | Compose file |
 | `TEMP_ADMIN_PW` | `KnelClusterSetup!2026` | Temp admin password (used only during clustering, then discarded) |
 ## Scripts
 | Script | Purpose |
 |---|---|
 | `remote-dns.sh` | SSH/SCP chokepoint for all DNS host access (tsrouter, netinfra01, netinfra02, netboot, sandbox) |
 | `setup.sh` | Master orchestrator: export → deploy → cluster → verify |
 | `verify.sh` | Comprehensive 10-section verification suite |
 | `discover*.sh` | Read-only discovery probes (used during development, safe to keep) |
 ## What gets copied
 From production `/etc/dns/` (inside the container), **excluding** runtime data:
 | Copied (configuration) | Excluded (runtime) |
 |---|---|
 | `auth.config` (users, passwords, 2FA) | `cache.bin` (DNS cache) |
 | `dns.config` (server settings) | `stats/` (query statistics) |
 | `webservice.config` (web console) | `logs/` (log files) |
 | `allowed.config` (zone transfer ACL) | |
 | `blocked.config` (blocked domains) | |
 | `blocklist.config` (blocklist settings) | |
 | `blocklists/` (blocklist data) | |
 | `zones/` (all 124 zone files) | |
 | `scopes/` (DHCP scopes) | |
 | `apps/` (Technitium apps) | |
 ## Verification tests
 The `verify.sh` script runs 10 categories of tests:
 1. **Container health** — both Technitium containers are Up
 2. **API responds** — web console API is reachable on both nodes
 3. **Zone count** — primary matches production; secondary matches primary
 4. **Forward DNS** — known knel.net records resolve identically on both nodes
 5. **External DNS** — both nodes can resolve external domains (github.com)
 6. **Zone transfer (AXFR)** — secondary can AXFR knel.net from primary
 7. **Reverse DNS** — PTR zones have SOA records on both nodes
 8. **Production untouched** — container still running, zone count unchanged
 9. **Failover** — secondary serves SOA independently (no primary dependency)
 10. **Credentials** — `auth.config` byte-size matches across all three nodes
 ## Security notes
 - **tailscale-router is never modified.** The only operation is `docker cp`
  (read) to export the config. No writes, no restarts, no config changes.
 - The temporary admin password (`TEMP_ADMIN_PW`) exists only during the
  clustering step. After configuration, the production `auth.config` (with 2FA)
  is restored. The temp password is never persisted.
 - The export tarball (`.export/technitium-production-config.tar.gz`) contains
  production credentials. It is in `.gitignore` and should be deleted after
  setup: `rm -rf dns-cluster-setup/.export/`
 - Each node's existing config is backed up to `config.backup-<timestamp>` before
  replacement, so the change is reversible.
 ## Recovery
 If something goes wrong, each node has a backup:
 ```bash
 # On netinfra-01 or netinfra-02:
 cd /home/localuser/services/technitium/
 docker compose down
 mv config config.failed
 mv config.backup-<timestamp> config
 docker compose up -d
 ```
 ## Validation on sandbox
 After cluster setup, validate that client hosts use the pair correctly:
 ```bash
 # From sectestbed-sandbox (or any client):
 # Query primary directly:
 dig @192.168.3.252 pfv-netinfra-01.knel.net
 # Query secondary directly:
 dig @192.168.3.253 pfv-netinfra-01.knel.net
 # Both should return the same answer.
 ```
 The KNELServerBuild provisioning code (`ProjectCode/ConfigFiles/NTP/ntp.conf`
 and `ProjectCode/ConfigFiles/Resolv/resolv.conf`) points clients at both
 servers for DNS and NTP redundancy. See `ProjectDocs/tailscale.md` for the
 full DNS architecture analysis.
@@ -0,0 +1,90 @@
 #!/usr/bin/bash
 #
 # remote-dns.sh
 #
 # Single chokepoint for ALL ssh/scp access to the DNS infrastructure hosts.
 # Every other script in dns-cluster-setup/ MUST route through this wrapper.
 # Never call ssh/scp directly.
 #
 # WHY: one place to configure host aliases/users/keys, one place to audit,
 # and the command scanner only permits ssh when invoked indirectly via a
 # script. Mirrors the pattern of tests/remote.sh.
 #
 # HOSTS (override IPs via env if needed):
 #   tsrouter       tailscale-router.knel.net  (PRODUCTION — READ-ONLY here)
 #   netinfra01     pfv-netinfra-01.knel.net   (Technitium primary target)
 #   netinfra02     pfv-netinfra-02.knel.net   (Technitium secondary target)
 #   netboot        pfv-netboot.knel.net       (reference / validation client)
 #   sandbox        sectestbed-sandbox.knel.net (validation client)
 #
 # All hosts are accessed as $VM_USER (default: localuser) over SSH with key auth
 # and passwordless sudo.
 #
 # USAGE:
 #   remote-dns.sh <host-alias> <cmd...>          run command on host
 #   remote-dns.sh <host-alias>-root <cmd...>     run command on host as root (sudo)
 #   remote-dns.sh <host-alias>-file <script>     run a local script file on host (bash -s)
 #   remote-dns.sh <host-alias>-copy <local> <remote-dest>   copy a file to host
 #
 #   e.g.
 #   remote-dns.sh tsrouter 'hostname; whoami'
 #   remote-dns.sh netinfra01-root 'systemctl status dnsServer'
 #   remote-dns.sh tsrouter-file ./probe.sh
 #
 set -uo pipefail
 VM_USER="${VM_USER:-localuser}"
 # Hostname -> FQDN map. Override individual IPs via env if a host moves.
 TSROUTER_HOST="${TSROUTER_HOST:-tailscale-router.knel.net}"
 NETINFRA01_HOST="${NETINFRA01_HOST:-pfv-netinfra-01.knel.net}"
 NETINFRA02_HOST="${NETINFRA02_HOST:-pfv-netinfra-02.knel.net}"
 NETBOOT_HOST="${NETBOOT_HOST:-pfv-netboot.knel.net}"
 SANDBOX_HOST="${SANDBOX_HOST:-sectestbed-sandbox.knel.net}"
 SSH_OPTS=(-o BatchMode=yes -o StrictHostKeyChecking=accept-new -o ConnectTimeout=15)
 die() { echo "remote-dns.sh: $*" >&2; exit 1; }
 host_fqdn() {
  case "$1" in
    tsrouter)    printf '%s' "$TSROUTER_HOST" ;;
    netinfra01)  printf '%s' "$NETINFRA01_HOST" ;;
    netinfra02)  printf '%s' "$NETINFRA02_HOST" ;;
    netboot)     printf '%s' "$NETBOOT_HOST" ;;
    sandbox)     printf '%s' "$SANDBOX_HOST" ;;
    *) return 1 ;;
  esac
 }
 _run() { ssh "${SSH_OPTS[@]}" "${VM_USER}@$1" "$2"; }
 _run_root() { ssh "${SSH_OPTS[@]}" "${VM_USER}@$1" "sudo -n bash -c $(printf '%q' "$2")"; }
 _run_file() { ssh "${SSH_OPTS[@]}" "${VM_USER}@$1" "bash -s" < "$2"; }
 _copy() {
  local fqdn="$1" local="$2" dest="$3"
  if command -v rsync >/dev/null 2>&1 \
     && ssh "${SSH_OPTS[@]}" "${VM_USER}@${fqdn}" 'command -v rsync' >/dev/null 2>&1; then
    rsync -az -e "ssh ${SSH_OPTS[*]}" "$local" "${VM_USER}@${fqdn}:${dest}"
  else
    ssh "${SSH_OPTS[@]}" "${VM_USER}@${fqdn}" "cat > '$dest'" < "$local"
  fi
 }
 spec="${1:-}"; shift || true
 # Split host alias from mode: "netinfra01", "netinfra01-root", "netinfra01-file", "netinfra01-copy"
 mode="run"
 alias="$spec"
 case "$spec" in
  *-root) mode="root"; alias="${spec%-root}" ;;
  *-file) mode="file"; alias="${spec%-file}" ;;
  *-copy) mode="copy"; alias="${spec%-copy}" ;;
 esac
 fqdn="$(host_fqdn "$alias")" || die "unknown host alias '$alias' (try: tsrouter|netinfra01|netinfra02|netboot|sandbox)"
 case "$mode" in
  run)  _run "$fqdn" "$*" ;;
  root) [ "$#" -ge 1 ] || die "need command"; _run_root "$fqdn" "$*" ;;
  file) [ -f "${1:-}" ] || die "need local script file"; _run_file "$fqdn" "$1" ;;
  copy) [ -f "${1:-}" ] || die "need local file"; _copy "$fqdn" "$1" "${2:-}" ;;
  *) die "bad mode" ;;
 esac
@@ -0,0 +1,474 @@
 #!/usr/bin/bash
 #
 # setup.sh — Technitium DNS Cluster Setup
 #
 # Replicates the production Technitium DNS Server config from tailscale-router
 # to the pfv-netinfra-01/02 pair, then configures 01 as primary and 02 as
 # secondary with automatic zone transfers (AXFR).
 #
 # PRODUCTION SAFETY: tailscale-router is accessed READ-ONLY. No file on it is
 # modified. The only operation is a docker cp (read) to export the config.
 #
 # ARCHITECTURE AFTER SETUP:
 #
 #   pfv-netinfra-01 (192.168.3.252) — PRIMARY
 #     Pi-hole (:53) → Technitium (:5300 inside container)
 #     All zones are Primary; zone transfer allowed from 02
 #
 #   pfv-netinfra-02 (192.168.3.253) — SECONDARY
 #     Pi-hole (:53) → Technitium (:5300 inside container)
 #     All zones are Secondary; AXFR from 01 on changes
 #
 #   tailscale-router — PRODUCTION (untouched, read-only source of truth)
 #
 # CLUSTERING MECHANISM:
 #   Technitium primary/secondary via DNS zone transfers (AXFR/IXFR + NOTIFY).
 #   01 serves all zones as Primary. 02 fetches them as Secondary from
 #   01's address (192.168.3.252:5300). When a record changes on 01, it sends
 #   a DNS NOTIFY to 02, which immediately pulls the update via IXFR.
 #
 # CREDENTIALS:
 #   The production auth.config (users + 2FA) is copied to both targets, so
 #   the existing admin username, password, and 2FA device work identically on
 #   all three servers.
 #
 # USAGE:
 #   ./setup.sh export     # Step 1: read-only export from tailscale-router
 #   ./setup.sh deploy01   # Step 2: deploy config to netinfra-01 (primary)
 #   ./setup.sh deploy02   # Step 3: deploy config to netinfra-02 (secondary)
 #   ./setup.sh cluster    # Step 4: configure clustering (01 primary, 02 secondary)
 #   ./setup.sh verify     # Step 5: test everything
 #   ./setup.sh all        # Steps 1-5 in sequence
 #
 set -euo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REMOTE="$HERE/remote-dns.sh"
 # Host aliases (defined in remote-dns.sh)
 PROD="tsrouter"        # tailscale-router (READ-ONLY)
 PRIMARY="netinfra01"   # pfv-netinfra-01
 SECONDARY="netinfra02" # pfv-netinfra-02
 # Network addresses for zone transfer
 PRIMARY_IP="${PRIMARY_IP:-192.168.3.252}"
 SECONDARY_IP="${SECONDARY_IP:-192.168.3.253}"
 # Technitium DNS port on the host (from docker-compose port mapping)
 TECH_PORT="${TECH_PORT:-5300}"
 # Config directory on the netinfra hosts (bind mount target)
 CONFIG_DIR="${CONFIG_DIR:-/home/localuser/services/technitium/config}"
 COMPOSE_FILE="${COMPOSE_FILE:-/home/localuser/services/technitium/docker-compose.yml}"
 # Temporary admin password used ONLY during clustering API calls.
 # After configuration, the production auth.config (with 2FA) is restored.
 TEMP_ADMIN_PW="${TEMP_ADMIN_PW:-KnelCluster2026}"
 # Local working directory for exports
 WORK_DIR="$HERE/.export"
 mkdir -p "$WORK_DIR"
 # Files/dirs to EXCLUDE from the config copy (runtime data, not configuration)
 EXCLUDE_PATTERNS=(cache.bin stats logs)
 log()  { printf '\033[0;36m[%s]\033[0m %s\n' "$(date +%H:%M:%S)" "$*"; }
 die()  { log "ERROR: $*"; exit 1; }
 # -----------------------------------------------------------------------------
 # Helpers
 # -----------------------------------------------------------------------------
 # Build an exclude-args string for tar
 exclude_args() {
  local args=""
  for p in "${EXCLUDE_PATTERNS[@]}"; do
    args+=" --exclude=$p"
  done
  printf '%s' "$args"
 }
 # Run a command on a host as root via the wrapper
 run_root() { bash "$REMOTE" "$1-root" "${@:2}"; }
 run()      { bash "$REMOTE" "$1" "${@:2}"; }
 # Get a Technitium API token on a host (temporary admin, no 2FA)
 # Uses root to avoid PATH issues with non-interactive SSH sessions.
 # Usage: get_token <host-alias>
 get_token() {
  local host="$1"
  local resp
  resp=$(run_root "$host" "curl -sk --max-time 10 -X POST http://127.0.0.1:5380/api/user/login -d 'user=admin&pass=${TEMP_ADMIN_PW}'" 2>/dev/null || true)
  local token
  token=$(echo "$resp" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('token',''))" 2>/dev/null || true)
  printf '%s' "$token"
 }
 # API call helper (uses root for reliable curl access)
 # Usage: api_call <host> <token> <endpoint> [param=value ...]
 api_call() {
  local host="$1" token="$2" endpoint="$3"; shift 3
  local url="http://127.0.0.1:5380/api/${endpoint}?token=${token}"
  local p
  for p in "$@"; do url+="&${p}"; done
  run_root "$host" "curl -sk --max-time 10 '$url'" 2>/dev/null || true
 }
 # -----------------------------------------------------------------------------
 # Step 1: Export production config (READ-ONLY on tailscale-router)
 # -----------------------------------------------------------------------------
 do_export() {
  log "=== STEP 1: Exporting production config from $PROD (READ-ONLY) ==="
  local export_tar="$WORK_DIR/technitium-production-config.tar.gz"
  log "Exporting config volume from $PROD (piped, no disk writes on prod)..."
  # Read the Docker volume directory directly from the host filesystem.
  # No docker exec needed (avoids /tmp space issues on the prod host).
  # Pipe tar → ssh → local file. Nothing is written on production's disk.
  local vol_path
  vol_path=$(bash "$REMOTE" "$PROD-root" \
    "docker volume inspect -f '{{.Mountpoint}}' dns_tsys-dns-config 2>/dev/null" \
    | tr -d '[:space:]')
  [ -n "$vol_path" ] || die "Could not find Docker volume path on $PROD."
  log "Volume path: $vol_path"
  bash "$REMOTE" "$PROD-root" \
    "tar czf - -C '$vol_path' --exclude=cache.bin --exclude=stats --exclude=logs ." \
    > "$export_tar" 2>/dev/null || die "Export pipe failed."
  [ -s "$export_tar" ] || die "Export tarball is empty."
  # Inspect
  local zone_count
  zone_count=$(tar tzf "$export_tar" | grep -c '\.zone$' || true)
  log "Export complete: $(du -h "$export_tar" | cut -f1), $zone_count zones."
  # Save the zone name list for clustering
  tar tzf "$export_tar" | grep '\.zone$' | sed 's|^\./||; s|^zones/||; s|\.zone$||' | sort > "$WORK_DIR/zones.txt"
  log "Zone list saved ($zone_count zones): $(head -5 "$WORK_DIR/zones.txt" | tr '\n' ' ')..."
 }
 # -----------------------------------------------------------------------------
 # Step 2: Deploy to netinfra-01 (PRIMARY)
 # -----------------------------------------------------------------------------
 do_deploy_primary() {
  log "=== STEP 2: Deploying PRIMARY to $PRIMARY ==="
  _deploy "$PRIMARY" "primary"
 }
 # -----------------------------------------------------------------------------
 # Step 3: Deploy to netinfra-02 (SECONDARY — initial clone, clustering in step 4)
 # -----------------------------------------------------------------------------
 do_deploy_secondary() {
  log "=== STEP 3: Deploying SECONDARY to $SECONDARY ==="
  _deploy "$SECONDARY" "secondary"
 }
 # Shared deploy logic
 # Usage: _deploy <host-alias> <role>
 _deploy() {
  local host="$1" role="$2"
  local export_tar="$WORK_DIR/technitium-production-config.tar.gz"
  [ -f "$export_tar" ] || die "No export found. Run '$0 export' first."
  log "Stopping Technitium on $host..."
  run_root "$host" "cd $CONFIG_DIR/.. && docker compose down" 2>/dev/null \
    || run_root "$host" "docker stop tsys-dns" 2>/dev/null || true
  log "Backing up existing config on $host..."
  run_root "$host" "
    if [ -d '$CONFIG_DIR' ]; then
      mv '$CONFIG_DIR' '${CONFIG_DIR}.backup-$(date +%Y%m%d-%H%M%S)'
    fi
    mkdir -p '$CONFIG_DIR'
  " || die "Backup failed."
  log "Uploading production config to $host..."
  bash "$REMOTE" "$host-root" "cat > /tmp/technitium-config.tar.gz" < "$export_tar" \
    || die "Upload failed."
  log "Extracting config on $host..."
  run_root "$host" "
    cd '$CONFIG_DIR'
    tar xzf /tmp/technitium-config.tar.gz
    rm -f /tmp/technitium-config.tar.gz
    chown -R 1654:1654 '$CONFIG_DIR' 2>/dev/null || true
    ls -la '$CONFIG_DIR/' | head -20
  " || die "Extract failed."
  # Update compose with production env vars
  log "Updating docker-compose env on $host ($role)..."
  run_root "$host" "
    cat > /tmp/compose-patch.py << 'PYEOF'
 import re, sys
 f = sys.argv[1]
 with open(f) as fh: c = fh.read()
 # Ensure DNS_SERVER_DOMAIN and web service env vars are set
 if 'DNS_SERVER_DOMAIN' not in c:
    c = re.sub(r'(image:.*\n)', r'\1    environment:\n      - DNS_SERVER_DOMAIN=knel.net\n', c, count=1)
 print(c)
 PYEOF
    python3 /tmp/compose-patch.py '$COMPOSE_FILE' > '${COMPOSE_FILE}.new' 2>/dev/null && mv '${COMPOSE_FILE}.new' '$COMPOSE_FILE' || true
    rm -f /tmp/compose-patch.py
  " || log "WARN: compose patch skipped (non-critical)."
  log "Starting Technitium on $host..."
  run_root "$host" "cd $CONFIG_DIR/.. && docker compose up -d" 2>/dev/null \
    || run_root "$host" "docker start tsys-dns" || die "Start failed."
  log "Waiting for Technitium to come up on $host..."
  local i
  for i in $(seq 1 20); do
    if run "$host" "curl -sk --max-time 3 http://127.0.0.1:5380/api/config/getVersion 2>/dev/null | head -c 50" 2>/dev/null | grep -qE 'token|error'; then
      log "Technitium is up on $host (after ${i}s)."
      return 0
    fi
    sleep 2
  done
  die "Technitium did not come up on $host within 40s."
 }
 # -----------------------------------------------------------------------------
 # Step 4: Configure clustering
 #
 # On PRIMARY (01): enable zone transfer for SECONDARY's IP on all zones.
 # On SECONDARY (02): replace all primary zones with secondary zones pointing
 #   to PRIMARY's address. Uses a temporary admin (no 2FA) for API access,
 #   then restores the production auth.config.
 # -----------------------------------------------------------------------------
 do_cluster() {
  log "=== STEP 4: Configuring clustering ($PRIMARY → $SECONDARY) ==="
  # --- 4a: On PRIMARY, enable zone transfer (for manual AXFR if needed) ---
  log "4a: Enabling zone transfer on $PRIMARY..."
  _with_temp_admin "$PRIMARY" "_cluster_enable_transfer"
  log "Zone transfers enabled on primary."
  # --- 4b: Install rsync-based zone replication on SECONDARY ---
  log "4b: Installing rsync-based zone replication on $SECONDARY..."
  _install_rsync_replication
  log "Replication installed."
 }
 # Install rsync-based zone sync on the secondary as a systemd timer.
 _install_rsync_replication() {
  local sync_script="$HERE/sync-zones.sh"
  [ -f "$sync_script" ] || die "sync-zones.sh not found."
  # Upload the sync script (copy to /tmp first, then move as root since
  # the services dir may be root-owned from docker operations)
  bash "$REMOTE" "$SECONDARY-copy" "$sync_script" "/tmp/sync-zones.sh" \
    || die "Could not copy sync-zones.sh to /tmp."
  run_root "$SECONDARY" "cp /tmp/sync-zones.sh /home/localuser/services/technitium/sync-zones.sh && chmod +x /home/localuser/services/technitium/sync-zones.sh && chown localuser:localuser /home/localuser/services/technitium/sync-zones.sh && rm /tmp/sync-zones.sh" \
    || die "Could not install sync-zones.sh."
  # Set up SSH key for rsync from secondary → primary (passwordless)
  log "Setting up SSH key for rsync (secondary → primary)..."
  run_root "$SECONDARY" "
    if [ ! -f /home/localuser/.ssh/id_ed25519 ]; then
      sudo -u localuser ssh-keygen -t ed25519 -N '' -f /home/localuser/.ssh/id_ed25519 -q
    fi
    cat /home/localuser/.ssh/id_ed25519.pub
  " 2>/dev/null | grep -E 'ssh-ed25519' | while read -r pubkey; do
    log "Adding secondary's SSH key to primary's authorized_keys..."
    run_root "$PRIMARY" "mkdir -p /home/localuser/.ssh && echo '$pubkey' >> /home/localuser/.ssh/authorized_keys && chmod 600 /home/localuser/.ssh/authorized_keys" \
      2>/dev/null || log "WARN: could not add key to primary"
  done
  # Install systemd timer for periodic sync
  run_root "$SECONDARY" "
    cat > /etc/systemd/system/technitium-zone-sync.service << 'SVCEOF'
 [Unit]
 Description=Technitium Zone Sync (primary → secondary)
 After=network-online.target
 [Service]
 Type=oneshot
 User=localuser
 ExecStart=/home/localuser/services/technitium/sync-zones.sh
 SVCEOF
    cat > /etc/systemd/system/technitium-zone-sync.timer << 'TMREOF'
 [Unit]
 Description=Run Technitium Zone Sync every minute
 [Timer]
 OnBootSec=30
 OnUnitActiveSec=60
 AccuracySec=10
 [Install]
 WantedBy=timers.target
 TMREOF
    systemctl daemon-reload
    systemctl enable --now technitium-zone-sync.timer
    echo 'timer installed'
  " 2>/dev/null || die "Could not install systemd timer."
  # Trigger an immediate sync
  log "Triggering initial sync..."
  run_root "$SECONDARY" "sudo -u localuser /home/localuser/services/technitium/sync-zones.sh 2>&1" 2>/dev/null || true
  sleep 3
  # Check result
  local zones
  zones=$(run_root "$SECONDARY" "ls /home/localuser/services/technitium/config/zones/ 2>/dev/null | wc -l" 2>/dev/null | tr -d '[:space:]')
  log "Secondary now has $zones zones."
 }
 # Enable zone transfer for the secondary IP on all primary zones.
 # Runs inside _with_temp_admin, so $1 = host.
 _cluster_enable_transfer() {
  local host="$1"
  local token; token="$(get_token "$host")"
  [ -n "$token" ] || die "Cannot get API token on $host."
  # Set global zone transfer allow list to include the secondary.
  # Technitium per-zone "allow zone transfer" — use the API to set it.
  local zone
  while IFS= read -r zone <&3; do
    [ -z "$zone" ] && continue
    # Set zone transfer to AllowAnyone so the secondary can AXFR.
    # Technitium API param: zoneTransfer (not allowZoneTransfer).
    api_call "$host" "$token" "zones/options/set" \
      "zone=$zone" "zoneTransfer=Allow" \
      >/dev/null 2>&1 || true
  done 3< "$WORK_DIR/zones.txt"
  log "Zone transfer set to AllowAnyone for ${SECONDARY_IP} on all zones."
 }
 # Delete all primary zones and recreate as secondary zones.
 # Runs inside _with_temp_admin, so $1 = host.
 _cluster_make_secondary() {
  local host="$1"
  local token; token="$(get_token "$host")"
  [ -n "$token" ] || die "Cannot get API token on $host."
  local zone total
  total=$(wc -l < "$WORK_DIR/zones.txt")
  local n=0
  # Use FD 3 so SSH (called by api_call/run_root) doesn't consume the loop's
  # stdin (a classic bash pitfall: ssh inherits and reads from FD 0).
  while IFS= read -r zone <&3; do
    [ -z "$zone" ] && continue
    n=$((n + 1))
    # Delete the existing (primary) zone
    api_call "$host" "$token" "zones/delete" "zone=$zone" >/dev/null 2>&1 || true
    # Create as secondary zone pointing to primary
    api_call "$host" "$token" "zones/create" \
      "zone=$zone" "type=Secondary" "primaryServer=${PRIMARY_IP}%3A${TECH_PORT}" \
      >/dev/null 2>&1 || true
    [ $((n % 20)) -eq 0 ] && log "  ...converted $n/$total zones"
  done 3< "$WORK_DIR/zones.txt"
  log "Converted $n zones to secondary (AXFR from ${PRIMARY_IP}:${TECH_PORT})."
  # Give Technitium a moment to AXFR
  log "Waiting 10s for initial zone transfer..."
  sleep 10
 }
 # Helper: temporarily replace auth.config with a fresh admin (no 2FA),
 # run a function, then restore the original auth.config.
 # Uses a docker-compose.override.yml (auto-merged by compose) so the original
 # compose file is never modified.
 # Usage: _with_temp_admin <host> <function_name>
 _with_temp_admin() {
  local host="$1" func="$2"
  log "Temporarily resetting admin on $host for API access (will restore after)..."
  local svc_dir; svc_dir="$(dirname "$CONFIG_DIR")"
  # Stop the container FIRST (otherwise it recreates auth.config from memory
  # before we can delete it), then back up + delete auth.config, then create
  # the override file, then restart.
  log "Stopping Technitium on $host..."
  run_root "$host" "cd '$svc_dir' && docker compose down 2>/dev/null || docker stop tsys-dns 2>/dev/null || true" \
    || die "Could not stop Technitium on $host."
  # Back up production auth.config, then remove it so Technitium creates a
  # fresh admin on next start.
  run_root "$host" "
    cp '$CONFIG_DIR/auth.config' '$CONFIG_DIR/auth.config.production'
    rm -f '$CONFIG_DIR/auth.config'
  " || die "Could not back up/remove auth.config on $host."
  # Create a compose override that injects the temp admin password.
  run_root "$host" "
    printf 'services:\\n  technitium:\\n    environment:\\n      - DNS_SERVER_ADMIN_PASSWORD=${TEMP_ADMIN_PW}\\n' \
      > '$svc_dir/docker-compose.override.yml'
  " || die "Could not create compose override on $host."
  # Restart with override in effect
  run_root "$host" "cd '$svc_dir' && docker compose up -d" \
    2>/dev/null || die "Could not restart with temp admin on $host."
  # Wait for API to come up (check with root to avoid PATH issues)
  local i
  for i in $(seq 1 20); do
    if run_root "$host" "curl -sk --max-time 3 http://127.0.0.1:5380/api/config/getVersion 2>/dev/null" 2>/dev/null | grep -q .; then
      log "Temp admin API is up on $host."
      # Give the auth subsystem a few seconds to finish creating the admin user.
      sleep 5
      break
    fi
    sleep 2
  done
  # Debug: show what login returns
  local login_resp
  login_resp=$(run_root "$host" "curl -sk --max-time 10 -X POST http://127.0.0.1:5380/api/user/login -d 'user=admin&pass=${TEMP_ADMIN_PW}'" 2>/dev/null || true)
  log "Login response: $(echo "$login_resp" | head -c 200)"
  # Run the configuration function
  "$func" "$host" || die "Configuration function $func failed on $host."
  # Restore: production auth.config + remove override + restart
  log "Restoring production auth.config (with 2FA) on $host..."
  run_root "$host" "
    cd '$svc_dir'
    docker compose down 2>/dev/null || true
    cp '$CONFIG_DIR/auth.config.production' '$CONFIG_DIR/auth.config'
    rm -f '$CONFIG_DIR/auth.config.production'
    chown 1654:1654 '$CONFIG_DIR/auth.config' 2>/dev/null || true
    rm -f docker-compose.override.yml
    docker compose up -d 2>/dev/null || true
  " || die "Could not restore auth.config on $host."
  sleep 3
  log "Production auth restored on $host."
 }
 # -----------------------------------------------------------------------------
 # Step 5: Verify
 # -----------------------------------------------------------------------------
 do_verify() {
  log "=== STEP 5: Verification ==="
  bash "$HERE/verify.sh"
 }
 # -----------------------------------------------------------------------------
 # Dispatch
 # -----------------------------------------------------------------------------
 subcmd="${1:-}"
 case "$subcmd" in
  export)    do_export ;;
  deploy01)  do_deploy_primary ;;
  deploy02)  do_deploy_secondary ;;
  cluster)   do_cluster ;;
  verify)    do_verify ;;
  all)
    do_export
    do_deploy_primary
    do_deploy_secondary
    do_cluster
    do_verify
    ;;
  ""|-h|--help|help)
    sed -n '2,60p' "${BASH_SOURCE[0]}" >&2
    exit 0
    ;;
  *) die "Unknown command '$subcmd'. Run '$0 help'." ;;
 esac
 log "=== DONE: $subcmd ==="
@@ -0,0 +1,43 @@
 #!/usr/bin/bash
 #
 # sync-zones.sh — rsync-based zone replication from primary to secondary
 #
 # Runs on the SECONDARY (netinfra-02). Syncs the zones/ directory from the
 # primary (netinfra-01) every 60 seconds. When a zone file changes, Technitium
 # detects the modification and reloads automatically.
 #
 # This is used instead of AXFR-based zone transfer because Technitium's zone
 # transfer mechanism uses port 53 (standard DNS), but on the netinfra hosts
 # port 53 is Pi-hole and Technitium is on port 5300. rsync-based replication
 # avoids the port conflict entirely.
 #
 # Install as a systemd service/timer or run via cron:
 #   * * * * * /home/localuser/services/technitium/sync-zones.sh
 #
 set -uo pipefail
 PRIMARY_HOST="${PRIMARY_HOST:-pfv-netinfra-01.knel.net}"
 CONFIG_DIR="${CONFIG_DIR:-/home/localuser/services/technitium/config}"
 ZONE_DIR="$CONFIG_DIR/zones"
 LOCK_FILE="/tmp/technitium-zone-sync.lock"
 LOG_FILE="${LOG_FILE:-/home/localuser/services/technitium/sync.log}"
 log() { printf '[%s] %s\n' "$(date +%H:%M:%S)" "$*" >> "$LOG_FILE"; }
 # Prevent overlapping runs
 exec 9>"$LOCK_FILE" || exit 0
 flock -n 9 || { log "another sync is running; skipping"; exit 0; }
 mkdir -p "$ZONE_DIR"
 # rsync zones from primary. Use --temp-dir to avoid partial writes being
 # picked up by Technitium, and --delete to remove zones deleted on primary.
 log "Syncing zones from $PRIMARY_HOST..."
 if rsync -az --delete --temp-dir=/tmp \
   "${PRIMARY_HOST}:$ZONE_DIR/" "$ZONE_DIR/" >> "$LOG_FILE" 2>&1; then
  zone_count=$(ls "$ZONE_DIR" | wc -l)
  log "Sync complete: $zone_count zones"
 else
  log "ERROR: rsync failed (rc=$?)"
  exit 1
 fi
@@ -0,0 +1,204 @@
 #!/usr/bin/bash
 #
 # verify.sh — Comprehensive Technitium DNS Cluster Verification
 #
 # Tests that the primary/secondary DNS cluster is correctly configured and
 # functioning: zones present on both servers, zone transfers working, records
 # resolve identically, failover works, and credentials are replicated.
 #
 set -uo pipefail
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REMOTE="$HERE/remote-dns.sh"
 PRIMARY="netinfra01"
 SECONDARY="netinfra02"
 PROD="tsrouter"
 PRIMARY_IP="${PRIMARY_IP:-192.168.3.252}"
 SECONDARY_IP="${SECONDARY_IP:-192.168.3.253}"
 TECH_PORT="${TECH_PORT:-5300}"
 PASS=0; FAIL=0; WARN=0
 ok()   { echo "✅ $*"; PASS=$((PASS+1)); }
 fail() { echo "❌ $*"; FAIL=$((FAIL+1)); }
 warn() { echo "⚠️  $*"; WARN=$((WARN+1)); }
 section() { echo ""; echo "=== $* ==="; }
 run()      { bash "$REMOTE" "$1" "${@:2}"; }
 run_root() { bash "$REMOTE" "$1-root" "${@:2}"; }
 # =============================================================================
 section "1. Container health on both nodes"
 for h in "$PRIMARY" "$SECONDARY"; do
  status=$(run_root "$h" "docker ps --format '{{.Status}}' tsys-dns 2>/dev/null" | head -1)
  if echo "$status" | grep -qi 'Up'; then
    ok "Technitium container running on $h ($status)"
  else
    fail "Technitium container NOT running on $h (status: ${status:-none})"
  fi
 done
 # =============================================================================
 section "2. Technitium API responds on both nodes"
 for h in "$PRIMARY" "$SECONDARY"; do
  resp=$(run "$h" "curl -sk --max-time 5 http://127.0.0.1:5380/api/config/getVersion 2>/dev/null" || true)
  if echo "$resp" | grep -qE 'token|error|invalid'; then
    ok "API responds on $h"
  else
    fail "API not responding on $h"
  fi
 done
 # =============================================================================
 section "3. Zone count matches between primary and production"
 # Count zones from the container on each host
 count_zones() {
  local host="$1"
  run_root "$host" "docker exec tsys-dns sh -c 'ls /etc/dns/zones/ 2>/dev/null | wc -l'" 2>/dev/null | tr -d '[:space:]'
 }
 prod_zones=$(count_zones "$PROD")
 pri_zones=$(count_zones "$PRIMARY")
 sec_zones=$(count_zones "$SECONDARY")
 echo "  Production zones: $prod_zones"
 echo "  Primary (01) zones: $pri_zones"
 echo "  Secondary (02) zones: $sec_zones"
 [ "$prod_zones" -gt 0 ] 2>/dev/null && ok "Production has $prod_zones zones" || fail "Production zone count invalid"
 [ "$pri_zones" -gt 0 ] 2>/dev/null && ok "Primary has $pri_zones zones" || fail "Primary zone count invalid"
 [ "$sec_zones" -gt 0 ] 2>/dev/null && ok "Secondary has $sec_zones zones" || fail "Secondary zone count invalid"
 if [ "$pri_zones" = "$prod_zones" ]; then
  ok "Primary zone count matches production ($pri_zones)"
 else
  warn "Primary zone count ($pri_zones) differs from production ($prod_zones)"
 fi
 if [ "$sec_zones" = "$pri_zones" ]; then
  ok "Secondary zone count matches primary ($sec_zones)"
 else
  warn "Secondary zone count ($sec_zones) differs from primary ($pri_zones) — may still be transferring"
 fi
 # =============================================================================
 section "4. knel.net zone resolves identically on primary and secondary"
 # Query a known record on both servers directly via Technitium's port
 for name in pfv-netinfra-01 pfv-netinfra-02 tailscale-router tsys-cloudron tsys-nsm; do
  fqdn="${name}.knel.net"
  # Query via dig against each Technitium instance (through Pi-hole on :53)
  pri_ans=$(run "$PRIMARY" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 $fqdn A 2>/dev/null | head -1" 2>/dev/null || true)
  sec_ans=$(run "$SECONDARY" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 $fqdn A 2>/dev/null | head -1" 2>/dev/null || true)
  if [ -n "$pri_ans" ] && [ "$pri_ans" = "$sec_ans" ]; then
    ok "$fqdn resolves identically: $pri_ans"
  elif [ -n "$pri_ans" ] && [ -z "$sec_ans" ]; then
    warn "$fqdn: primary=$pri_ans secondary=<no answer> (may still be syncing)"
  elif [ -z "$pri_ans" ] && [ -z "$sec_ans" ]; then
    warn "$fqdn: no answer on either server"
  else
    fail "$fqdn MISMATCH: primary=$pri_ans secondary=$sec_ans"
  fi
 done
 # =============================================================================
 section "5. External DNS resolution works on both nodes"
 for h in "$PRIMARY" "$SECONDARY"; do
  ans=$(run "$h" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 github.com A 2>/dev/null | head -1" 2>/dev/null || true)
  if [ -n "$ans" ]; then
    ok "$h resolves github.com → $ans"
  else
    fail "$h cannot resolve github.com"
  fi
 done
 # =============================================================================
 section "6. Zone transfer (AXFR) from primary to secondary"
 # Test AXFR of knel.net from the primary
 axfr=$(run "$SECONDARY" "dig +short +time=5 +tries=1 @${PRIMARY_IP} -p ${TECH_PORT} knel.net AXFR 2>/dev/null | wc -l" 2>/dev/null || echo "0")
 if [ "$axfr" -gt 1 ] 2>/dev/null; then
  ok "AXFR of knel.net from primary succeeds ($axfr records transferred)"
 else
  warn "AXFR test returned $axfr records — zone transfer may be restricted or in progress"
 fi
 # =============================================================================
 section "7. Reverse DNS works"
 # Pick a known reverse zone and test PTR resolution
 ptr_test="181.103.100.in-addr.arpa"
 ptr_ans=$(run "$PRIMARY" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 $ptr_test SOA 2>/dev/null | head -1" 2>/dev/null || true)
 if [ -n "$ptr_ans" ]; then
  ok "Reverse zone $ptr_test has SOA on primary"
 else
  warn "Reverse zone $ptr_test: no SOA on primary"
 fi
 ptr_ans2=$(run "$SECONDARY" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 $ptr_test SOA 2>/dev/null | head -1" 2>/dev/null || true)
 if [ -n "$ptr_ans2" ]; then
  ok "Reverse zone $ptr_test has SOA on secondary"
 else
  warn "Reverse zone $ptr_test: no SOA on secondary"
 fi
 # =============================================================================
 section "8. Production untouched (read-only verification)"
 # Verify production container is still running and unchanged
 prod_status=$(run_root "$PROD" "docker ps --format '{{.Status}}' tsys-dns 2>/dev/null" | head -1)
 if echo "$prod_status" | grep -qi 'Up'; then
  ok "Production container still running on $PROD ($prod_status)"
 else
  fail "Production container NOT running on $PROD!"
 fi
 prod_zones_after=$(count_zones "$PROD")
 if [ "$prod_zones_after" = "$prod_zones" ]; then
  ok "Production zone count unchanged ($prod_zones_after = $prod_zones before)"
 else
  fail "Production zone count CHANGED: $prod_zones → $prod_zones_after"
 fi
 # =============================================================================
 section "9. Failover test"
 # Take the approach of querying via the secondary when primary is slow/unavailable.
 # We test that the secondary answers independently.
 sec_soa=$(run "$SECONDARY" "dig +short +time=3 +tries=1 @127.0.0.1 -p 53 knel.net SOA 2>/dev/null | head -1" 2>/dev/null || true)
 if [ -n "$sec_soa" ]; then
  ok "Secondary independently serves knel.net SOA: $sec_soa"
 else
  fail "Secondary cannot serve knel.net SOA independently"
 fi
 # =============================================================================
 section "10. Credentials check — auth.config size matches production"
 prod_auth_size=$(run_root "$PROD" "docker exec tsys-dns wc -c < /etc/dns/auth.config 2>/dev/null" | tr -d '[:space:]')
 pri_auth_size=$(run_root "$PRIMARY" "docker exec tsys-dns wc -c < /etc/dns/auth.config 2>/dev/null" | tr -d '[:space:]')
 sec_auth_size=$(run_root "$SECONDARY" "docker exec tsys-dns wc -c < /etc/dns/auth.config 2>/dev/null" | tr -d '[:space:]')
 echo "  auth.config sizes — prod=$prod_auth_size pri=$pri_auth_size sec=$sec_auth_size"
 if [ "$prod_auth_size" = "$pri_auth_size" ] && [ "$prod_auth_size" = "$sec_auth_size" ]; then
  ok "auth.config identical size across all three nodes (credentials + 2FA replicated)"
 else
  fail "auth.config sizes differ — credentials may not be replicated correctly"
 fi
 # =============================================================================
 # Summary
 echo ""
 echo "=========================================="
 echo "  PASSED: $PASS"
 echo "  FAILED: $FAIL"
 echo "  WARNED: $WARN"
 echo "=========================================="
 [ "$FAIL" -eq 0 ] && exit 0 || exit 1
@@ -0,0 +1,139 @@
 # AI Review: KNELServerBuild (FetchApply) Project
 ## Executive Summary
 The KNELServerBuild project is a comprehensive Infrastructure-as-Code (IaC) solution designed for provisioning Linux servers within the TSYS Group environment. The project implements a fetch-and-apply framework that automates the setup and hardening of server systems, incorporating security, monitoring, and operational components.
 ## Project Overview
 The FetchApply project is a shell-based automation framework that provisions Linux servers with:
 - Security hardening (SSH, 2FA, Wazuh, STIG compliance)
 - Operational monitoring (LibreNMS, cockpit, SNMP)
 - System packages and configurations for enterprise operations
 - Network discovery and management capabilities
 ## Architecture and Structure
 ### Key Components
 - **ProjectCode/**: Main setup and configuration scripts
 - **Project-ConfigFiles/**: Configuration variables and parameters
 - **Project-Includes/**: Reusable shell functions and utilities
 - **Project-Tests/**: Comprehensive testing framework
 - **Modules/**: Functional modules for security, operations, etc.
 - **vendor/**: External dependencies and frameworks
 ### Core Workflow
 The `SetupNewSystem.sh` orchestrates:
 1. Preflight checks and environment validation
 2. Package installation and system updates
 3. Service configuration and hardening
 4. Security implementation (SSH, Wazuh, 2FA)
 5. Operational monitoring setup
 ## Strengths
 ### 1. Comprehensive Testing Framework
 - Well-structured testing with unit, integration, security, and validation categories
 - Clear documentation and usage instructions
 - JSON reporting for CI/CD integration
 ### 2. Security-First Approach
 - Multiple layers of security hardening (SSH, 2FA, audit agents)
 - STIG compliance for government/hybrid environments
 - Proper permission management and configuration validation
 ### 3. Modular Architecture
 - Separated concerns into functional modules
 - Reusable functions and components
 - Clear separation between framework and project-specific code
 ### 4. Operational Readiness
 - Built-in monitoring and alerting
 - System performance optimization
 - Network discovery and management tools
 ### 5. Cross-Platform Considerations
 - Detection for different hardware types (physical, virtual, Raspberry Pi)
 - Distribution-specific handling
 - Environment-aware configurations
 ## Areas for Improvement
 ### 1. Documentation Completeness
 - README mentions usage but lacks detailed architecture overview
 - Missing troubleshooting and recovery procedures
 - Limited guidance for extending/adding new modules
 ### 2. Security and Secrets Management
 - Configuration files may expose hardcoded credentials or tokens
 - No clear secrets management strategy
 - Download URLs and endpoints are hardcoded in scripts
 ### 3. Error Handling and Resilience
 - While scripts have basic error handling, recovery mechanisms are limited
 - No rollback capabilities for failed installations
 - Some operations may fail silently
 ### 4. Scalability and Performance
 - Scripts execute sequentially without parallelization
 - No caching mechanisms for downloads
 - Limited handling for high-latency networks
 ### 5. Configuration Management
 - Configuration values scattered across multiple files
 - No centralized configuration management
 - Difficult to customize for different environments
 ## Recommendations
 ### 1. Enhance Security Practices
 - Implement secrets management (HashiCorp Vault, AWS Secrets Manager, etc.)
 - Add configuration validation before applying changes
 - Implement digital signature verification for downloaded content
 - Add security scanning of packages before installation
 ### 2. Improve Testing Coverage
 - Add end-to-end tests for complete deployment scenarios
 - Implement performance benchmarks
 - Add security validation tests
 - Include tests for different hardware configurations
 ### 3. Add Monitoring and Observability
 - Implement deployment success/failure metrics
 - Add progress tracking for long-running operations
 - Include health checks post-deployment
 - Add rollback mechanisms for failed deployments
 ### 4. Refactor for Maintainability
 - Centralize configuration management
 - Abstract environment-specific variables
 - Implement plugin architecture for new modules
 - Add proper logging and audit trails
 ### 5. Enhance Usability
 - Add dry-run functionality for testing changes
 - Provide rollback/recovery procedures
 - Add interactive mode for new users
 - Implement configuration templates
 ## Technical Debt Assessment
 ### High Priority
 - Centralized configuration management
 - Secrets handling and security
 - Error recovery and rollback mechanisms
 ### Medium Priority
 - Parallel execution of independent operations
 - Caching for downloaded packages/configs
 - Improved logging and monitoring
 ### Low Priority
 - Code modernization (consider newer shell features)
 - Migration to configuration management tools (Ansible/Terraform)
 ## Conclusion
 The FetchApply project represents a solid foundation for automated server provisioning with good security practices and testing. However, there are significant opportunities to improve security, maintainability, and operational resilience. Prioritizing security improvements and configuration management would provide the greatest value to the project's stability and long-term viability.
 The modular architecture and comprehensive testing framework provide a strong foundation for future enhancements and improvements.
@@ -0,0 +1,44 @@
 # AI Overview of KNELServerBuild
 This is an AI-generated overview of the KNELServerBuild project. The analysis is based on a read-only review of the project's files.
 ## Project Overview
 The KNELServerBuild project is an Infrastructure as Code (IAC) repository for provisioning and configuring Linux servers. It is based on a collection of bash scripts that automate the installation of packages, configuration of services, and security hardening of the system. The project is designed to be used with the `FetchApply` tool, which is not included in this repository.
 The main entry point of the project is the `ProjectCode/SetupNewSystem.sh` script. This script performs the following actions:
 *   **Initializes the environment:** Sets up project paths and sources a shell framework (`KNELShellFramework`) and project-specific includes.
 *   **Installs packages:** Installs a wide range of packages, including monitoring agents (check_mk, snmp), security tools (auditd, aide, lynis, clamav), administration tools (cockpit, webmin), and common utilities (tmux, vim, zsh).
 *   **Configures services:** Configures various services like Postfix for email, `rsyslog` for system logging, `snmpd` for monitoring, `lldpd` for network discovery, and `cockpit`.
 *   **Security Hardening:** It runs a series of security hardening scripts from `Modules/Security`, including `secharden-ssh.sh`, `secharden-wazuh.sh`, `secharden-2fa.sh`, and `secharden-scap-stig.sh`.
 *   **OAM:** It runs an OAM (Operations, Administration, and Maintenance) script for LibreNMS.
 *   **Conditional Logic:** It has conditional logic to apply different configurations based on whether the host is a physical Dell server, a virtual machine (KVM or Hyper-V), or a Raspberry Pi.
 ## What I Like
 *   **Well-structured:** The project is well-structured, with separate directories for code, configuration files, documentation, and tests. This makes it easy to understand and maintain.
 *   **Modularity:** The use of modules for different functionalities (e.g., security hardening, OAM) is a good practice. It allows for easy extension and modification of the project.
 *   **Comprehensive:** The project covers a wide range of aspects of server provisioning, from package installation to security hardening.
 *   **Conditional Logic:** The use of conditional logic to adapt the configuration to different environments is a good feature.
 *   **Good commenting:** The scripts are generally well-commented, which makes them easier to understand.
 ## Areas for Improvement
 *   **Error Handling:** The scripts could benefit from more robust error handling. For example, the `SetupNewSystem.sh` script uses `set -e` to exit on error, but it does not have any specific error handling logic.
 *   **Idempotency:** The scripts are not fully idempotent. For example, some of the `curl` commands will re-download files even if they already exist. This could be improved by adding checks to see if the files already exist.
 *   **Testing:** The project has a `Project-Tests` directory, but it is not clear how the tests are run or what they cover. The testing framework could be improved to provide more comprehensive coverage of the project's functionality.
 *   **Secrets Management:** The scripts contain some hardcoded secrets, such as the `relayhost` for Postfix. These secrets should be managed using a secrets management tool like HashiCorp Vault or AWS Secrets Manager.
 *   **Configuration Management:** The project uses a collection of shell scripts to manage the configuration of the system. While this works, it can be difficult to manage and maintain in the long run. A configuration management tool like Ansible, Puppet, or Chef would be a better choice for this task. The project already installs `ansible-core`, so it would be a natural progression to move the logic to Ansible playbooks.
 *   **Documentation:** The project has some documentation, but it could be improved. For example, the `README.md` file could provide more information on how to use the project and how to contribute to it.
 ## Recommendations
 *   **Improve Error Handling:** Add more robust error handling to the scripts to make them more reliable.
 *   **Improve Idempotency:** Make the scripts more idempotent to avoid unnecessary re-downloads and re-configurations.
 *   **Improve Testing:** Implement a more comprehensive testing framework to ensure the quality of the project.
 *   **Use a Secrets Management Tool:** Use a secrets management tool to manage the secrets in the project.
 *   **Use a Configuration Management Tool:** Use a configuration management tool like Ansible to manage the configuration of the system.
 *   **Improve Documentation:** Improve the documentation of the project to make it easier to use and contribute to.
 Overall, the KNELServerBuild project is a good starting point for an IAC repository. It is well-structured and covers a wide range of aspects of server provisioning. However, there are some areas where it could be improved. By addressing the areas for improvement, the project can be made more robust, reliable, and maintainable.
@@ -0,0 +1,308 @@
 # AI Overview: KNEL Server Build (FetchApply) Project
 **Date:** December 26, 2025  
 **Reviewer:** OpenCode AI Assistant  
 **Project:** TSYS Infrastructure Provisioning System  
 ## Executive Summary
 The KNEL Server Build project is a comprehensive Infrastructure as Code (IaC) system for Linux server provisioning and security hardening. It demonstrates strong architectural patterns with a modular framework approach but has several areas requiring improvement for production readiness, security, and maintainability.
 ## Architecture Assessment
 ### Strengths ✅
 **1. Modular Framework Design**
 - Well-structured KNELShellFramework with centralized includes
 - Clear separation between framework, project code, and configuration
 - Consistent pattern for sourcing framework components
 - Proper abstraction of common functionality
 **2. Comprehensive Security Modules**
 - Extensive security hardening capabilities (SSH, Wazuh, 2FA, SCAP/STIG)
 - HTTPS enforcement throughout
 - Proper audit logging integration
 - Good compliance focus with industry standards
 **3. Testing Infrastructure**
 - Automated test suite with multiple categories (unit, integration, security, validation)
 - JSON-based test reporting
 - Good test organization and coverage
 **4. Documentation Excellence**
 - Comprehensive deployment guide with troubleshooting
 - Detailed development guidelines with best practices
 - Security documentation with threat model
 - Code review findings and refactoring examples
 ### Areas for Improvement ⚠️
 **1. Performance Issues**
 - Multiple separate package installation commands instead of consolidated approach
 - Individual file downloads causing network overhead
 - No connection pooling for multiple downloads from same host
 **2. Security Vulnerabilities**
 - SSH keys stored in git repository (secrets management needed)
 - No download integrity verification (checksum validation)
 - Missing comprehensive input validation
 - Unquoted variable expansions creating injection risks
 **3. Error Handling Gaps**
 - Network operations lack timeout and retry logic
 - Inconsistent error handling across modules
 - Missing graceful failure handling in critical paths
 ## Technical Debt Analysis
 ### High Priority Issues
 **1. Package Installation Performance**
 ```bash
 # Current inefficient pattern in SetupNewSystem.sh
 apt-get -y install git sudo dmidecode curl  # Line 27
 # Later: separate massive apt-get command
 ```
 **Impact:** 30-40% slower deployments, multiple package cache updates
 **2. Network Resilience**
 ```bash
 # Vulnerable pattern throughout codebase
 curl --silent ${DL_ROOT}/path/file >/etc/config
 ```
 **Impact:** Deployment failures in poor network conditions, no recovery mechanism
 **3. Variable Quoting Security**
 ```bash
 # Risky pattern
 chsh -s $(which zsh) root
 ```
 **Impact:** Potential command injection vulnerabilities
 ### Medium Priority Issues
 **1. Framework Consistency**
 - Not all modules follow established error handling patterns
 - Inconsistent logging and progress reporting
 - Mixed coding standards across different components
 **2. Testing Coverage**
 - Limited integration testing for complex workflows
 - Missing performance benchmarking tests
 - No automated regression testing for configuration changes
 ## Recommendations
 ### Immediate Actions (Week 1-2)
 **1. Implement Safe Download Framework**
 ```bash
 # Create centralized download function with:
 # - Connection timeouts (30s)
 # - Retry logic (3 attempts)
 # - Checksum validation
 # - Error recovery
 ```
 **2. Consolidate Package Management**
 ```bash
 # Single package installation with logical grouping:
 # - Core system tools
 # - Security packages  
 # - Monitoring tools
 # - Development utilities
 ```
 **3. Fix Variable Quoting**
 - Audit entire codebase for unquoted variables
 - Implement static analysis check in CI pipeline
 - Add input validation framework
 ### Medium-term Improvements (Month 1-2)
 **1. Secrets Management**
 - Remove SSH keys from repository
 - Integrate Bitwarden/Vault for secret storage
 - Implement key rotation procedures
 **2. Performance Optimization**
 - Implement batch download operations
 - Add connection pooling
 - Create deployment metrics collection
 **3. Enhanced Testing**
 - Add performance benchmarking
 - Implement chaos engineering for network failures
 - Create automated regression testing
 ### Long-term Enhancements (Quarter 1)
 **1. Infrastructure Improvements**
 - Implement configuration backup/restore
 - Add rollback capability for failed deployments
 - Create deployment pipeline with staging environments
 **2. Advanced Security**
 - Implement supply chain security with SBOM
 - Add automated vulnerability scanning
 - Create security compliance reporting
 ## Code Quality Assessment
 ### Positive Patterns
 - Good function documentation in recent code
 - Proper error handling in newer modules
 - Consistent use of framework logging functions
 - Clear separation of concerns
 ### Problem Patterns
 - Mixed coding styles across files
 - Inconsistent framework usage
 - Missing input validation
 - Hardcoded configuration values
 ### Modernization Opportunities
 **1. Containerization**
 - Consider Docker-based deployment testing
 - Create immutable infrastructure patterns
 - Implement blue-green deployments
 **2. Configuration Management**
 - Move to declarative configuration approach
 - Implement configuration drift detection
 - Add automated compliance checking
 **3. Observability**
 - Implement comprehensive logging with structured formats
 - Add metrics collection for deployment performance
 - Create dashboard for system health monitoring
 ## Security Posture Review
 ### Current Strengths
 - HTTPS-only downloads
 - Good SSH hardening practices
 - Comprehensive audit logging
 - Regular security scanning integration
 ### Critical Gaps
 - No integrity verification for downloads
 - Secrets stored in version control
 - Limited defense in depth
 - Missing automated security testing
 ### Recommended Security Enhancements
 **1. Supply Chain Security**
 - Implement checksum validation for all downloads
 - Add GPG signature verification where available
 - Create SBOM generation for deployments
 **2. Access Control**
 - Implement role-based access control
 - Add privileged access management
 - Create audit trail for all administrative actions
 **3. Continuous Security**
 - Integrate automated vulnerability scanning
 - Implement security testing in CI/CD
 - Create security metrics dashboard
 ## Deployment Readiness Assessment
 ### Current State: **70% Production Ready**
 **Ready Components:**
 - Core provisioning functionality
 - Security hardening modules
 - Basic testing framework
 - Documentation
 **Missing Components:**
 - Robust error handling
 - Performance optimization
 - Secrets management
 - Comprehensive testing
 ### Path to Production Readiness
 **Phase 1 (2 weeks):** Critical fixes and performance optimization
 **Phase 2 (4 weeks):** Security enhancements and testing improvements
 **Phase 3 (8 weeks):** Advanced features and production hardening
 ## Overall Assessment
 ### What I Like 🎯
 **1. Architectural Excellence**
 - The KNELShellFramework shows mature thinking about code organization
 - Modular approach allows for easy maintenance and extension
 - Clear separation of concerns between framework and project code
 **2. Security-First Mindset**
 - Comprehensive security hardening capabilities
 - Good threat awareness and mitigation strategies
 - Integration with industry-standard security tools
 **3. Documentation Quality**
 - Excellent documentation with practical examples
 - Clear deployment guides with troubleshooting sections
 - Good development guidelines for team consistency
 ### What I Don't Like 🚫
 **1. Performance Oversights**
 - Multiple package installations causing unnecessary delays
 - Individual file downloads creating network overhead
 - No performance metrics or monitoring
 **2. Security Gaps**
 - Critical vulnerability with secrets in git repository
 - No download integrity verification
 - Missing comprehensive input validation
 **3. Code Quality Issues**
 - Inconsistent error handling across modules
 - Variable quoting creating security risks
 - Mixed coding standards throughout codebase
 ### Improvement Potential 📈
 **1. Immediate Impact (High ROI)**
 - Package installation consolidation: 30-40% performance improvement
 - Safe download framework: 90% reduction in network-related failures
 - Variable quoting fixes: Eliminate security vulnerabilities
 **2. Medium-term Benefits**
 - Secrets management: Eliminate critical security risks
 - Performance optimization: Better user experience
 - Enhanced testing: Higher reliability and confidence
 **3. Long-term Value**
 - Containerization: Modern deployment patterns
 - Observability: Better operational insight
 - Automation: Reduced manual overhead
 ## Final Recommendation
 The KNEL Server Build project demonstrates solid architectural foundations and comprehensive security capabilities. With focused improvements in performance optimization, security hardening (particularly secrets management), and error handling, this system can become a production-grade infrastructure provisioning solution.
 **Priority:**
 1. **Immediate:** Fix security vulnerabilities and performance bottlenecks
 2. **Short-term:** Enhance testing and error handling
 3. **Long-term:** Implement advanced features and modernization
 **Investment Justification:** The project shows strong potential with a clear path to production readiness. The modular architecture and comprehensive security focus make it a valuable foundation for enterprise infrastructure automation.
 ---
 **Next Steps:**
 1. Create implementation roadmap for critical fixes
 2. Establish performance benchmarks
 3. Implement continuous integration with quality gates
 4. Plan phased rollout to production environments
 **Risk Level:** Medium - manageable with proper remediation plan
 **Business Value:** High - significant time savings and security improvements
 **Technical Debt:** Moderate - requires systematic but achievable refactoring
@@ -0,0 +1,27 @@
 # AI Security Audit of KNELServerBuild
 This is an AI-generated security audit of the KNELServerBuild project. The analysis is based on a read-only review of the project's files.
 ## Summary of Findings
 The KNELServerBuild project has a good security posture overall, but there are a few areas that could be improved. The most significant finding is the presence of SSH authorized keys in the repository. This is a security risk, as it allows anyone with access to the repository to know which public keys are authorized to access the servers.
 ### High-Risk Findings
 *   **SSH Authorized Keys in Repository:** The `ProjectCode/ConfigFiles/SSH/AuthorizedKeys` directory contains SSH authorized keys for the `localuser` and `root` users. This is a security risk, as it allows anyone with access to the repository to know which public keys are authorized to access the servers.
 ### Medium-Risk Findings
 *   **Hardcoded Hostnames:** The scripts contain several hardcoded hostnames for services like Postfix, NTP, syslog, and Wazuh. This is not a direct security risk, but it does represent a configuration management issue. If any of these hostnames change, they will need to be updated in multiple places.
 ### Low-Risk Findings
 *   **Potential for Password on Command Line:** The `ProjectCode/Agents/librenms/mysql.sh` script has a `--pass` argument for a MySQL password. This is a potential security risk if the password is provided on the command line, as it could be logged in the shell history.
 ## Recommendations
 *   **Remove SSH Authorized Keys from Repository:** The SSH authorized keys should be removed from the repository and managed using a secrets management tool like HashiCorp Vault or AWS Secrets Manager.
 *   **Use Variables for Hostnames:** The hardcoded hostnames should be replaced with variables that are defined in a central configuration file. This will make it easier to update the hostnames if they change.
 *   **Avoid Passwords on Command Line:** The `ProjectCode/Agents/librenms/mysql.sh` script should be modified to avoid passing the MySQL password on the command line. For example, the script could prompt the user for the password or read it from a configuration file.
 Overall, the KNELServerBuild project is a good starting point for an IAC repository. By addressing the security risks identified in this audit, the project can be made more secure and reliable.
@@ -0,0 +1,279 @@
 # TSYS FetchApply Code Review Findings
 **Review Date:** July 14, 2025  
 **Reviewer:** Claude (Anthropic)  
 **Repository:** TSYS Group Infrastructure Provisioning Scripts
 ## Executive Summary
 The repository shows good architectural structure with centralized framework components, but has several performance, security, and maintainability issues that require attention. The codebase is functional but needs optimization for production reliability.
 ## Critical Issues (High Priority)
 ### 1. Package Installation Performance ⚠️
 **Location:** `ProjectCode/SetupNewSystem.sh:27` and `Lines 117-183`
 **Issue:** Multiple separate package installation commands causing performance bottlenecks
 ```bash
 # Current inefficient pattern
 apt-get -y install git sudo dmidecode curl
 # ... later in script ...
 DEBIAN_FRONTEND="noninteractive" apt-get -qq --yes install virt-what auditd ...
 ```
 **Impact:** Significantly slower deployment, multiple package cache updates
 **Fix:** Combine all package installations into single command
 ### 2. Network Operations Lack Error Handling 🔴
 **Location:** `ProjectCode/SetupNewSystem.sh:61-63`, multiple modules
 **Issue:** curl commands without timeout or error handling
 ```bash
 # Vulnerable pattern
 curl --silent ${DL_ROOT}/path/file >/etc/config
 ```
 **Impact:** Deployment failures in poor network conditions
 **Fix:** Add timeout, error handling, and retry logic
 ### 3. Unquoted Variable Expansions 🔴
 **Location:** Multiple files, including `ProjectCode/SetupNewSystem.sh:244`
 **Issue:** Variables used without proper quoting creating security risks
 ```bash
 # Risky pattern
 chsh -s $(which zsh) root
 ```
 **Impact:** Potential command injection, script failures
 **Fix:** Quote all variable expansions consistently
 ## Security Concerns
 ### 4. No Download Integrity Verification 🔴
 **Issue:** All remote downloads lack checksum verification
 **Impact:** Supply chain attack vulnerability
 **Recommendation:** Implement SHA256 checksum validation
 ### 5. Excessive Root Privilege Usage ⚠️
 **Issue:** All operations run as root without privilege separation
 **Impact:** Unnecessary security exposure
 **Recommendation:** Delegate non-privileged operations when possible
 ## Performance Optimization Opportunities
 ### 6. Individual File Downloads 🟡
 **Location:** `ProjectCode/Modules/Security/secharden-scap-stig.sh:66-77`
 **Issue:** 12+ individual curl commands for config files
 ```bash
 curl --silent ${DL_ROOT}/path1 > /etc/file1
 curl --silent ${DL_ROOT}/path2 > /etc/file2
 # ... repeated 12+ times
 ```
 **Impact:** Network overhead, slower deployment
 **Fix:** Batch download operations
 ### 7. Missing Connection Pooling ⚠️
 **Issue:** No connection reuse for multiple downloads from same host
 **Impact:** Unnecessary connection overhead
 **Fix:** Use curl with connection reuse or wget with keep-alive
 ## Code Quality Issues
 ### 8. Inconsistent Framework Usage 🟡
 **Issue:** Not all modules use established error handling framework
 **Impact:** Inconsistent error reporting, debugging difficulties
 **Fix:** Standardize framework usage across all modules
 ### 9. Incomplete Function Implementations 🟡
 **Location:** `Framework-Includes/LookupKv.sh`
 **Issue:** Stubbed functions with no implementation
 **Impact:** Technical debt, confusion
 **Fix:** Implement or remove unused functions
 ### 10. Missing Input Validation 🟡
 **Location:** `Project-Includes/pi-detect.sh`
 **Issue:** Functions lack proper input validation and quoting
 **Impact:** Potential script failures
 **Fix:** Add comprehensive input validation
 ## Recommended Immediate Actions
 ### Phase 1: Critical Fixes (Week 1)
 1. **Fix variable quoting** throughout codebase
 2. **Add error handling** to all network operations
 3. **Combine package installations** for performance
 4. **Implement download integrity verification**
 ### Phase 2: Performance Optimization (Week 2)
 1. **Batch file download operations**
 2. **Add connection timeouts and retries**
 3. **Implement bulk configuration deployment**
 4. **Optimize service restart procedures**
 ### Phase 3: Code Quality (Week 3-4)
 1. **Standardize framework usage**
 2. **Add comprehensive input validation**
 3. **Implement proper logging with timestamps**
 4. **Remove or complete stubbed functions**
 ## Specific Code Improvements
 ### Enhanced Error Handling Pattern
 ```bash
 function safe_download() {
    local url="$1"
    local dest="$2"
    local max_attempts=3
    local attempt=1
    while [[ $attempt -le $max_attempts ]]; do
        if curl --silent --connect-timeout 30 --max-time 60 --fail "$url" > "$dest"; then
            print_success "Downloaded: $(basename "$dest")"
            return 0
        else
            print_warning "Download attempt $attempt failed: $url"
            ((attempt++))
            sleep 5
        fi
    done
    print_error "Failed to download after $max_attempts attempts: $url"
    return 1
 }
 ```
 ### Bulk Package Installation Pattern
 ```bash
 function install_all_packages() {
    print_info "Installing all required packages..."
    local packages=(
        # Core system packages
        git sudo dmidecode curl wget
        # Security packages
        auditd fail2ban aide
        # Monitoring packages
        snmpd snmp-mibs-downloader
        # Additional packages
        virt-what net-tools htop
    )
    if DEBIAN_FRONTEND="noninteractive" apt-get -qq --yes -o Dpkg::Options::="--force-confold" install "${packages[@]}"; then
        print_success "All packages installed successfully"
    else
        print_error "Package installation failed"
        return 1
    fi
 }
 ```
 ### Batch Configuration Download
 ```bash
 function download_configurations() {
    print_info "Downloading configuration files..."
    local -A configs=(
        ["${DL_ROOT}/ProjectCode/ConfigFiles/ZSH/tsys-zshrc"]="/etc/zshrc"
        ["${DL_ROOT}/ProjectCode/ConfigFiles/SMTP/aliases"]="/etc/aliases"
        ["${DL_ROOT}/ProjectCode/ConfigFiles/Syslog/rsyslog.conf"]="/etc/rsyslog.conf"
    )
    for url in "${!configs[@]}"; do
        local dest="${configs[$url]}"
        if ! safe_download "$url" "$dest"; then
            return 1
        fi
    done
    print_success "All configurations downloaded"
 }
 ```
 ## Testing Recommendations
 ### Add Performance Tests
 ```bash
 function test_package_installation_performance() {
    local start_time=$(date +%s)
    install_all_packages
    local end_time=$(date +%s)
    local duration=$((end_time - start_time))
    echo "✅ Package installation completed in ${duration}s"
    if [[ $duration -gt 300 ]]; then
        echo "⚠️  Installation took longer than expected (>5 minutes)"
    fi
 }
 ```
 ### Add Network Resilience Tests
 ```bash
 function test_network_error_handling() {
    # Test with invalid URL
    if safe_download "https://invalid.example.com/file" "/tmp/test"; then
        echo "❌ Error handling test failed - should have failed"
        return 1
    else
        echo "✅ Error handling test passed"
        return 0
    fi
 }
 ```
 ## Monitoring and Metrics
 ### Deployment Performance Metrics
 - **Package installation time:** Should complete in <5 minutes
 - **Configuration download time:** Should complete in <2 minutes
 - **Service restart time:** Should complete in <30 seconds
 - **Total deployment time:** Should complete in <15 minutes
 ### Error Rate Monitoring
 - **Network operation failures:** Should be <1%
 - **Package installation failures:** Should be <0.1%
 - **Service restart failures:** Should be <0.1%
 ## Compliance Assessment
 ### Development Guidelines Adherence
 ✅ **Good:** Single package commands in newer modules  
 ✅ **Good:** Framework integration patterns  
 ✅ **Good:** Function documentation in recent code  
 ❌ **Needs Work:** Variable quoting consistency  
 ❌ **Needs Work:** Error handling standardization  
 ❌ **Needs Work:** Input validation coverage  
 ## Risk Assessment
 **Current Risk Level:** Medium
 **Key Risks:**
 1. **Deployment failures** due to network issues
 2. **Security vulnerabilities** from unvalidated downloads
 3. **Performance issues** in production deployments
 4. **Maintenance challenges** from code inconsistencies
 **Mitigation Priority:**
 1. Network error handling (High)
 2. Download integrity verification (High)
 3. Performance optimization (Medium)
 4. Code standardization (Medium)
 ## Conclusion
 The TSYS FetchApply repository has a solid foundation but requires systematic improvements to meet production reliability standards. The recommended fixes will significantly enhance:
 - **Deployment reliability** through better error handling
 - **Security posture** through integrity verification
 - **Performance** through optimized operations
 - **Maintainability** through code standardization
 Implementing these improvements in the suggested phases will create a robust, production-ready infrastructure provisioning system.
 ---
 **Next Steps:**
 1. Review and prioritize findings with development team
 2. Create implementation plan for critical fixes
 3. Establish testing procedures for improvements
 4. Set up monitoring for deployment metrics
@@ -0,0 +1,93 @@
 # Claude Code Review - TSYS FetchApply Infrastructure
 **Review Date:** July 14, 2025 (Updated)  
 **Reviewed by:** Claude (Anthropic)  
 **Repository:** TSYS Group Infrastructure Provisioning Scripts  
 **Previous Review:** July 12, 2025  
 ## Project Overview
 This repository contains infrastructure-as-code for provisioning Linux servers in the TSYS Group environment. The codebase includes 32 shell scripts (~2,800 lines) organized into a modular framework for system hardening, security configuration, and operational tooling deployment.
 ## Strengths ✅
 ### Security Hardening
 - **SSH Security:** Comprehensive SSH hardening with key-only authentication, disabled password login, and secure cipher configurations
 - **Security Agents:** Automated deployment of Wazuh SIEM agents, audit tools, and SCAP-STIG compliance checking
 - **File Permissions:** Proper restrictive permissions (400 for SSH keys, 644 for configs)
 - **Network Security:** Firewall configuration, network discovery tools (LLDP), and monitoring agents
 ### Code Quality
 - **Error Handling:** Robust bash strict mode implementation (`set -euo pipefail`) with custom error trapping and line number reporting
 - **Modular Design:** Well-organized structure separating framework components, configuration files, and functional modules
 - **Environment Awareness:** Intelligent detection of physical vs virtual hosts, distribution-specific logic, and hardware-specific optimizations
 - **Logging:** Centralized logging with timestamp-based log files and colored output for debugging
 ### Operational Excellence
 - **Package Management:** Automated repository setup for security tools (Lynis, Webmin, Tailscale, Wazuh)
 - **System Tuning:** Performance optimizations for physical hosts, virtualization-aware configurations
 - **Monitoring Integration:** LibreNMS agents, SNMP configuration, and system metrics collection
 ## Security Concerns ⚠️
 ### Critical Issues
 1. **~~Insecure Deployment Method~~** ✅ **RESOLVED:** Now uses `git clone` + local script execution instead of `curl | bash`
 2. **No Integrity Verification:** Downloaded scripts lack checksum validation or cryptographic signatures
 3. **~~HTTP Downloads~~** ✅ **RESOLVED:** All HTTP URLs converted to HTTPS (Dell OMSA, Proxmox, Apache sources)
 ### Moderate Risks
 4. **Exposed SSH Keys:** Public SSH keys committed directly to repository without rotation mechanism
 5. **Hard-coded Credentials:** Server hostnames and domain names embedded in scripts
 6. **Missing Secrets Management:** No current implementation of Bitwarden/Vault integration (noted in TODO comments)
 ## Improvement Recommendations 🔧
 ### High Priority (Security Critical)
 1. **~~Secure Deployment Pipeline~~** ✅ **RESOLVED:** Now uses git clone-based deployment
 2. **~~HTTPS Enforcement~~** ✅ **RESOLVED:** All HTTP downloads converted to HTTPS
 3. **Script Integrity:** Implement SHA256 checksum verification for all downloaded components
 4. **Secrets Management:** Deploy proper secrets handling for SSH keys and sensitive configurations
 ### Medium Priority (Operational)
 5. **Testing Framework:** Add integration tests for provisioning workflows
 6. **Documentation Enhancement:** Expand security considerations and deployment procedures
 7. **Configuration Validation:** Add pre-deployment validation of system requirements
 8. **Rollback Capability:** Implement configuration backup and rollback mechanisms
 ### Low Priority (Quality of Life)
 9. **Error Recovery:** Enhanced error recovery and partial deployment resumption
 10. **Monitoring Integration:** Centralized logging and deployment status reporting
 11. **User Interface:** Consider web-based deployment dashboard for non-technical users
 ## Risk Assessment 📊
 **Overall Risk Level:** Low-Medium ⬇️ (Reduced from Medium-Low)
 The repository contains well-architected defensive security tools with strong error handling and modular design. **Major security improvement:** The insecure `curl | bash` deployment method has been replaced with git-based deployment. Remaining concerns are primarily around hardening the provisioning scripts themselves rather than the deployment method.
 **Recommendation:** Continue addressing remaining security issues (HTTPS enforcement, secrets management) but the critical deployment risk has been mitigated. The codebase is much safer for production use.
 ## Update Summary (July 14, 2025)
 **✅ Resolved Issues:**
 - Insecure deployment method replaced with git clone approach
 - README.md updated with project management and community links
 - Deployment security risk significantly reduced
 - All HTTP URLs converted to HTTPS (Dell OMSA, Proxmox, Apache sources)
 **🔄 Remaining Priorities:**
 1. ~~HTTPS enforcement for internal downloads~~ ✅ **RESOLVED:** All HTTP URLs converted to HTTPS
 2. Secrets management implementation
 3. Script integrity verification
 4. SSH key rotation from repository
 ## Files Reviewed
 - 32 shell scripts across Framework-Includes, Project-Includes, and ProjectCode directories
 - Configuration files for SSH, SNMP, logging, and system services
 - Security modules for hardening, authentication, and monitoring
 - Documentation and framework configuration files
 ## Next Steps
 See `charles-todo.md` and `claude-todo.md` for detailed action items prioritized for human operators and AI assistants respectively.
@@ -0,0 +1,336 @@
 # TSYS FetchApply Deployment Guide
 ## Overview
 This guide provides comprehensive instructions for deploying the TSYS FetchApply infrastructure provisioning system on Linux servers.
 ## Prerequisites
 ### System Requirements
 - **Operating System:** Ubuntu 18.04+ or Debian 10+ (recommended)
 - **RAM:** Minimum 2GB, recommended 4GB
 - **Disk Space:** Minimum 10GB free space
 - **Network:** Internet connectivity for package downloads
 - **Privileges:** Root or sudo access required
 ### Required Tools
 - `git` - Version control system
 - `curl` - HTTP client for downloads
 - `wget` - Alternative download tool
 - `systemctl` - System service management
 - `apt-get` - Package management (Debian/Ubuntu)
 ### Network Requirements
 - **HTTPS access** to:
  - `https://archive.ubuntu.com` (Ubuntu packages)
  - `https://linux.dell.com` (Dell hardware support)
  - `https://download.proxmox.com` (Proxmox packages)
  - `https://github.com` (Git repositories)
 ## Pre-Deployment Validation
 ### 1. System Compatibility Check
 ```bash
 # Clone repository
 git clone [repository-url]
 cd FetchApply
 # Run system validation
 ./Project-Tests/validation/system-requirements.sh
 ```
 ### 2. Network Connectivity Test
 ```bash
 # Test network connectivity
 curl -I https://archive.ubuntu.com
 curl -I https://linux.dell.com
 curl -I https://download.proxmox.com
 ```
 ### 3. Permission Verification
 ```bash
 # Verify write permissions
 test -w /etc && echo "✅ /etc writable" || echo "❌ /etc not writable"
 test -w /usr/local/bin && echo "✅ /usr/local/bin writable" || echo "❌ /usr/local/bin not writable"
 ```
 ## Deployment Methods
 ### Method 1: Standard Deployment (Recommended)
 ```bash
 # 1. Clone repository
 git clone [repository-url]
 cd FetchApply
 # 2. Run pre-deployment tests
 ./Project-Tests/run-tests.sh validation
 # 3. Execute deployment
 cd ProjectCode
 sudo bash SetupNewSystem.sh
 ```
 ### Method 2: Dry Run Mode
 ```bash
 # 1. Clone repository
 git clone [repository-url]
 cd FetchApply
 # 2. Review configuration
 cat ProjectCode/SetupNewSystem.sh
 # 3. Execute with manual review
 cd ProjectCode
 sudo bash -x SetupNewSystem.sh  # Debug mode
 ```
 ## Deployment Process
 ### Phase 1: Framework Initialization
 1. **Environment Setup**
   - Load framework variables
   - Source framework includes
   - Initialize logging system
 2. **System Detection**
   - Detect physical vs virtual hardware
   - Identify operating system
   - Check for existing users
 ### Phase 2: Base System Configuration
 1. **Package Installation**
   - Update package repositories
   - Install essential packages
   - Configure package sources
 2. **User Management**
   - Create required user accounts
   - Configure SSH access
   - Set up sudo permissions
 ### Phase 3: Security Hardening
 1. **SSH Configuration**
   - Deploy hardened SSH configuration
   - Install SSH keys
   - Disable password authentication
 2. **System Hardening**
   - Configure firewall rules
   - Enable audit logging
   - Install security tools
 ### Phase 4: Monitoring and Management
 1. **Monitoring Agents**
   - Deploy LibreNMS agents
   - Configure SNMP
   - Set up system monitoring
 2. **Management Tools**
   - Install Cockpit dashboard
   - Configure remote access
   - Set up maintenance scripts
 ## Post-Deployment Verification
 ### 1. Security Validation
 ```bash
 # Run security tests
 ./Project-Tests/run-tests.sh security
 # Verify SSH configuration
 ssh -T [server-ip]  # Should work with key authentication
 ```
 ### 2. Service Status Check
 ```bash
 # Check critical services
 sudo systemctl status ssh
 sudo systemctl status auditd
 sudo systemctl status snmpd
 ```
 ### 3. Network Connectivity
 ```bash
 # Test internal services
 curl -k https://localhost:9090  # Cockpit
 snmpwalk -v2c -c public localhost system
 ```
 ## Troubleshooting
 ### Common Issues
 #### 1. Permission Denied Errors
 ```bash
 # Solution: Run with sudo
 sudo bash SetupNewSystem.sh
 ```
 #### 2. Network Connectivity Issues
 ```bash
 # Check DNS resolution
 nslookup archive.ubuntu.com
 # Test direct IP access
 curl -I 91.189.91.26  # Ubuntu archive IP
 ```
 #### 3. Package Installation Failures
 ```bash
 # Update package cache
 sudo apt-get update
 # Fix broken packages
 sudo apt-get -f install
 ```
 #### 4. SSH Key Issues
 ```bash
 # Verify key permissions
 ls -la ~/.ssh/
 chmod 600 ~/.ssh/id_rsa
 chmod 644 ~/.ssh/id_rsa.pub
 ```
 ### Debug Mode
 ```bash
 # Enable debug logging
 export DEBUG=1
 bash -x SetupNewSystem.sh
 ```
 ### Log Analysis
 ```bash
 # Check deployment logs
 tail -f /var/log/fetchapply/deployment.log
 # Review system logs
 journalctl -u ssh
 journalctl -u auditd
 ```
 ## Environment-Specific Configurations
 ### Physical Dell Servers
 - **OMSA Installation:** Dell OpenManage Server Administrator
 - **Hardware Monitoring:** iDRAC configuration
 - **Performance Tuning:** CPU and memory optimizations
 ### Virtual Machines
 - **Guest Additions:** VMware tools or VirtualBox additions
 - **Resource Limits:** Memory and CPU constraints
 - **Network Configuration:** Bridge vs NAT settings
 ### Development Environments
 - **SSH Configuration:** Less restrictive settings
 - **Development Tools:** Additional packages for development
 - **Testing Access:** Enhanced logging and debugging
 ## Maintenance and Updates
 ### Regular Maintenance
 ```bash
 # Update system packages
 sudo apt-get update && sudo apt-get upgrade
 # Update monitoring scripts
 cd /usr/local/bin
 sudo wget https://[repository]/scripts/up2date.sh
 sudo chmod +x up2date.sh
 ```
 ### Security Updates
 ```bash
 # Check for security updates
 sudo apt-get update
 sudo apt list --upgradable | grep -i security
 # Apply security patches
 sudo apt-get upgrade
 ```
 ### Configuration Updates
 ```bash
 # Update FetchApply
 cd FetchApply
 git pull origin main
 # Re-run specific modules
 cd ProjectCode/Modules/Security
 sudo bash secharden-ssh.sh
 ```
 ## Best Practices
 ### 1. Pre-Deployment
 - Always test in non-production environment first
 - Review all scripts before execution
 - Validate network connectivity
 - Ensure proper backup procedures
 ### 2. During Deployment
 - Monitor deployment progress
 - Check for errors and warnings
 - Document any customizations
 - Validate each phase completion
 ### 3. Post-Deployment
 - Run full security test suite
 - Verify all services are running
 - Test remote access
 - Document deployment specifics
 ### 4. Ongoing Operations
 - Regular security updates
 - Monitor system performance
 - Review audit logs
 - Maintain deployment documentation
 ## Support and Resources
 ### Documentation
 - **README.md:** Basic usage instructions
 - **SECURITY.md:** Security architecture and guidelines
 - **Project-Tests/README.md:** Testing framework documentation
 ### Community Support
 - **Issues:** https://projects.knownelement.com/project/reachableceo-vptechnicaloperations/timeline
 - **Discussion:** https://community.turnsys.com/c/chieftechnologyandproductofficer/26
 ### Professional Support
 - **Technical Support:** [Contact information to be added]
 - **Consulting Services:** [Contact information to be added]
 ## Deployment Checklist
 ### Pre-Deployment
 - [ ] System requirements validated
 - [ ] Network connectivity tested
 - [ ] Backup procedures in place
 - [ ] Security review completed
 ### Deployment
 - [ ] Repository cloned successfully
 - [ ] Pre-deployment tests passed
 - [ ] Deployment executed without errors
 - [ ] Post-deployment verification completed
 ### Post-Deployment
 - [ ] Security tests passed
 - [ ] All services running
 - [ ] Remote access verified
 - [ ] Documentation updated
 ### Maintenance
 - [ ] Update schedule established
 - [ ] Monitoring configured
 - [ ] Backup procedures tested
 - [ ] Incident response plan activated
 ## Version History
 - **v1.0:** Initial deployment framework
 - **v1.1:** Added security hardening and secrets management
 - **v1.2:** Enhanced testing framework and documentation
 Last updated: July 14, 2025
@@ -0,0 +1,406 @@
 # TSYS FetchApply Development Guidelines
 ## Overview
 This document contains development standards and best practices for the TSYS FetchApply infrastructure provisioning system.
 ## Package Management Best Practices
 ### Combine apt-get Install Commands
 **Rule:** Always combine multiple package installations into a single `apt-get install` command for performance.
 **Rationale:** Single command execution is significantly faster than multiple separate commands due to:
 - Reduced package cache processing
 - Single dependency resolution
 - Fewer network connections
 - Optimized package download ordering
 #### ✅ Correct Implementation
 ```bash
 # Install all packages in one command
 apt-get install -y package1 package2 package3 package4
 # Real example from 2FA script
 apt-get install -y libpam-google-authenticator qrencode
 ```
 #### ❌ Incorrect Implementation
 ```bash
 # Don't use separate commands for each package
 apt-get install -y package1
 apt-get install -y package2
 apt-get install -y package3
 ```
 #### Complex Package Installation Pattern
 ```bash
 function install_security_packages() {
    print_info "Installing security packages..."
    # Update package cache once
    apt-get update
    # Install all packages in single command
    apt-get install -y \
        auditd \
        fail2ban \
        libpam-google-authenticator \
        lynis \
        rkhunter \
        aide \
        chkrootkit \
        clamav \
        clamav-daemon
    print_success "Security packages installed successfully"
 }
 ```
 ## Script Development Standards
 ### Error Handling
 - Always use `set -euo pipefail` at script start
 - Implement proper error trapping
 - Use framework error handling functions
 - Return appropriate exit codes
 ### Function Structure
 ```bash
 function function_name() {
    print_info "Description of what function does..."
    # Local variables
    local var1="value"
    local var2="value"
    # Function logic
    if [[ condition ]]; then
        print_success "Success message"
        return 0
    else
        print_error "Error message"
        return 1
    fi
 }
 ```
 ### Framework Integration
 - Source framework includes at script start
 - Use framework logging and pretty print functions
 - Follow existing patterns for consistency
 - Include proper PROJECT_ROOT path resolution
 ```bash
 # Standard framework sourcing pattern
 PROJECT_ROOT="$(dirname "$(realpath "${BASH_SOURCE[0]}")")/../.."
 source "$PROJECT_ROOT/Framework-Includes/PrettyPrint.sh"
 source "$PROJECT_ROOT/Framework-Includes/Logging.sh"
 source "$PROJECT_ROOT/Framework-Includes/ErrorHandling.sh"
 ```
 ## Code Quality Standards
 ### ShellCheck Compliance
 - All scripts must pass shellcheck validation
 - Address shellcheck warnings appropriately
 - Use proper quoting for variables
 - Handle edge cases and error conditions
 ### Variable Naming
 - Use UPPERCASE for global constants
 - Use lowercase for local variables
 - Use descriptive names
 - Quote all variable expansions
 ```bash
 # Global constants
 declare -g BACKUP_DIR="/root/backup"
 declare -g CONFIG_FILE="/etc/ssh/sshd_config"
 # Local variables
 local user_name="localuser"
 local temp_file="/tmp/config.tmp"
 # Proper quoting
 if [[ -f "$CONFIG_FILE" ]]; then
    cp "$CONFIG_FILE" "$BACKUP_DIR/"
 fi
 ```
 ### Function Documentation
 - Include purpose description
 - Document parameters if any
 - Document return values
 - Include usage examples for complex functions
 ```bash
 # Configure SSH hardening settings
 # Parameters: none
 # Returns: 0 on success, 1 on failure
 # Usage: configure_ssh_hardening
 function configure_ssh_hardening() {
    print_info "Configuring SSH hardening..."
    # Implementation
 }
 ```
 ## Testing Requirements
 ### Test Coverage
 - Every new module must include corresponding tests
 - Test both success and failure scenarios
 - Validate configurations after changes
 - Include integration tests for complex workflows
 ### Test Categories
 1. **Unit Tests:** Individual function validation
 2. **Integration Tests:** Module interaction testing
 3. **Security Tests:** Security configuration validation
 4. **Validation Tests:** System requirement checking
 ### Test Implementation Pattern
 ```bash
 function test_function_name() {
    echo "🔍 Testing specific functionality..."
    local failed=0
    # Test implementation
    if [[ condition ]]; then
        echo "✅ Test passed"
    else
        echo "❌ Test failed"
        ((failed++))
    fi
    return $failed
 }
 ```
 ## Security Standards
 ### Configuration Backup
 - Always backup configurations before modification
 - Use timestamped backup directories
 - Provide restore instructions
 - Test backup/restore procedures
 ### Service Management
 - Test configurations before restarting services
 - Provide rollback procedures
 - Validate service status after changes
 - Include service dependency handling
 ### User Safety
 - Use `nullok` for gradual 2FA rollout
 - Provide clear setup instructions
 - Include emergency access procedures
 - Test all access methods before enforcement
 ## Documentation Standards
 ### Script Headers
 ```bash
 #!/bin/bash
 # TSYS Module Name - Brief Description
 # Longer description of what this script does
 # Author: TSYS Development Team
 # Version: 1.0
 # Last Updated: YYYY-MM-DD
 set -euo pipefail
 ```
 ### Inline Documentation
 - Comment complex logic
 - Explain non-obvious decisions
 - Document external dependencies
 - Include troubleshooting notes
 ### User Documentation
 - Create comprehensive guides for complex features
 - Include step-by-step procedures
 - Provide troubleshooting sections
 - Include examples and use cases
 ## Performance Optimization
 ### Package Management
 - Single apt-get commands (as noted above)
 - Cache package lists appropriately
 - Use specific package versions when stability required
 - Clean up package cache when appropriate
 ### Network Operations
 - Use connection timeouts for external requests
 - Implement retry logic with backoff
 - Cache downloaded resources when possible
 - Validate download integrity
 ### File Operations
 - Use efficient file processing tools
 - Minimize file system operations
 - Use appropriate file permissions
 - Clean up temporary files
 ## Version Control Practices
 ### Commit Messages
 - Use descriptive commit messages
 - Include scope of changes
 - Reference related issues/requirements
 - Follow established commit message format
 ### Branch Management
 - Test changes in feature branches
 - Use pull requests for review
 - Maintain clean commit history
 - Tag releases appropriately
 ### Code Review Requirements
 - All changes require review
 - Security changes require security team review
 - Test coverage must be maintained
 - Documentation must be updated
 ## Deployment Practices
 ### Pre-Deployment
 - Run full test suite
 - Validate in test environment
 - Review security implications
 - Update documentation
 ### Deployment Process
 - Use configuration validation
 - Implement gradual rollout when possible
 - Monitor for issues during deployment
 - Have rollback procedures ready
 ### Post-Deployment
 - Validate deployment success
 - Monitor system performance
 - Update operational documentation
 - Gather feedback for improvements
 ## Example Implementation
 ### Complete Module Template
 ```bash
 #!/bin/bash
 # TSYS Security Module - Template
 # Template for creating new security modules
 # Author: TSYS Development Team
 set -euo pipefail
 # Source framework functions
 PROJECT_ROOT="$(dirname "$(realpath "${BASH_SOURCE[0]}")")/../.."
 source "$PROJECT_ROOT/Framework-Includes/PrettyPrint.sh"
 source "$PROJECT_ROOT/Framework-Includes/Logging.sh"
 source "$PROJECT_ROOT/Framework-Includes/ErrorHandling.sh"
 # Module configuration
 BACKUP_DIR="/root/backup/module-$(date +%Y%m%d-%H%M%S)"
 CONFIG_FILE="/etc/example.conf"
 # Create backup directory
 mkdir -p "$BACKUP_DIR"
 print_header "TSYS Module Template"
 function backup_configs() {
    print_info "Creating configuration backup..."
    if [[ -f "$CONFIG_FILE" ]]; then
        cp "$CONFIG_FILE" "$BACKUP_DIR/"
        print_success "Configuration backed up"
    fi
 }
 function install_packages() {
    print_info "Installing required packages..."
    # Update package cache
    apt-get update
    # Install all packages in single command
    apt-get install -y package1 package2 package3
    print_success "Packages installed successfully"
 }
 function configure_module() {
    print_info "Configuring module..."
    # Configuration logic here
    print_success "Module configured successfully"
 }
 function validate_configuration() {
    print_info "Validating configuration..."
    local failed=0
    # Validation logic here
    if [[ $failed -eq 0 ]]; then
        print_success "Configuration validation passed"
        return 0
    else
        print_error "Configuration validation failed"
        return 1
    fi
 }
 function main() {
    # Check if running as root
    if [[ $EUID -ne 0 ]]; then
        print_error "This script must be run as root"
        exit 1
    fi
    # Execute module steps
    backup_configs
    install_packages
    configure_module
    validate_configuration
    print_success "Module setup completed successfully!"
 }
 # Run main function
 main "$@"
 ```
 ## Continuous Improvement
 ### Regular Reviews
 - Review guidelines quarterly
 - Update based on lessons learned
 - Incorporate new best practices
 - Gather team feedback
 ### Tool Updates
 - Keep development tools current
 - Adopt new security practices
 - Update testing frameworks
 - Improve automation
 ### Knowledge Sharing
 - Document lessons learned
 - Share best practices
 - Provide training materials
 - Maintain knowledge base
 ---
 **Last Updated:** July 14, 2025  
 **Version:** 1.0  
 **Author:** TSYS Development Team
 **Note:** These guidelines are living documents and should be updated as the project evolves and new best practices are identified.
@@ -0,0 +1,534 @@
 # Code Refactoring Examples
 This document provides specific examples of how to apply the code review findings to improve performance, security, and reliability.
 ## Package Installation Optimization
 ### Before (Current - Multiple Commands)
 ```bash
 # Line 27 in SetupNewSystem.sh
 apt-get -y install git sudo dmidecode curl
 # Lines 117-183 (later in script)
 DEBIAN_FRONTEND="noninteractive" apt-get -qq --yes -o Dpkg::Options::="--force-confold" install \
  virt-what \
  auditd \
  aide \
  # ... many more packages
 ```
 ### After (Optimized - Single Command)
 ```bash
 function install_all_packages() {
    print_info "Installing all required packages..."
    # All packages in logical groups for better readability
    local packages=(
        # Core system tools
        git sudo dmidecode curl wget net-tools htop
        # Security and auditing
        auditd aide fail2ban lynis rkhunter
        # Monitoring and SNMP
        snmpd snmp-mibs-downloader libsnmp-dev
        # Virtualization detection
        virt-what
        # System utilities
        rsyslog logrotate ntp ntpdate
        cockpit cockpit-ws cockpit-system
        # Development and debugging
        build-essential dkms
        # Network services
        openssh-server ufw
    )
    # Single package installation command with retry logic
    local max_attempts=3
    local attempt=1
    while [[ $attempt -le $max_attempts ]]; do
        if DEBIAN_FRONTEND="noninteractive" apt-get -qq --yes -o Dpkg::Options::="--force-confold" install "${packages[@]}"; then
            print_success "All packages installed successfully"
            return 0
        else
            print_warning "Package installation attempt $attempt failed"
            if [[ $attempt -lt $max_attempts ]]; then
                print_info "Retrying in 10 seconds..."
                sleep 10
                apt-get update  # Refresh package cache before retry
            fi
            ((attempt++))
        fi
    done
    print_error "Package installation failed after $max_attempts attempts"
    return 1
 }
 ```
 ## Safe Download Implementation
 ### Before (Current - Unsafe Downloads)
 ```bash
 # Lines 61-63 in SetupNewSystem.sh
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/ZSH/tsys-zshrc >/etc/zshrc
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/SMTP/aliases >/etc/aliases
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/Syslog/rsyslog.conf >/etc/rsyslog.conf
 ```
 ### After (Safe Downloads with Error Handling)
 ```bash
 function download_system_configs() {
    print_info "Downloading system configuration files..."
    # Source the safe download framework
    source "$PROJECT_ROOT/Framework-Includes/SafeDownload.sh"
    # Define configuration downloads with checksums (optional)
    declare -A config_downloads=(
        ["${DL_ROOT}/ProjectCode/ConfigFiles/ZSH/tsys-zshrc"]="/etc/zshrc"
        ["${DL_ROOT}/ProjectCode/ConfigFiles/SMTP/aliases"]="/etc/aliases"
        ["${DL_ROOT}/ProjectCode/ConfigFiles/Syslog/rsyslog.conf"]="/etc/rsyslog.conf"
        ["${DL_ROOT}/ProjectCode/ConfigFiles/SSH/Configs/tsys-sshd-config"]="/etc/ssh/sshd_config.tsys"
    )
    # Validate all URLs are accessible before starting
    local urls=()
    for url in "${!config_downloads[@]}"; do
        urls+=("$url")
    done
    if ! validate_required_urls "${urls[@]}"; then
        print_error "Some configuration URLs are not accessible"
        return 1
    fi
    # Perform batch download with backup
    local failed_downloads=0
    for url in "${!config_downloads[@]}"; do
        local dest="${config_downloads[$url]}"
        if ! safe_config_download "$url" "$dest"; then
            ((failed_downloads++))
        fi
    done
    if [[ $failed_downloads -eq 0 ]]; then
        print_success "All configuration files downloaded successfully"
        return 0
    else
        print_error "$failed_downloads configuration downloads failed"
        return 1
    fi
 }
 ```
 ## Variable Quoting Fixes
 ### Before (Unsafe Variable Usage)
 ```bash
 # Line 244 in SetupNewSystem.sh
 chsh -s $(which zsh) root
 # Multiple instances throughout codebase
 if [ -f $CONFIG_FILE ]; then
    cp $CONFIG_FILE $BACKUP_DIR
 fi
 ```
 ### After (Proper Variable Quoting)
 ```bash
 # Safe variable usage with proper quoting
 chsh -s "$(which zsh)" root
 # Consistent quoting pattern
 if [[ -f "$CONFIG_FILE" ]]; then
    cp "$CONFIG_FILE" "$BACKUP_DIR/"
 fi
 # Function parameter handling
 function configure_service() {
    local service_name="$1"
    local config_file="$2"
    if [[ -z "$service_name" || -z "$config_file" ]]; then
        print_error "configure_service: service name and config file required"
        return 1
    fi
    print_info "Configuring service: $service_name"
    # Safe operations with quoted variables
 }
 ```
 ## Service Management with Error Handling
 ### Before (Basic Service Operations)
 ```bash
 # Current pattern in various modules
 systemctl restart snmpd
 systemctl enable snmpd
 ```
 ### After (Robust Service Management)
 ```bash
 function safe_service_restart() {
    local service="$1"
    local config_test_cmd="${2:-}"
    if [[ -z "$service" ]]; then
        print_error "safe_service_restart: service name required"
        return 1
    fi
    print_info "Managing service: $service"
    # Test configuration if test command provided
    if [[ -n "$config_test_cmd" ]]; then
        print_info "Testing $service configuration..."
        if ! eval "$config_test_cmd"; then
            print_error "$service configuration test failed"
            return 1
        fi
        print_success "$service configuration test passed"
    fi
    # Check if service exists
    if ! systemctl list-unit-files "$service.service" >/dev/null 2>&1; then
        print_error "Service $service does not exist"
        return 1
    fi
    # Stop service if running
    if systemctl is-active "$service" >/dev/null 2>&1; then
        print_info "Stopping $service..."
        if ! systemctl stop "$service"; then
            print_error "Failed to stop $service"
            return 1
        fi
    fi
    # Start and enable service
    print_info "Starting and enabling $service..."
    if systemctl start "$service" && systemctl enable "$service"; then
        print_success "$service started and enabled successfully"
        # Verify service is running
        sleep 2
        if systemctl is-active "$service" >/dev/null 2>&1; then
            print_success "$service is running properly"
            return 0
        else
            print_error "$service failed to start properly"
            return 1
        fi
    else
        print_error "Failed to start or enable $service"
        return 1
    fi
 }
 # Usage examples
 safe_service_restart "sshd" "sshd -t"
 safe_service_restart "snmpd"
 safe_service_restart "rsyslog"
 ```
 ## Batch Configuration Deployment
 ### Before (Individual File Operations)
 ```bash
 # Lines 66-77 in secharden-scap-stig.sh
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/ModProbe/usb_storage.conf > /etc/modprobe.d/usb_storage.conf 
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/ModProbe/dccp.conf > /etc/modprobe.d/dccp.conf
 curl --silent ${DL_ROOT}/ProjectCode/ConfigFiles/ModProbe/rds.conf > /etc/modprobe.d/rds.conf
 # ... 12 more individual downloads
 ```
 ### After (Batch Operations with Error Handling)
 ```bash
 function deploy_modprobe_configs() {
    print_info "Deploying modprobe security configurations..."
    source "$PROJECT_ROOT/Framework-Includes/SafeDownload.sh"
    local modprobe_configs=(
        "usb_storage" "dccp" "rds" "sctp" "tipc"
        "cramfs" "freevxfs" "hfs" "hfsplus"
        "jffs2" "squashfs" "udf"
    )
    # Create download map
    declare -A config_downloads=()
    for config in "${modprobe_configs[@]}"; do
        local url="${DL_ROOT}/ProjectCode/ConfigFiles/ModProbe/${config}.conf"
        local dest="/etc/modprobe.d/${config}.conf"
        config_downloads["$url"]="$dest"
    done
    # Validate URLs first
    local urls=()
    for url in "${!config_downloads[@]}"; do
        urls+=("$url")
    done
    if ! validate_required_urls "${urls[@]}"; then
        print_error "Some modprobe configuration URLs are not accessible"
        return 1
    fi
    # Perform batch download
    if batch_download config_downloads; then
        print_success "All modprobe configurations deployed"
        # Update initramfs to apply changes
        if update-initramfs -u; then
            print_success "Initramfs updated with new module configurations"
        else
            print_warning "Failed to update initramfs - reboot may be required"
        fi
        return 0
    else
        print_error "Failed to deploy some modprobe configurations"
        return 1
    fi
 }
 ```
 ## Input Validation and Error Handling
 ### Before (Minimal Validation)
 ```bash
 # pi-detect.sh current implementation
 function pi-detect() {
  print_info Now running "$FUNCNAME"....
  if [ -f /sys/firmware/devicetree/base/model ] ; then
    export IS_RASPI="1"
  fi
 }
 ```
 ### After (Comprehensive Validation)
 ```bash
 function pi-detect() {
    print_info "Now running $FUNCNAME..."
    # Initialize variables with default values
    export IS_RASPI="0"
    export PI_MODEL=""
    export PI_REVISION=""
    # Check for Raspberry Pi detection file
    local device_tree_model="/sys/firmware/devicetree/base/model"
    local cpuinfo_file="/proc/cpuinfo"
    if [[ -f "$device_tree_model" ]]; then
        # Try device tree method first (most reliable)
        local model_info
        model_info=$(tr -d '\0' < "$device_tree_model" 2>/dev/null)
        if [[ "$model_info" =~ [Rr]aspberry.*[Pp]i ]]; then
            export IS_RASPI="1"
            export PI_MODEL="$model_info"
            print_success "Raspberry Pi detected via device tree: $PI_MODEL"
        fi
    elif [[ -f "$cpuinfo_file" ]]; then
        # Fallback to cpuinfo method
        if grep -qi "raspberry" "$cpuinfo_file"; then
            export IS_RASPI="1"
            PI_MODEL=$(grep "^Model" "$cpuinfo_file" | cut -d: -f2 | sed 's/^[[:space:]]*//' 2>/dev/null || echo "Unknown Pi Model")
            PI_REVISION=$(grep "^Revision" "$cpuinfo_file" | cut -d: -f2 | sed 's/^[[:space:]]*//' 2>/dev/null || echo "Unknown")
            export PI_MODEL
            export PI_REVISION
            print_success "Raspberry Pi detected via cpuinfo: $PI_MODEL (Rev: $PI_REVISION)"
        fi
    fi
    if [[ "$IS_RASPI" == "1" ]]; then
        print_info "Raspberry Pi specific optimizations will be applied"
    else
        print_info "Standard x86/x64 system detected"
    fi
    return 0
 }
 ```
 ## Function Framework Integration
 ### Before (Inconsistent Framework Usage)
 ```bash
 # Mixed patterns throughout codebase
 function some_function() {
  echo "Doing something..."
  command_that_might_fail
  echo "Done"
 }
 ```
 ### After (Standardized Framework Integration)
 ```bash
 function some_function() {
    print_info "Now running $FUNCNAME..."
    # Local variables
    local config_file="/etc/example.conf"
    local backup_dir="/root/backup"
    local failed=0
    # Validate prerequisites
    if [[ ! -d "$backup_dir" ]]; then
        if ! mkdir -p "$backup_dir"; then
            print_error "Failed to create backup directory: $backup_dir"
            return 1
        fi
    fi
    # Backup existing configuration
    if [[ -f "$config_file" ]]; then
        if cp "$config_file" "$backup_dir/$(basename "$config_file").bak.$(date +%Y%m%d-%H%M%S)"; then
            print_info "Backed up existing configuration"
        else
            print_error "Failed to backup existing configuration"
            return 1
        fi
    fi
    # Perform main operation with error handling
    if command_that_might_fail; then
        print_success "Operation completed successfully"
    else
        print_error "Operation failed"
        return 1
    fi
    print_success "Completed $FUNCNAME"
    return 0
 }
 ```
 ## Performance Monitoring Integration
 ### Enhanced Deployment with Metrics
 ```bash
 function deploy_with_metrics() {
    local start_time end_time duration
    local operation_name="$1"
    shift
    local operation_function="$1"
    shift
    print_info "Starting $operation_name..."
    start_time=$(date +%s)
    # Execute the operation
    if "$operation_function" "$@"; then
        end_time=$(date +%s)
        duration=$((end_time - start_time))
        print_success "$operation_name completed in ${duration}s"
        # Log performance metrics
        echo "$(date '+%Y-%m-%d %H:%M:%S') - $operation_name: ${duration}s" >> /var/log/fetchapply-performance.log
        # Alert if operation took too long
        case "$operation_name" in
            "Package Installation")
                if [[ $duration -gt 300 ]]; then
                    print_warning "Package installation took longer than expected (${duration}s > 300s)"
                fi
                ;;
            "Configuration Download")
                if [[ $duration -gt 120 ]]; then
                    print_warning "Configuration download took longer than expected (${duration}s > 120s)"
                fi
                ;;
        esac
        return 0
    else
        end_time=$(date +%s)
        duration=$((end_time - start_time))
        print_error "$operation_name failed after ${duration}s"
        echo "$(date '+%Y-%m-%d %H:%M:%S') - $operation_name: FAILED after ${duration}s" >> /var/log/fetchapply-performance.log
        return 1
    fi
 }
 # Usage example
 deploy_with_metrics "Package Installation" install_all_packages
 deploy_with_metrics "Configuration Download" download_system_configs
 deploy_with_metrics "SSH Hardening" configure_ssh_hardening
 ```
 ## Testing Integration
 ### Comprehensive Validation Function
 ```bash
 function validate_deployment() {
    print_header "Deployment Validation"
    local validation_failures=0
    # Test package installation
    local required_packages=("git" "curl" "wget" "snmpd" "auditd" "fail2ban")
    for package in "${required_packages[@]}"; do
        if dpkg -l | grep -q "^ii.*$package"; then
            print_success "Package installed: $package"
        else
            print_error "Package missing: $package"
            ((validation_failures++))
        fi
    done
    # Test service status
    local required_services=("sshd" "snmpd" "auditd" "rsyslog")
    for service in "${required_services[@]}"; do
        if systemctl is-active "$service" >/dev/null 2>&1; then
            print_success "Service running: $service"
        else
            print_error "Service not running: $service"
            ((validation_failures++))
        fi
    done
    # Test configuration files
    local required_configs=("/etc/ssh/sshd_config" "/etc/snmp/snmpd.conf" "/etc/rsyslog.conf")
    for config in "${required_configs[@]}"; do
        if [[ -f "$config" && -s "$config" ]]; then
            print_success "Configuration exists: $(basename "$config")"
        else
            print_error "Configuration missing or empty: $(basename "$config")"
            ((validation_failures++))
        fi
    done
    # Run security tests
    if command -v lynis >/dev/null 2>&1; then
        print_info "Running basic security audit..."
        if lynis audit system --quick --quiet; then
            print_success "Security audit completed"
        else
            print_warning "Security audit found issues"
        fi
    fi
    # Summary
    if [[ $validation_failures -eq 0 ]]; then
        print_success "All deployment validation checks passed"
        return 0
    else
        print_error "$validation_failures deployment validation checks failed"
        return 1
    fi
 }
 ```
 These refactoring examples demonstrate how to apply the code review findings to create more robust, performant, and maintainable infrastructure provisioning scripts.
@@ -0,0 +1,190 @@
 # TSYS FetchApply Security Documentation
 ## Security Architecture
 The TSYS FetchApply infrastructure provisioning system is designed with security-first principles, implementing multiple layers of protection for server deployment and management.
 ## Current Security Features
 ### 1. Secure Deployment Method ✅
 - **Git-based deployment:** Uses `git clone` instead of `curl | bash`
 - **Local execution:** Scripts run locally after inspection
 - **Version control:** Full audit trail of changes
 - **Code review:** Changes require explicit approval
 ### 2. HTTPS Enforcement ✅
 - **All downloads use HTTPS:** Eliminates man-in-the-middle attacks
 - **SSL certificate validation:** Automatic certificate checking
 - **Secure repositories:** Ubuntu archive, Dell, Proxmox all use HTTPS
 - **No HTTP fallbacks:** No insecure download methods
 ### 3. SSH Hardening
 - **Key-only authentication:** Password login disabled
 - **Secure ciphers:** Modern encryption algorithms only
 - **Fail2ban protection:** Automated intrusion prevention
 - **Custom SSH configuration:** Hardened sshd_config
 ### 4. System Security
 - **Firewall configuration:** Automated iptables rules
 - **Audit logging:** auditd with custom rules
 - **SIEM integration:** Wazuh agent deployment
 - **Compliance scanning:** SCAP-STIG automated checks
 ### 5. Error Handling
 - **Bash strict mode:** `set -euo pipefail` prevents errors
 - **Centralized logging:** All operations logged with timestamps
 - **Graceful failures:** Proper cleanup on errors
 - **Line-level debugging:** Error reporting with line numbers
 ## Security Testing
 ### Automated Security Validation
 ```bash
 # Run security test suite
 ./Project-Tests/run-tests.sh security
 # Specific security tests
 ./Project-Tests/security/https-enforcement.sh
 ```
 ### Security Test Categories
 1. **HTTPS Enforcement:** Validates all URLs use HTTPS
 2. **Deployment Security:** Checks for secure deployment methods
 3. **SSL Certificate Validation:** Tests certificate authenticity
 4. **Permission Validation:** Verifies proper file permissions
 ## Threat Model
 ### Mitigated Threats
 - **Supply Chain Attacks:** Git-based deployment with review
 - **Man-in-the-Middle:** HTTPS-only downloads
 - **Privilege Escalation:** Proper permission models
 - **Unauthorized Access:** SSH hardening and key management
 ### Remaining Risks
 - **Secrets in Repository:** SSH keys stored in git (planned for removal)
 - **No Integrity Verification:** Downloads lack checksum validation
 - **No Backup/Recovery:** No rollback capability implemented
 ## Security Recommendations
 ### High Priority
 1. **Implement Secrets Management**
   - Remove SSH keys from repository
   - Use Bitwarden/Vault for secret storage
   - Implement key rotation procedures
 2. **Add Download Integrity Verification**
   - SHA256 checksum validation for all downloads
   - GPG signature verification where available
   - Fail-safe on integrity check failures
 3. **Enhance Audit Logging**
   - Centralized log collection
   - Real-time security monitoring
   - Automated threat detection
 ### Medium Priority
 1. **Configuration Backup**
   - System state snapshots before changes
   - Rollback capability for failed deployments
   - Configuration drift detection
 2. **Network Security**
   - VPN-based deployment (where applicable)
   - Network segmentation for management
   - Encrypted communication channels
 ## Compliance
 ### Security Standards
 - **CIS Benchmarks:** Automated compliance checking
 - **STIG Guidelines:** SCAP-based validation
 - **Industry Best Practices:** Following NIST cybersecurity framework
 ### Audit Requirements
 - **Change Tracking:** All modifications logged
 - **Access Control:** Permission-based system access
 - **Vulnerability Management:** Regular security assessments
 ## Incident Response
 ### Security Event Handling
 1. **Detection:** Automated monitoring and alerting
 2. **Containment:** Immediate isolation procedures
 3. **Investigation:** Log analysis and forensics
 4. **Recovery:** System restoration procedures
 5. **Lessons Learned:** Process improvement
 ### Contact Information
 - **Security Team:** [To be defined]
 - **Incident Response:** [To be defined]
 - **Escalation Path:** [To be defined]
 ## Security Development Lifecycle
 ### Code Review Process
 1. **Static Analysis:** Automated security scanning
 2. **Peer Review:** Manual code inspection
 3. **Security Testing:** Automated security test suite
 4. **Approval:** Security team sign-off
 ### Deployment Security
 1. **Pre-deployment Validation:** Security test execution
 2. **Secure Deployment:** Authorized personnel only
 3. **Post-deployment Verification:** Security configuration validation
 4. **Monitoring:** Continuous security monitoring
 ## Security Tools and Integrations
 ### Current Tools
 - **Wazuh:** SIEM and security monitoring
 - **Lynis:** Security auditing
 - **auditd:** System call auditing
 - **Fail2ban:** Intrusion prevention
 ### Planned Integrations
 - **Vault/Bitwarden:** Secrets management
 - **OSSEC:** Host-based intrusion detection
 - **Nessus/OpenVAS:** Vulnerability scanning
 - **ELK Stack:** Log aggregation and analysis
 ## Vulnerability Management
 ### Vulnerability Scanning
 - **Regular scans:** Monthly vulnerability assessments
 - **Automated patching:** Security update automation
 - **Exception handling:** Risk-based patch management
 - **Reporting:** Executive security dashboards
 ### Disclosure Process
 1. **Internal Discovery:** Report to security team
 2. **Assessment:** Risk and impact evaluation
 3. **Remediation:** Patch development and testing
 4. **Deployment:** Coordinated security updates
 5. **Verification:** Post-patch validation
 ## Security Metrics
 ### Key Performance Indicators
 - **Deployment Success Rate:** Percentage of successful secure deployments
 - **Vulnerability Response Time:** Time to patch critical vulnerabilities
 - **Security Test Coverage:** Percentage of code covered by security tests
 - **Incident Response Time:** Time to detect and respond to security events
 ### Monitoring and Reporting
 - **Real-time Dashboards:** Security status monitoring
 - **Executive Reports:** Monthly security summaries
 - **Compliance Reports:** Quarterly compliance assessments
 - **Trend Analysis:** Security posture improvement tracking
 ## Contact and Support
 For security-related questions or incidents:
 - **Repository Issues:** https://projects.knownelement.com/project/reachableceo-vptechnicaloperations/timeline
 - **Community Discussion:** https://community.turnsys.com/c/chieftechnologyandproductofficer/26
 - **Security Team:** [Contact information to be added]
 ## Security Updates
 This document is updated as security features are implemented and threats evolve. Last updated: July 14, 2025.
@@ -0,0 +1,329 @@
 # TSYS Two-Factor Authentication Implementation Guide
 ## Overview
 This guide provides complete instructions for implementing and managing two-factor authentication (2FA) on TSYS servers using Google Authenticator (TOTP).
 ## What This Implementation Provides
 ### Services Protected by 2FA
 - **SSH Access:** Requires SSH key + 2FA token
 - **Cockpit Web Interface:** Requires password + 2FA token
 - **Webmin Administration:** Requires password + 2FA token (if installed)
 ### Security Features
 - **Time-based One-Time Passwords (TOTP):** Standard 6-digit codes
 - **Backup Codes:** Emergency access codes
 - **Gradual Rollout:** Optional nullok mode for phased deployment
 - **Configuration Backup:** Automatic backup of all configs
 ## Implementation Steps
 ### Step 1: Run the 2FA Setup Script
 ```bash
 # Navigate to the security modules directory
 cd ProjectCode/Modules/Security
 # Run the 2FA setup script as root
 sudo bash secharden-2fa.sh
 ```
 ### Step 2: Validate Installation
 ```bash
 # Run 2FA validation tests
 ./Project-Tests/security/2fa-validation.sh
 # Run specific 2FA security test
 ./Project-Tests/run-tests.sh security
 ```
 ### Step 3: Setup Individual Users
 For each user that needs 2FA access:
 ```bash
 # Check setup instructions
 cat /home/username/2fa-setup-instructions.txt
 # Run user setup script
 sudo /tmp/setup-2fa-username.sh
 ```
 ### Step 4: Test 2FA Access
 1. **Test SSH access** from another terminal
 2. **Test Cockpit access** via web browser
 3. **Test Webmin access** if installed
 ## User Setup Process
 ### Installing Authenticator Apps
 Users need one of these apps on their phone:
 - **Google Authenticator** (Android/iOS)
 - **Authy** (Android/iOS)
 - **Microsoft Authenticator** (Android/iOS)
 - **1Password** (with TOTP support)
 ### Setting Up 2FA for a User
 1. **Run setup script:**
   ```bash
   sudo /tmp/setup-2fa-username.sh
   ```
 2. **Follow prompts:**
   - Answer "y" to update time-based token
   - Scan QR code with authenticator app
   - Save emergency backup codes securely
   - Answer "y" to remaining security questions
 3. **Test immediately:**
   ```bash
   # Test SSH from another terminal
   ssh username@server-ip
   # You'll be prompted for 6-digit code
   ```
 ## Configuration Details
 ### SSH Configuration Changes
 File: `/etc/ssh/sshd_config`
 ```
 ChallengeResponseAuthentication yes
 UsePAM yes
 AuthenticationMethods publickey,keyboard-interactive
 ```
 ### PAM Configuration
 File: `/etc/pam.d/sshd`
 ```
 auth required pam_google_authenticator.so nullok
 ```
 ### Cockpit Configuration
 File: `/etc/cockpit/cockpit.conf`
 ```
 [WebService]
 LoginTitle = TSYS Server Management
 LoginTo = 300
 RequireHost = true
 [Session]
 Banner = /etc/cockpit/issue.cockpit
 IdleTimeout = 15
 ```
 ### Webmin Configuration
 File: `/etc/webmin/miniserv.conf`
 ```
 twofactor_provider=totp
 twofactor=1
 ```
 ## Security Considerations
 ### Gradual vs Strict Enforcement
 #### Gradual Enforcement (Default)
 - Uses `nullok` option in PAM
 - Users without 2FA can still log in
 - Allows phased rollout
 - Good for initial deployment
 #### Strict Enforcement
 - Remove `nullok` from PAM configuration
 - All users must have 2FA configured
 - Immediate security enforcement
 - Risk of lockout if misconfigured
 ### Backup and Recovery
 #### Emergency Access
 - **Backup codes:** Generated during setup
 - **Root access:** Can disable 2FA if needed
 - **Console access:** Physical/virtual console bypasses SSH
 #### Configuration Backup
 - Automatic backup to `/root/backup/2fa-TIMESTAMP/`
 - Includes all modified configuration files
 - Can be restored if needed
 ## Troubleshooting
 ### Common Issues
 #### 1. User Cannot Generate QR Code
 ```bash
 # Ensure qrencode is installed
 sudo apt-get install qrencode
 # Re-run user setup
 sudo /tmp/setup-2fa-username.sh
 ```
 #### 2. SSH Connection Fails
 ```bash
 # Check SSH service status
 sudo systemctl status sshd
 # Test SSH configuration
 sudo sshd -t
 # Check logs
 sudo journalctl -u sshd -f
 ```
 #### 3. 2FA Code Not Accepted
 - **Check time synchronization** on server and phone
 - **Verify app setup** - rescan QR code if needed
 - **Try backup codes** if available
 #### 4. Locked Out of Server
 ```bash
 # Access via console (physical/virtual)
 # Disable 2FA temporarily
 sudo cp /root/backup/2fa-*/pam.d.bak/sshd /etc/pam.d/sshd
 sudo systemctl restart sshd
 ```
 ### Debug Commands
 ```bash
 # Check 2FA status
 ./Project-Tests/security/2fa-validation.sh
 # Check SSH configuration
 sudo sshd -T | grep -E "(Challenge|PAM|Authentication)"
 # Check PAM configuration
 cat /etc/pam.d/sshd | grep google-authenticator
 # Check user 2FA status
 ls -la ~/.google_authenticator
 ```
 ## Management and Maintenance
 ### Adding New Users
 1. Ensure user account exists
 2. Run setup script for new user
 3. Provide setup instructions
 4. Test access
 ### Removing User 2FA
 ```bash
 # Remove user's 2FA configuration
 sudo rm /home/username/.google_authenticator
 # User will need to re-setup 2FA
 ```
 ### Disabling 2FA System-Wide
 ```bash
 # Restore original configurations
 sudo cp /root/backup/2fa-*/sshd_config.bak /etc/ssh/sshd_config
 sudo cp /root/backup/2fa-*/pam.d.bak/sshd /etc/pam.d/sshd
 sudo systemctl restart sshd
 ```
 ### Updating 2FA Configuration
 ```bash
 # Re-run setup script
 sudo bash secharden-2fa.sh
 # Validate changes
 ./Project-Tests/security/2fa-validation.sh
 ```
 ## Best Practices
 ### Deployment Strategy
 1. **Test in non-production** environment first
 2. **Enable gradual rollout** (nullok) initially
 3. **Train users** on 2FA setup process
 4. **Test emergency procedures** before strict enforcement
 5. **Monitor logs** for authentication issues
 ### Security Recommendations
 - **Enforce strict mode** after successful rollout
 - **Regular backup code rotation**
 - **Monitor failed authentication attempts**
 - **Document emergency procedures**
 - **Regular security audits**
 ### User Training
 - **Provide clear instructions**
 - **Demonstrate setup process**
 - **Explain backup code importance**
 - **Test login process with users**
 - **Establish support procedures**
 ## Monitoring and Logging
 ### Authentication Logs
 ```bash
 # SSH authentication logs
 sudo journalctl -u sshd | grep -i "authentication"
 # PAM authentication logs
 sudo journalctl | grep -i "pam_google_authenticator"
 # Failed login attempts
 sudo journalctl | grep -i "failed"
 ```
 ### Security Monitoring
 - Monitor for repeated failed 2FA attempts
 - Alert on successful logins without 2FA (during gradual rollout)
 - Track user 2FA setup completion
 - Monitor for emergency access usage
 ## Integration with Existing Systems
 ### LDAP/Active Directory
 - 2FA works with existing authentication systems
 - Users still need local 2FA setup
 - Consider centralized 2FA solutions for large deployments
 ### Monitoring Systems
 - LibreNMS: Will continue to work with SNMP
 - Wazuh: Will log 2FA authentication events
 - Cockpit: Enhanced with 2FA protection
 ### Backup Systems
 - Ensure backup procedures account for 2FA
 - Test restore procedures with 2FA enabled
 - Document emergency access procedures
 ## Support and Resources
 ### Files Created by Setup
 - `/tmp/setup-2fa-*.sh` - User setup scripts
 - `/home/*/2fa-setup-instructions.txt` - User instructions
 - `/root/backup/2fa-*/` - Configuration backups
 ### Validation Tools
 - `./Project-Tests/security/2fa-validation.sh` - Complete 2FA validation
 - `./Project-Tests/run-tests.sh security` - Security test suite
 ### Emergency Contacts
 - System Administrator: [Contact Info]
 - Security Team: [Contact Info]
 - 24/7 Support: [Contact Info]
 ## Compliance and Audit
 ### Security Benefits
 - Significantly reduces risk of unauthorized access
 - Meets multi-factor authentication requirements
 - Provides audit trail of authentication events
 - Complies with security frameworks (NIST, ISO 27001)
 ### Audit Trail
 - All authentication attempts logged
 - 2FA setup events recorded
 - Configuration changes tracked
 - Emergency access documented
 ---
 **Last Updated:** July 14, 2025  
 **Version:** 1.0  
 **Author:** TSYS Security Team
@@ -0,0 +1,117 @@
 # Charles TODO - TSYS FetchApply Security Improvements
 **Priority Order:** High → Medium → Low  
 **Target:** Address security vulnerabilities and operational improvements
 ## 🚨 HIGH PRIORITY (Security Critical)
 ### ✅ 1. Replace Insecure Deployment Method - RESOLVED
 **Previous Issue:** `curl https://dl.knownelement.com/KNEL/FetchApply/SetupNewSystem.sh | bash`
 **Status:** Fixed in README.md - now uses secure git clone approach
 **Current Method:** `git clone this repo` → `cd FetchApply/ProjectCode` → `bash SetupNewSystem.sh`
 **Remaining considerations:**
 - Consider implementing GPG signature verification for tagged releases
 - Add cryptographic checksums for external downloads within scripts
 ### ✅ 2. Enforce HTTPS for All Downloads - RESOLVED
 **Previous Issue:** HTTP URLs in Dell OMSA and some repository setups
 **Status:** All HTTP URLs converted to HTTPS across:
  - `ProjectCode/Dell/Server/omsa.sh` - Ubuntu archive and Dell repo URLs
  - `ProjectCode/legacy/prox7.sh` - Proxmox download URLs
  - `ProjectCode/Modules/RandD/sslStackFromSource.sh` - Apache source URLs
 **Remaining considerations:**
 - SSL certificate validation is enabled by default in wget/curl
 - Consider adding retry logic for certificate failures
 ### 3. Implement Secrets Management
 **Current Issue:** SSH keys committed to repository, no secrets rotation
 **Action Required:**
 - Deploy Bitwarden CLI or HashiCorp Vault integration
 - Remove SSH public keys from repository
 - Create secure key distribution mechanism
 - Implement key rotation procedures
 - Add environment variable support for sensitive data
 **Files to secure:**
 - `ProjectCode/ConfigFiles/SSH/AuthorizedKeys/` (entire directory)
 - Hard-coded hostnames in various scripts
 ## 🔶 MEDIUM PRIORITY (Operational Security)
 ### 4. Add Script Integrity Verification
 **Action Required:**
 - Generate SHA256 checksums for all scripts
 - Create checksum verification function in Framework-Includes
 - Add signature verification for external downloads
 - Implement rollback capability on verification failure
 ### 5. Enhanced Error Recovery
 **Action Required:**
 - Add state tracking for partial deployments
 - Implement resume functionality for interrupted installations
 - Create system restoration points before major changes
 - Add dependency checking before module execution
 ### 6. Security Testing Framework
 **Action Required:**
 - Create integration tests for security configurations
 - Add compliance validation (CIS benchmarks, STIG)
 - Implement automated security scanning post-deployment
 - Create test environments for validation
 ### 7. Configuration Validation
 **Action Required:**
 - Add pre-flight checks for system compatibility
 - Validate network connectivity to required services
 - Check for conflicting software before installation
 - Verify sufficient disk space and system resources
 ## 🔹 LOW PRIORITY (Quality Improvements)
 ### 8. Documentation Enhancement
 **Action Required:**
 - Create detailed security architecture documentation
 - Add troubleshooting guides for common issues
 - Document security implications of each module
 - Create deployment runbooks for different environments
 ### 9. Monitoring and Alerting
 **Action Required:**
 - Add deployment success/failure reporting
 - Implement centralized logging for all installations
 - Create dashboards for deployment status
 - Add alerting for security configuration drift
 ### 10. User Experience Improvements
 **Action Required:**
 - Create web-based deployment interface
 - Add progress indicators for long-running operations
 - Implement dry-run mode for testing configurations
 - Add interactive configuration selection
 ## Implementation Timeline
 **✅ COMPLETED:** Item 1 (Secure deployment method)  
 **✅ COMPLETED:** Item 2 (HTTPS enforcement)  
 **Week 1:** Item 3 (Secrets management)  
 **Week 2-3:** Items 4-5 (Operational improvements)  
 **Month 2:** Items 6-10 (Quality and monitoring)
 ## Success Criteria
 - [ ] No plaintext secrets in repository
 - [x] All downloads use HTTPS with verification ✅
 - [x] Deployment method is cryptographically secure ✅
 - [ ] Automated testing validates security configurations
 - [ ] Rollback capability exists for all changes
 - [ ] Comprehensive documentation covers security implications
 ## Resources Needed
 - Access to package repository for signed distributions
 - GPG key infrastructure for signing
 - Secrets management service (Vault/Bitwarden)
 - Test environment infrastructure
 - Security scanning tools integration
@@ -0,0 +1,162 @@
 # Claude TODO - TSYS FetchApply Automation Tasks
 **Purpose:** Actionable items optimized for AI assistant implementation  
 **Priority:** Critical → High → Medium → Low
 ## 🚨 CRITICAL (Immediate Security Fixes)
 ### ✅ RESOLVED: Secure Deployment Method
 **Previous Issue:** `curl | bash` deployment method  
 **Status:** Fixed in README.md - now uses `git clone` + local script execution
 ### ✅ RESOLVED: Replace HTTP URLs with HTTPS
 **Files modified:**
 - `ProjectCode/Dell/Server/omsa.sh` - Converted 11 HTTP URLs to HTTPS (Ubuntu archive, Dell repo)
 - `ProjectCode/legacy/prox7.sh` - Converted 2 HTTP URLs to HTTPS (Proxmox downloads)
 - `ProjectCode/Modules/RandD/sslStackFromSource.sh` - Converted 3 HTTP URLs to HTTPS (Apache sources)
 **Status:** All HTTP URLs in active scripts converted to HTTPS. Only remaining HTTP references are in comments and LibreNMS agent files (external dependencies).
 ### TASK-002: Add Download Integrity Verification
 **Create new function in:** `Framework-Includes/VerifyDownload.sh`
 **Function to implement:**
 ```bash
 function verify_download() {
    local url="$1"
    local expected_hash="$2"
    local output_file="$3"
    curl -fsSL "$url" -o "$output_file"
    local actual_hash=$(sha256sum "$output_file" | cut -d' ' -f1)
    if [ "$actual_hash" != "$expected_hash" ]; then
        print_error "Hash verification failed for $output_file"
        rm -f "$output_file"
        return 1
    fi
    print_info "Download verified: $output_file"
 }
 ```
 ### TASK-003: Create Secure Deployment Script
 **Create:** `ProjectCode/SecureSetupNewSystem.sh`
 **Features to implement:**
 - GPG signature verification
 - SHA256 checksum validation
 - HTTPS-only downloads
 - Rollback capability
 ## 🔶 HIGH (Security Enhancements)
 ### TASK-004: Remove Hardcoded SSH Keys
 **Files to modify:**
 - `ProjectCode/ConfigFiles/SSH/AuthorizedKeys/root-ssh-authorized-keys`
 - `ProjectCode/ConfigFiles/SSH/AuthorizedKeys/localuser-ssh-authorized-keys`
 - `ProjectCode/Modules/Security/secharden-ssh.sh:31,40,51`
 **Implementation approach:**
 1. Create environment variable support: `SSH_KEYS_URL` or `SSH_KEYS_VAULT_PATH`
 2. Modify secharden-ssh.sh to fetch keys from secure source
 3. Add key validation before deployment
 ### TASK-005: Add Secrets Management Framework
 **Create:** `Framework-Includes/SecretsManager.sh`
 **Functions to implement:**
 ```bash
 function get_secret() { }           # Retrieve secret from vault
 function validate_secret() { }      # Validate secret format
 function rotate_secret() { }        # Trigger secret rotation
 ```
 ### TASK-006: Enhanced Preflight Checks
 **Modify:** `Framework-Includes/PreflightCheck.sh`
 **Add checks for:**
 - Network connectivity to required hosts
 - Disk space requirements
 - Existing conflicting software
 - Required system capabilities
 ## 🔹 MEDIUM (Operational Improvements)
 ### TASK-007: Add Configuration Backup
 **Create:** `Framework-Includes/ConfigBackup.sh`
 **Functions:**
 ```bash
 function backup_config() { }        # Create timestamped backup
 function restore_config() { }       # Restore from backup
 function list_backups() { }         # Show available backups
 ```
 ### TASK-008: Implement State Tracking
 **Create:** `Framework-Includes/StateManager.sh`
 **Track:**
 - Deployment progress
 - Module completion status
 - Rollback points
 - System changes made
 ### TASK-009: Add Retry Logic
 **Enhance existing scripts with:**
 - Configurable retry attempts for network operations
 - Exponential backoff for failed operations
 - Circuit breaker for repeatedly failing services
 ## 🔸 LOW (Quality of Life)
 ### TASK-010: Enhanced Logging
 **Modify:** `Framework-Includes/Logging.sh`
 **Add:**
 - Structured logging (JSON format option)
 - Log levels (DEBUG, INFO, WARN, ERROR)
 - Remote logging capability
 - Log rotation management
 ### TASK-011: Progress Indicators
 **Add to:** `Framework-Includes/PrettyPrint.sh`
 ```bash
 function show_progress() { }        # Display progress bar
 function update_status() { }        # Update current operation
 ```
 ### TASK-012: Dry Run Mode
 **Add to:** `ProjectCode/SetupNewSystem.sh`
 **Implementation:**
 - `--dry-run` flag support
 - Preview of changes without execution
 - Dependency analysis output
 ## Implementation Order for Claude
 **Updated Priority After Security Fix (July 14, 2025):**
 1. **Start with TASK-001** (HTTPS enforcement - simple find/replace operations)
 2. **Create framework functions** (TASK-002, TASK-005, TASK-007)
 3. **Enhance existing modules** (TASK-004, TASK-006)
 4. **Add operational features** (TASK-008, TASK-009)
 5. **Improve user experience** (TASK-010, TASK-011, TASK-012)
 **Note:** Major deployment security risk resolved - remaining tasks focus on hardening internal operations.
 ## File Location Patterns
 - **Framework components:** `Framework-Includes/*.sh`
 - **Security modules:** `ProjectCode/Modules/Security/*.sh`
 - **Configuration files:** `ProjectCode/ConfigFiles/*/`
 - **Main entry point:** `ProjectCode/SetupNewSystem.sh`
 ## Testing Strategy
 For each task:
 1. Create backup of original files
 2. Implement changes incrementally
 3. Test with `bash -n` for syntax validation
 4. Verify functionality with controlled test runs
 5. Document changes made
 ## Error Handling Requirements
 All new functions must:
 - Use `set -euo pipefail` compatibility
 - Integrate with existing error handling framework
 - Log errors to `$LOGFILENAME`
 - Return appropriate exit codes
 - Clean up temporary files on failure
@@ -0,0 +1,217 @@
 # Tailscale vs. Managed DNS — Architecture Analysis
 > **Status:** analysis for review. No code decisions are final. Read the
 > "Known issues" section before acting on the managed-resolv.conf change.
 ## 1. Executive summary
 Every host in this build runs the Tailscale client, and Tailscale — by default —
 **manages `/etc/resolv.conf` itself**, pointing it at `100.100.100.100`
 (Tailscale's MagicDNS resolver). This directly conflicts with the managed
 `resolv.conf` (pointing at `192.168.3.252`/`192.168.3.253`) that
 `SetupNewSystem.sh` deploys: whichever runs last wins, and Tailscale's daemon
 re-wins on every `tailscale up` and on reboot.
 Worse, a probe of the live network shows that **knel.net device records only
 resolve through the Tailscale 100.100.100.100 path** — querying the LAN IPs of
 the DNS servers directly returns NXDOMAIN for current hostnames (the Technitium
 `knel.net` zone has the SOA but is stale/empty of actual records). So pointing
 `resolv.conf` at the LAN IPs would break resolution of the very names this
 project's modules depend on (`tsys-nsm.knel.net`, `tsys-cloudron.knel.net`,
 `tsys-librenms.knel.net`).
 This document lays out the options and a recommended path forward.
 ## 2. How name resolution actually works today (as measured)
 Probed from `sectestbed-sandbox` (192.168.3.50):
 | Query path | External name (`github.com`) | knel.net device name (`pfv-netinfra-01.knel.net`) |
 |---|---|---|
 | Via current resolver = `100.100.100.100` (Tailscale) | resolves | **resolves** → `100.70.181.72` (Tailscale CGNAT) |
 | Direct `dig @192.168.3.252` (Technitium, LAN) | resolves (recurses) | **NXDOMAIN** (SOA present, no record) |
 | Direct `dig @192.168.3.253` (Pi-hole, LAN) | resolves (recurses) | **NXDOMAIN** (SOA present, no record) |
 Other measured facts:
 - `dig @192.168.3.252 knel.net SOA` → `NOERROR`, returns
  `knel.net. 900 IN SOA dns.knel.net. hostadmin.knel.net. 2025062313 …`
  (serial dated **2025-06-23** — the zone exists but is stale).
 - NTP on both `.252` and `.253` answers time queries (stratum 2/3).
 - The live `/etc/resolv.conf` on a deployed host reads:
  ```
  # resolv.conf(5) file generated by tailscale
  # DO NOT EDIT THIS FILE BY HAND -- CHANGES WILL BE OVERWRITTEN
  nameserver 100.100.100.100
  nameserver fd7a:115c:a1e0::53
  search knel.net
  ```
 **Interpretation:** the `knel.net` device→Tailscale-IP mappings are synthesised
 by Tailscale's MagicDNS from the tailnet device registry (every device that
 joins the tailnet gets `hostname.knel.net` → its `100.x.x.x` address). The
 Technitium `knel.net` zone is a separate, manually-maintained zone that has
 fallen out of date. The two are not the same source of truth.
 ## 3. The core tension
 | Goal | Who provides it today |
 |---|---|
 | Resolve `*.knel.net` device names (→ Tailscale IPs) | Tailscale MagicDNS via `100.100.100.100` |
 | Resolve external names with ad-blocking | Pi-hole (`.253`), reachable via Tailscale → Technitium → Pi-hole chain |
 | Redundant, low-latency, tunnel-independent DNS | LAN resolvers `.252`/`.253` — **but these lack knel.net records** |
 | Authoritative time | NTP on `.252`/`.253` (works on either path) |
 The conflict: you cannot simply point `resolv.conf` at the LAN resolvers,
 because they do not know about the current `knel.net` device records, and
 several modules in this project resolve `knel.net` hostnames at runtime
 (wazuh manager, postfix relay, syslog target). You also cannot ignore Tailscale,
 because it is the only thing that resolves those names today.
 ## 4. Options
 ### Option A — Let Tailscale own DNS (status quo, `accept-dns=true`)
 Leave the default. Tailscale writes `100.100.100.100` to `resolv.conf`; the
 control-plane forwarding (`100.100.100.100` → Technitium → Pi-hole) handles
 external names and ad-blocking; MagicDNS handles `knel.net` device names.
 | Pros | Cons |
 |---|---|
 | Zero per-host config; new machines "just work" on `tailscale up` | **All DNS depends on the Tailscale daemon being up.** If `tailscaled` dies, every name lookup fails — including the ones you need to SSH in and fix it. |
 | MagicDNS + knel.net names resolve automatically | Latency: every query goes host→tailscaled→100.100.100.100→(tunnel)→Technitium→Pi-hole→upstream |
 | Ad-blocking preserved (via the Pi-hole hop) | Overwrites the managed `resolv.conf` — the `.252`/`.253` redundancy is lost |
 | Centralised in the Tailscale admin console | Single resolver in `resolv.conf` (`100.100.100.100`); no glibc-level failover |
 | | Boot-order risk: early-boot processes have no DNS until `tailscaled` is up |
 ### Option B — Pin resolv.conf to the LAN resolvers (`accept-dns=false`)
 Set `--accept-dns=false` on every host and keep the managed `resolv.conf`
 pointing at `.252`/`.253`.
 | Pros | Cons |
 |---|---|
 | DNS independent of Tailscale — survives `tailscaled` outages | **`*.knel.net` device names break (NXDOMAIN)** because the LAN resolvers' knel.net zone is stale. This breaks wazuh/postfix/syslog hostname resolution. |
 | Lowest latency, full glibc-level failover across two servers | MagicDNS names (`*.ts.net`) do not resolve |
 | Managed `resolv.conf` wins uncontested | Requires fixing the Technitium/Pi-hole `knel.net` zone to mirror the Tailscale device records before this is viable |
 | Boot-time DNS works immediately | Off-LAN hosts (laptops) can't reach `.252`/`.253` without the tunnel — back to needing Tailscale |
 > **Not recommended as-is.** Only viable **after** the `knel.net` zone on
 > `.252`/`.253` is repopulated with current device records (see §6).
 ### Option C — Tailscale Split DNS (per-domain routing)
 MagicDNS `ON`, "Override local DNS" `OFF` in the admin console; only `ts.net`
 (and explicitly split domains) route to `100.100.100.100`, everything else stays
 on the system resolver.
 | Pros | Cons |
 |---|---|
 | Best of both worlds: MagicDNS names resolve AND general queries go direct | Requires `systemd-resolved` (or NetworkManager `dns=dnsmasq`) for per-domain routing. These hosts use a **plain `/etc/resolv.conf`** — on which Tailscale **cannot** do per-domain split; it replaces the whole file. |
 | Reduces tunnel dependency for non-Tailscale names | Migrating every host to `systemd-resolved` is a significant, cross-cutting change |
 | | More moving parts to reason about and debug |
 ### Option D — Make Tailscale push the LAN resolvers as global nameservers
 In the admin console, set global nameservers to `192.168.3.252`/`192.168.3.253`,
 keep `accept-dns=true`.
 | Pros | Cons |
 |---|---|
 | Clients get the LAN resolvers via Tailscale config (consistent) | Tailscale still overwrites `resolv.conf` |
 | MagicDNS still works (100.100.100.100 added for `ts.net`/`knel.net`) | On-LAN hosts don't need Tailscale to find `.252`/`.253` — pure indirection |
 | Centralised management | Still depends on `tailscaled` for DNS |
 | | `knel.net` device names still only resolve via the Tailscale path, so the LAN resolvers being "global" doesn't help those names unless the zone is fixed |
 ## 5. Recommendation
 **Short term (unblock now): Option A — let Tailscale own DNS.** Revert/disable
 the managed-`resolv.conf` deployment so provisioning stops fighting Tailscale.
 Today, `knel.net` device names **only** resolve through Tailscale, and this
 project's modules depend on those names, so Tailscale-managed DNS is the only
 thing that currently works end-to-end. Keep the NTP change (LAN IPs, no DNS
 dependency) — that part is safe and beneficial regardless.
 **Medium term (the real fix): populate the `knel.net` zone on the LAN
 resolvers**, then choose B or C. Concretely:
 1. Make Technitium (`.252`) authoritative for `knel.net` **with current records**
   (mirror the Tailscale device→IP mappings, or enable a zone-transfer/sync from
   the Tailscale device registry, or use Technitium's "Tailscale" DNS app if
   available). Confirm `dig @192.168.3.252 pfv-netinfra-01.knel.net` returns an
   answer, not NXDOMAIN.
 2. Make Pi-hole (`.253`) forward `knel.net` to Technitium (or also serve the
   zone), so both resolvers in the pair can answer internal names — otherwise
   glibc failover to `.253` would silently break knel.net lookups.
 3. *Then* pin `resolv.conf` to `.252`/`.253` with `--accept-dns=false`
   (Option B), gaining tunnel-independent, redundant DNS.
 **Long term (optional, if per-domain routing is wanted): Option C** — adopt
 `systemd-resolved` and configure Tailscale Split DNS so `ts.net`/`knel.net` go
 to MagicDNS and everything else goes direct. Only worth the migration cost if
 you specifically need `*.ts.net` short-name resolution alongside direct LAN DNS.
 ### Why not just force `.252`/`.253` today?
 Because it regresses name resolution for the hostnames this project already
 uses. Concretely, with `resolv.conf` pinned to the LAN resolvers the following
 would fail to resolve:
 - `ProjectCode/Modules/Security/secharden-wazuh.sh` → `WAZUH_MANAGER="tsys-nsm.knel.net"`
 - `ProjectCode/SetupNewSystem.sh` → `postconf -e "relayhost = tsys-cloudron.knel.net"`
 - `ProjectCode/ConfigFiles/Syslog/rsyslog.conf` → `*.* @tsys-librenms.knel.net:514`
 All three resolve cleanly via `100.100.100.100` today and return NXDOMAIN via
 `.252`/`.253`. Pinning the LAN resolvers before the zone is fixed would break
 wazuh, mail relay, and syslog.
 ## 6. Known issues / action items
 1. **Technitium `knel.net` zone is stale.** SOA serial `2025062313`
   (2025-06-23); current device names return NXDOMAIN from the LAN interface.
   Action: repopulate the zone (mirror Tailscale device records) and bump the
   serial.
 2. **Pi-hole (`.253`) has no `knel.net` device records either.** For the pair
   to be truly redundant for internal names, `.253` must either serve the same
   zone or conditional-forward `knel.net` to `.252`. Action: configure Pi-hole
   to forward `knel.net` to Technitium.
 3. **The managed-`resolv.conf` change (commit f010fa9) conflicts with
   Tailscale.** As written, `SetupNewSystem.sh` writes `resolv.conf` with
   `.252`/`.253`, but `tailscaled` overwrites it on the next `tailscale up` /
   reboot — and even when our file wins transiently, knel.net names break. See
   §5 for the recommended handling.
 4. **NTP change is safe and good.** `ntp.conf` now uses LAN IPs
   (`192.168.3.252`/`192.168.3.253`, `iburst`) directly — no DNS dependency, so
   it works under both the Tailscale-managed and the LAN-pinned resolver
   configurations. Keep this regardless of the DNS decision.
 5. **Split-horizon possibility (unconfirmed).** It is possible Technitium serves
   a richer `knel.net` zone on its Tailscale interface (`100.x`) than on its LAN
   interface (`192.168.3.252`). If so, the fix is to make the LAN view match the
   Tailscale view. Worth confirming with `dig @<technitium-tailscale-ip> knel.net host`.
 ## 7. Implementation guidance (once the zone is fixed)
 When you are ready to move to tunnel-independent DNS (Option B):
 1. In provisioning, after `tailscale up`, set `--accept-dns=false`:
   ```bash
   tailscale up --accept-dns=false …
   ```
   Or bake it into the tailscale systemd unit via a drop-in so re-boots hold.
 2. *Then* deploy the managed `resolv.conf` (`.252`/`.253`). Order matters: Tailscale
   first (with DNS disabled), then our file, so nothing overwrites it.
 3. Add a watchdog (timer) that restores `resolv.conf` if any process rewrites it,
   to defend against future `tailscale up` invocations that re-enable DNS.
 4. Validate with `Project-Tests/validation/dns-ntp-redundancy.sh` — and extend
   its probe to assert `*.knel.net` names resolve (not just external names), so
   this regression cannot recur silently.
 ## 8. TL;DR
 - **DNS**: don't fight Tailscale yet. Today `knel.net` names only resolve via
  Tailscale, and this project depends on them. Fix the Technitium/Pi-hole
  `knel.net` zone first, *then* pin the LAN resolvers.
 - **NTP**: the LAN-IP change is correct and safe; keep it.
 - **The managed `resolv.conf` (`.252`/`.253`) as currently committed will be
  overwritten by Tailscale and, if it ever sticks, breaks knel.net resolution —
  see §5/§6 before relying on it.**
@@ -0,0 +1,2 @@
 *
 !.gitignore
@@ -0,0 +1,9 @@
 [Unit]
 Description=Check_MK LibreNMS Agent Socket
 [Socket]
 ListenStream=6556
 Accept=yes
 [Install]
 WantedBy=sockets.target
@@ -0,0 +1,7 @@
 [Unit]
 Description=Check_MK LibreNMS Agent Service
 After=network.target
 [Service]
 ExecStart=/usr/bin/check_mk_agent
 StandardOutput=socket
@@ -0,0 +1,659 @@
 #!/bin/bash
 # +------------------------------------------------------------------+
 # |             ____ _               _        __  __ _  __           |
 # |            / ___| |__   ___  ___| | __   |  \/  | |/ /           |
 # |           | |   | '_ \ / _ \/ __| |/ /   | |\/| | ' /            |
 # |           | |___| | | |  __/ (__|   <    | |  | | . \            |
 # |            \____|_| |_|\___|\___|_|\_\___|_|  |_|_|\_\           |
 # |                                                                  |
 # | Copyright Mathias Kettner 2014             mk@mathias-kettner.de |
 # +------------------------------------------------------------------+
 #
 # This file is part of Check_MK.
 # The official homepage is at http://mathias-kettner.de/check_mk.
 #
 # check_mk is free software;  you can redistribute it and/or modify it
 # under the  terms of the  GNU General Public License  as published by
 # the Free Software Foundation in version 2.  check_mk is  distributed
 # in the hope that it will be useful, but WITHOUT ANY WARRANTY;  with-
 # out even the implied warranty of  MERCHANTABILITY  or  FITNESS FOR A
 # PARTICULAR PURPOSE. See the  GNU General Public License for more de-
 # ails.  You should have  received  a copy of the  GNU  General Public
 # License along with GNU Make; see the file  COPYING.  If  not,  write
 # to the Free Software Foundation, Inc., 51 Franklin St,  Fifth Floor,
 # Boston, MA 02110-1301 USA.
 # Remove locale settings to eliminate localized outputs where possible
 export LC_ALL=C
 unset LANG
 export MK_LIBDIR="/usr/lib/check_mk_agent"
 export MK_CONFDIR="/etc/check_mk"
 export MK_VARDIR="/var/lib/check_mk_agent"
 # Provide information about the remote host. That helps when data
 # is being sent only once to each remote host.
 if [ "$REMOTE_HOST" ] ; then
    export REMOTE=$REMOTE_HOST
 elif [ "$SSH_CLIENT" ] ; then
    export REMOTE=${SSH_CLIENT%% *}
 fi
 # Make sure, locally installed binaries are found
 PATH=$PATH:/usr/local/bin
 # All executables in PLUGINSDIR will simply be executed and their
 # ouput appended to the output of the agent. Plugins define their own
 # sections and must output headers with '<<<' and '>>>'
 PLUGINSDIR=$MK_LIBDIR/plugins
 # All executables in LOCALDIR will by executabled and their
 # output inserted into the section <<<local>>>. Please
 # refer to online documentation for details about local checks.
 LOCALDIR=$MK_LIBDIR/local
 # All files in SPOOLDIR will simply appended to the agent
 # output if they are not outdated (see below)
 SPOOLDIR=$MK_VARDIR/spool
 # close standard input (for security reasons) and stderr
 if [ "$1" = -d ]
 then
    set -xv
 else
    exec </dev/null 2>/dev/null
 fi
 # Runs a command asynchronous by use of a cache file
 function run_cached () {
    local section=
    if [ "$1" = -s ] ; then local section="echo '<<<$2>>>' ; " ; shift ; fi
    local NAME=$1
    local MAXAGE=$2
    shift 2
    local CMDLINE="$section$@"
    if [ ! -d $MK_VARDIR/cache ]; then mkdir -p $MK_VARDIR/cache ; fi
    CACHEFILE="$MK_VARDIR/cache/$NAME.cache"
    # Check if the creation of the cache takes suspiciously long and return
    # nothing if the age (access time) of $CACHEFILE.new is twice the MAXAGE
    local NOW=$(date +%s)
    if [ -e "$CACHEFILE.new" ] ; then
        local CF_ATIME=$(stat -c %X "$CACHEFILE.new")
        if [ $((NOW - CF_ATIME)) -ge $((MAXAGE * 2)) ] ; then
            # Kill the process still accessing that file in case
            # it is still running. This avoids overlapping processes!
            fuser -k -9 "$CACHEFILE.new" >/dev/null 2>&1
            rm -f "$CACHEFILE.new"
            return
        fi
    fi
    # Check if cache file exists and is recent enough
    if [ -s "$CACHEFILE" ] ; then
        local MTIME=$(stat -c %Y "$CACHEFILE")
        if [ $((NOW - MTIME)) -le $MAXAGE ] ; then local USE_CACHEFILE=1 ; fi
        # Output the file in any case, even if it is
        # outdated. The new file will not yet be available
        cat "$CACHEFILE"
    fi
    # Cache file outdated and new job not yet running? Start it
    if [ -z "$USE_CACHEFILE" -a ! -e "$CACHEFILE.new" ] ; then
        echo "set -o noclobber ; exec > \"$CACHEFILE.new\" || exit 1 ; $CMDLINE && mv \"$CACHEFILE.new\" \"$CACHEFILE\" || rm -f \"$CACHEFILE\" \"$CACHEFILE.new\"" | nohup bash >/dev/null 2>&1 &
    fi
 }
 # Make run_cached available for subshells (plugins, local checks, etc.)
 export -f run_cached
 echo '<<<check_mk>>>'
 echo Version: 1.2.6b5
 echo AgentOS: linux
 echo AgentDirectory: $MK_CONFDIR
 echo DataDirectory: $MK_VARDIR
 echo SpoolDirectory: $SPOOLDIR
 echo PluginsDirectory: $PLUGINSDIR
 echo LocalDirectory: $LOCALDIR
 # If we are called via xinetd, try to find only_from configuration
 if [ -n "$REMOTE_HOST" ]
 then
    echo -n 'OnlyFrom: '
    echo $(sed -n '/^service[[:space:]]*check_mk/,/}/s/^[[:space:]]*only_from[[:space:]]*=[[:space:]]*\(.*\)/\1/p' /etc/xinetd.d/* | head -n1)
 fi
 # Print out Partitions / Filesystems. (-P gives non-wrapped POSIXed output)
 # Heads up: NFS-mounts are generally supressed to avoid agent hangs.
 # If hard NFS mounts are configured or you have too large nfs retry/timeout
 # settings, accessing those mounts from the agent would leave you with
 # thousands of agent processes and, ultimately, a dead monitored system.
 # These should generally be monitored on the NFS server, not on the clients.
 echo '<<<df>>>'
 # The exclusion list is getting a bit of a problem. -l should hide any remote FS but seems
 # to be all but working.
 excludefs="-x smbfs -x cifs -x iso9660 -x udf -x nfsv4 -x nfs -x mvfs -x zfs"
 df -PTlk $excludefs | sed 1d
 # df inodes information
 echo '<<<df>>>'
 echo '[df_inodes_start]'
 df -PTli $excludefs | sed 1d
 echo '[df_inodes_end]'
 # Filesystem usage for ZFS
 if type zfs > /dev/null 2>&1 ; then
    echo '<<<zfsget>>>'
    zfs get -Hp name,quota,used,avail,mountpoint,type -t filesystem,volume || \
       zfs get -Hp name,quota,used,avail,mountpoint,type
    echo '[df]'
    df -PTlk -t zfs | sed 1d
 fi
 # Check NFS mounts by accessing them with stat -f (System
 # call statfs()). If this lasts more then 2 seconds we
 # consider it as hanging. We need waitmax.
 if type waitmax >/dev/null
 then
    STAT_VERSION=$(stat --version | head -1 | cut -d" " -f4)
    STAT_BROKE="5.3.0"
    echo '<<<nfsmounts>>>'
    sed -n '/ nfs4\? /s/[^ ]* \([^ ]*\) .*/\1/p' < /proc/mounts |
        sed 's/\\040/ /g' |
        while read MP
 	do
 	 if [ $STAT_VERSION != $STAT_BROKE ]; then
 	    waitmax -s 9 2 stat -f -c "$MP ok %b %f %a %s" "$MP" || \
 		echo "$MP hanging 0 0 0 0"
 	 else
 	    waitmax -s 9 2 stat -f -c "$MP ok %b %f %a %s" "$MP" && \
 	    printf '\n'|| echo "$MP hanging 0 0 0 0"
 	 fi
 	done
    echo '<<<cifsmounts>>>'
    sed -n '/ cifs\? /s/[^ ]* \([^ ]*\) .*/\1/p' < /proc/mounts |
        sed 's/\\040/ /g' |
        while read MP
        do
         if [ $STAT_VERSION != $STAT_BROKE ]; then
            waitmax -s 9 2 stat -f -c "$MP ok %b %f %a %s" "$MP" || \
                echo "$MP hanging 0 0 0 0"
         else
            waitmax -s 9 2 stat -f -c "$MP ok %b %f %a %s" "$MP" && \
            printf '\n'|| echo "$MP hanging 0 0 0 0"
         fi
        done
 fi
 # Check mount options. Filesystems may switch to 'ro' in case
 # of a read error.
 echo '<<<mounts>>>'
 grep ^/dev < /proc/mounts
 # processes including username, without kernel processes
 echo '<<<ps>>>'
 ps ax -o user,vsz,rss,cputime,pid,command --columns 10000 | sed -e 1d -e 's/ *\([^ ]*\) *\([^ ]*\) *\([^ ]*\) *\([^ ]*\) *\([^ ]*\) */(\1,\2,\3,\4,\5) /'
 # Memory usage
 echo '<<<mem>>>'
 egrep -v '^Swap:|^Mem:|total:' < /proc/meminfo
 # Load and number of processes
 echo '<<<cpu>>>'
 echo "$(cat /proc/loadavg) $(grep -E '^CPU|^processor' < /proc/cpuinfo | wc -l)"
 # Uptime
 echo '<<<uptime>>>'
 cat /proc/uptime
 # New variant: Information about speed and state in one section
 echo '<<<lnx_if:sep(58)>>>'
 sed 1,2d /proc/net/dev
 if type ethtool > /dev/null
 then
    for eth in $(sed -e 1,2d < /proc/net/dev | cut -d':' -f1 | sort)
    do
        echo "[$eth]"
        ethtool $eth | egrep '(Speed|Duplex|Link detected|Auto-negotiation):'
        echo -en "\tAddress: " ; cat /sys/class/net/$eth/address ; echo
    done
 fi
 # Current state of bonding interfaces
 if [ -e /proc/net/bonding ] ; then
    echo '<<<lnx_bonding:sep(58)>>>'
    pushd /proc/net/bonding > /dev/null ; head -v -n 1000 * ; popd
 fi
 # Same for Open vSwitch bonding
 if type ovs-appctl > /dev/null ; then
    echo '<<<ovs_bonding:sep(58)>>>'
    for bond in $(ovs-appctl bond/list | sed -e 1d | cut -f2) ; do
        echo "[$bond]"
        ovs-appctl bond/show $bond
    done
 fi
 # Number of TCP connections in the various states
 echo '<<<tcp_conn_stats>>>'
 # waitmax 10 netstat -nt | awk ' /^tcp/ { c[$6]++; } END { for (x in c) { print x, c[x]; } }'
 # New implementation: netstat is very slow for large TCP tables
 cat /proc/net/tcp /proc/net/tcp6 2>/dev/null | awk ' /:/ { c[$4]++; } END { for (x in c) { print x, c[x]; } }'
 # Linux Multipathing
 if type multipath >/dev/null ; then
    echo '<<<multipath>>>'
    multipath -l
 fi
 # Performancecounter Platten
 echo '<<<diskstat>>>'
 date +%s
 egrep ' (x?[shv]d[a-z]*|cciss/c[0-9]+d[0-9]+|emcpower[a-z]+|dm-[0-9]+|VxVM.*|mmcblk.*) ' < /proc/diskstats
 if type dmsetup >/dev/null ; then
    echo '[dmsetup_info]'
    dmsetup info -c --noheadings --separator ' ' -o name,devno,vg_name,lv_name
 fi
 if [ -d /dev/vx/dsk ] ; then
    echo '[vx_dsk]'
    stat -c "%t %T %n" /dev/vx/dsk/*/*
 fi
 # Performancecounter Kernel
 echo '<<<kernel>>>'
 date +%s
 cat /proc/vmstat /proc/stat
 # Hardware sensors via IPMI (need ipmitool)
 if type ipmitool > /dev/null
 then
    run_cached -s ipmi 300 "ipmitool sensor list | grep -v 'command failed' | sed -e 's/ *| */|/g' -e 's/ /_/g' -e 's/_*"'$'"//' -e 's/|/ /g' | egrep -v '^[^ ]+ na ' | grep -v ' discrete '"
 fi
 # IPMI data via ipmi-sensors (of freeipmi). Please make sure, that if you
 # have installed freeipmi that IPMI is really support by your hardware.
 if type ipmi-sensors >/dev/null
 then
    echo '<<<ipmi_sensors>>>'
    # Newer ipmi-sensors version have new output format; Legacy format can be used
    if ipmi-sensors --help | grep -q legacy-output; then
        IPMI_FORMAT="--legacy-output"
    else
        IPMI_FORMAT=""
    fi
    # At least with ipmi-sensoirs 0.7.16 this group is Power_Unit instead of "Power Unit"
    run_cached -s ipmi_sensors 300 "for class in Temperature Power_Unit Fan
    do
        ipmi-sensors $IPMI_FORMAT --sdr-cache-directory /var/cache -g "$class" | sed -e 's/ /_/g' -e 's/:_\?/ /g' -e 's@ \([^(]*\)_(\([^)]*\))@ \2_\1@'
        # In case of a timeout immediately leave loop.
        if [ $? = 255 ] ; then break ; fi
    done"
 fi
 # RAID status of Linux software RAID
 echo '<<<md>>>'
 cat /proc/mdstat
 # RAID status of Linux RAID via device mapper
 if type dmraid >/dev/null && DMSTATUS=$(dmraid -r)
 then
    echo '<<<dmraid>>>'
    # Output name and status
    dmraid -s | grep -e ^name -e ^status
    # Output disk names of the RAID disks
    DISKS=$(echo "$DMSTATUS" | cut -f1 -d\:)
    for disk in $DISKS ; do
        device=$(cat /sys/block/$(basename $disk)/device/model )
        status=$(echo "$DMSTATUS" | grep ^${disk})
        echo "$status Model: $device"
    done
 fi
 # RAID status of LSI controllers via cfggen
 if type cfggen > /dev/null ; then
   echo '<<<lsi>>>'
   cfggen 0 DISPLAY | egrep '(Target ID|State|Volume ID|Status of volume)[[:space:]]*:' | sed -e 's/ *//g' -e 's/:/ /'
 fi
 # RAID status of LSI MegaRAID controller via MegaCli. You can download that tool from:
 # http://www.lsi.com/downloads/Public/MegaRAID%20Common%20Files/8.02.16_MegaCLI.zip
 if type MegaCli >/dev/null ; then
    MegaCli_bin="MegaCli"
 elif type MegaCli64 >/dev/null ; then
    MegaCli_bin="MegaCli64"
 elif type megacli >/dev/null ; then
    MegaCli_bin="megacli"
 else
    MegaCli_bin="unknown"
 fi
 if [ "$MegaCli_bin" != "unknown" ]; then
    echo '<<<megaraid_pdisks>>>'
    for part in $($MegaCli_bin -EncInfo -aALL -NoLog < /dev/null \
        | sed -rn 's/:/ /g; s/[[:space:]]+/ /g; s/^ //; s/ $//; s/Number of enclosures on adapter ([0-9]+).*/adapter \1/g; /^(Enclosure|Device ID|adapter) [0-9]+$/ p'); do
        [ $part = adapter ] && echo ""
        [ $part = 'Enclosure' ] && echo -ne "\ndev2enc"
        echo -n " $part"
    done
    echo
    $MegaCli_bin -PDList -aALL -NoLog < /dev/null | egrep 'Enclosure|Raw Size|Slot Number|Device Id|Firmware state|Inquiry|Adapter'
    echo '<<<megaraid_ldisks>>>'
    $MegaCli_bin -LDInfo -Lall -aALL -NoLog < /dev/null | egrep 'Size|State|Number|Adapter|Virtual'
    echo '<<<megaraid_bbu>>>'
    $MegaCli_bin -AdpBbuCmd -GetBbuStatus -aALL -NoLog < /dev/null | grep -v Exit
 fi
 # RAID status of 3WARE disk controller (by Radoslaw Bak)
 if type tw_cli > /dev/null ; then
    for C in $(tw_cli show | awk 'NR < 4 { next } { print $1 }'); do
        echo '<<<3ware_info>>>'
        tw_cli /$C show all | egrep 'Model =|Firmware|Serial'
        echo '<<<3ware_disks>>>'
        tw_cli /$C show drivestatus | egrep 'p[0-9]' | sed "s/^/$C\//"
        echo '<<<3ware_units>>>'
        tw_cli /$C show unitstatus | egrep 'u[0-9]' | sed "s/^/$C\//"
    done
 fi
 # RAID controllers from areca (Taiwan)
 # cli64 can be found at ftp://ftp.areca.com.tw/RaidCards/AP_Drivers/Linux/CLI/
 if type cli64 >/dev/null ; then
    run_cached -s arc_raid_status 300 "cli64 rsf info | tail -n +3 | head -n -2"
 fi
 # VirtualBox Guests. Section must always been output. Otherwise the
 # check would not be executed in case no guest additions are installed.
 # And that is something the check wants to detect
 echo '<<<vbox_guest>>>'
 if type VBoxControl >/dev/null 2>&1 ; then
    VBoxControl -nologo guestproperty enumerate | cut -d, -f1,2
    [ ${PIPESTATUS[0]} = 0 ] || echo "ERROR"
 fi
 # OpenVPN Clients. Currently we assume that the configuration # is in
 # /etc/openvpn. We might find a safer way to find the configuration later.
 if [ -e /etc/openvpn/openvpn-status.log ] ; then
    echo '<<<openvpn_clients:sep(44)>>>'
    sed -n -e '/CLIENT LIST/,/ROUTING TABLE/p' < /etc/openvpn/openvpn-status.log  | sed -e 1,3d -e '$d'
 fi
 # Time synchronization with NTP
 if type ntpq > /dev/null 2>&1 ; then
   # remove heading, make first column space separated
   run_cached -s ntp 30 "waitmax 5 ntpq -np | sed -e 1,2d -e 's/^\(.\)/\1 /' -e 's/^ /%/'"
 fi
 # Time synchronization with Chrony
 if type chronyc > /dev/null 2>&1 ; then
    # Force successful exit code. Otherwise section will be missing if daemon not running
    run_cached -s chrony 30 "waitmax 5 chronyc tracking || true"
 fi
 if type nvidia-settings >/dev/null && [ -S /tmp/.X11-unix/X0 ]
 then
    echo '<<<nvidia>>>'
    for var in GPUErrors GPUCoreTemp
    do
        DISPLAY=:0 waitmax 2 nvidia-settings -t -q $var | sed "s/^/$var: /"
    done
 fi
 if [ -e /proc/drbd ]; then
  echo '<<<drbd>>>'
  cat /proc/drbd
 fi
 # Status of CUPS printer queues
 if type lpstat > /dev/null 2>&1; then
    if pgrep cups > /dev/null 2>&1; then
        echo '<<<cups_queues>>>'
        CPRINTCONF=/etc/cups/printers.conf
        if [ -r "$CPRINTCONF" ] ; then
            LOCAL_PRINTERS=$(grep -E "<(Default)?Printer .*>" $CPRINTCONF | awk '{print $2}' | sed -e 's/>//')
            lpstat -p | while read LINE
            do
                PRINTER=$(echo $LINE | awk '{print $2}')
                if echo "$LOCAL_PRINTERS" | grep -q "$PRINTER"; then
                    echo $LINE
                fi
            done
            echo '---'
            lpstat -o | while read LINE
            do
                PRINTER=${LINE%%-*}
                if echo "$LOCAL_PRINTERS" | grep -q "$PRINTER"; then
                    echo $LINE
                fi
            done
        else
            lpstat -p
            echo '---'
            lpstat -o | sort
        fi
    fi
 fi
 # Heartbeat monitoring
 # Different handling for heartbeat clusters with and without CRM
 # for the resource state
 if [ -S /var/run/heartbeat/crm/cib_ro -o -S /var/run/crm/cib_ro ] || pgrep crmd > /dev/null 2>&1; then
  echo '<<<heartbeat_crm>>>'
  crm_mon -1 -r | grep -v ^$ | sed 's/^ //; /^\sResource Group:/,$ s/^\s//; s/^\s/_/g'
 fi
 if type cl_status > /dev/null 2>&1; then
  echo '<<<heartbeat_rscstatus>>>'
  cl_status rscstatus
  echo '<<<heartbeat_nodes>>>'
  for NODE in $(cl_status listnodes); do
    if [ $NODE != $(echo $HOSTNAME | tr 'A-Z' 'a-z') ]; then
      STATUS=$(cl_status nodestatus $NODE)
      echo -n "$NODE $STATUS"
      for LINK in $(cl_status listhblinks $NODE 2>/dev/null); do
        echo -n " $LINK $(cl_status hblinkstatus $NODE $LINK)"
      done
      echo
    fi
  done
 fi
 # Postfix mailqueue monitoring
 #
 # Only handle mailq when postfix user is present. The mailq command is also
 # available when postfix is not installed. But it produces different outputs
 # which are not handled by the check at the moment. So try to filter out the
 # systems not using postfix by searching for the postfix user.a
 #
 # Cannot take the whole outout. This could produce several MB of agent output
 # on blocking queues.
 # Only handle the last 6 lines (includes the summary line at the bottom and
 # the last message in the queue. The last message is not used at the moment
 # but it could be used to get the timestamp of the last message.
 if type postconf >/dev/null ; then
    echo '<<<postfix_mailq>>>'
    postfix_queue_dir=$(postconf -h queue_directory)
    postfix_count=$(find $postfix_queue_dir/deferred -type f | wc -l)
    postfix_size=$(du -ks $postfix_queue_dir/deferred | awk '{print $1 }')
    if [ $postfix_count -gt 0 ]
    then
       echo -- $postfix_size Kbytes in $postfix_count Requests.
    else
       echo Mail queue is empty
    fi
 elif [ -x /usr/sbin/ssmtp ] ; then
    echo '<<<postfix_mailq>>>'
    mailq 2>&1 | sed 's/^[^:]*: \(.*\)/\1/' | tail -n 6
 fi
 #Check status of qmail mailqueue
 if type qmail-qstat >/dev/null
 then
   echo "<<<qmail_stats>>>"
   qmail-qstat
 fi
 # Check status of OMD sites
 if type omd >/dev/null
 then
    run_cached -s omd_status 60 "omd status --bare --auto"
 fi
 # Welcome the ZFS check on Linux
 # We do not endorse running ZFS on linux if your vendor doesnt support it ;)
 # check zpool status
 if type zpool >/dev/null; then
   echo "<<<zpool_status>>>"
   zpool status -x
 fi
 # Fileinfo-Check: put patterns for files into /etc/check_mk/fileinfo.cfg
 if [ -r "$MK_CONFDIR/fileinfo.cfg" ] ; then
    echo '<<<fileinfo:sep(124)>>>'
    date +%s
    stat -c "%n|%s|%Y" $(cat "$MK_CONFDIR/fileinfo.cfg")
 fi
 # Get stats about OMD monitoring cores running on this machine.
 # Since cd is a shell builtin the check does not affect the performance
 # on non-OMD machines.
 if cd /omd/sites
 then
    echo '<<<livestatus_status:sep(59)>>>'
    for site in *
    do
        if [ -S "/omd/sites/$site/tmp/run/live" ] ; then
            echo "[$site]"
            echo -e "GET status" | waitmax 3 /omd/sites/$site/bin/unixcat /omd/sites/$site/tmp/run/live
        fi
    done
 fi
 # Get statistics about monitored jobs. Below the job directory there
 # is a sub directory per user that ran a job. That directory must be
 # owned by the user so that a symlink or hardlink attack for reading
 # arbitrary files can be avoided.
 if pushd $MK_VARDIR/job >/dev/null; then
    echo '<<<job>>>'
    for username in *
    do
        if [ -d "$username" ] && cd "$username" ; then
            su "$username" -c "head -n -0 -v *"
            cd ..
        fi
    done
    popd > /dev/null
 fi
 # Gather thermal information provided e.g. by acpi
 # At the moment only supporting thermal sensors
 if ls /sys/class/thermal/thermal_zone* >/dev/null 2>&1; then
    echo '<<<lnx_thermal>>>'
    for F in /sys/class/thermal/thermal_zone*; do
        echo -n "${F##*/} "
        if [ ! -e $F/mode ] ; then echo -n "- " ; fi
        cat $F/{mode,type,temp,trip_point_*} | tr \\n " "
        echo
    done
 fi
 # Libelle Business Shadow
 if type trd >/dev/null; then
   echo "<<<libelle_business_shadow:sep(58)>>>"
   trd -s
 fi
 # MK's Remote Plugin Executor
 if [ -e "$MK_CONFDIR/mrpe.cfg" ]
 then
    echo '<<<mrpe>>>'
    grep -Ev '^[[:space:]]*($|#)' "$MK_CONFDIR/mrpe.cfg" | \
    while read descr cmdline
    do
        PLUGIN=${cmdline%% *}
        OUTPUT=$(eval "$cmdline")
        echo -n "(${PLUGIN##*/}) $descr $? $OUTPUT" | tr \\n \\1
        echo
    done
 fi
 # Local checks
 echo '<<<local>>>'
 if cd $LOCALDIR ; then
    for skript in $(ls) ; do
        if [ -f "$skript" -a -x "$skript" ] ; then
            ./$skript
        fi
    done
    # Call some plugins only every X'th minute
    for skript in [1-9]*/* ; do
        if [ -x "$skript" ] ; then
            run_cached local_${skript//\//\\} ${skript%/*} "$skript"
        fi
    done
 fi
 # Plugins
 if cd $PLUGINSDIR ; then
    for skript in $(ls) ; do
        if [ -f "$skript" -a -x "$skript" ] ; then
            ./$skript
        fi
    done
    # Call some plugins only every Xth minute
    for skript in [1-9]*/* ; do
        if [ -x "$skript" ] ; then
            run_cached plugins_${skript//\//\\} ${skript%/*} "$skript"
        fi
    done
 fi
 # Agent output snippets created by cronjobs, etc.
 if [ -d "$SPOOLDIR" ]
 then
    pushd "$SPOOLDIR" > /dev/null
    now=$(date +%s)
    for file in *
    do
        # output every file in this directory. If the file is prefixed
        # with a number, then that number is the maximum age of the
        # file in seconds. If the file is older than that, it is ignored.
        maxage=""
        part="$file"
        # Each away all digits from the front of the filename and
        # collect them in the variable maxage.
        while [ "${part/#[0-9]/}" != "$part" ]
        do
            maxage=$maxage${part:0:1}
            part=${part:1}
        done
        # If there is at least one digit, than we honor that.
        if [ "$maxage" ] ; then
            mtime=$(stat -c %Y "$file")
            if [ $((now - mtime)) -gt $maxage ] ; then
                continue
            fi
        fi
        # Output the file
        cat "$file"
    done
    popd > /dev/null
 fi
@@ -0,0 +1,114 @@
 #!/usr/bin/env bash
 # Detects which OS and if it is Linux then it will detect which Linux Distribution.
 OS=`uname -s`
 REV=`uname -r`
 MACH=`uname -m`
 if [ "${OS}" = "SunOS" ] ; then
  OS=Solaris
  ARCH=`uname -p`
  OSSTR="${OS} ${REV}(${ARCH} `uname -v`)"
 elif [ "${OS}" = "AIX" ] ; then
  OSSTR="${OS} `oslevel` (`oslevel -r`)"
 elif [ "${OS}" = "Linux" ] ; then
  KERNEL=`uname -r`
  if [ -f /etc/fedora-release ]; then
    DIST=$(cat /etc/fedora-release | awk '{print $1}')
    REV=`cat /etc/fedora-release | sed s/.*release\ // | sed s/\ .*//`
  elif [ -f /etc/redhat-release ] ; then
    DIST=$(cat /etc/redhat-release | awk '{print $1}')
    if [ "${DIST}" = "CentOS" ]; then
      DIST="CentOS"
    elif [ "${DIST}" = "Mandriva" ]; then
      DIST="Mandriva"
      PSEUDONAME=`cat /etc/mandriva-release | sed s/.*\(// | sed s/\)//`
      REV=`cat /etc/mandriva-release | sed s/.*release\ // | sed s/\ .*//`
    elif [ -f /etc/oracle-release ]; then
      DIST="Oracle"
    else
      DIST="RedHat"
    fi
    PSEUDONAME=`cat /etc/redhat-release | sed s/.*\(// | sed s/\)//`
    REV=`cat /etc/redhat-release | sed s/.*release\ // | sed s/\ .*//`
  elif [ -f /etc/mandrake-release ] ; then
    DIST='Mandrake'
    PSEUDONAME=`cat /etc/mandrake-release | sed s/.*\(// | sed s/\)//`
    REV=`cat /etc/mandrake-release | sed s/.*release\ // | sed s/\ .*//`
  elif [ -f /etc/devuan_version ] ; then
    DIST="Devuan `cat /etc/devuan_version`"
    REV=""
  elif [ -f /etc/debian_version ] ; then
    DIST="Debian `cat /etc/debian_version`"
    REV=""
    ID=`lsb_release -i | awk -F ':' '{print $2}' | sed 's/	//g'`
    if [ "${ID}" = "Raspbian" ] ; then
      DIST="Raspbian `cat /etc/debian_version`"
    fi
  elif [ -f /etc/gentoo-release ] ; then
    DIST="Gentoo"
    REV=$(tr -d '[[:alpha:]]' </etc/gentoo-release | tr -d " ")
  elif [ -f /etc/arch-release ] ; then
    DIST="Arch Linux"
    REV="" # Omit version since Arch Linux uses rolling releases
    IGNORE_LSB=1 # /etc/lsb-release would overwrite $REV with "rolling"
  elif [ -f /etc/os-release ] ; then
    DIST=$(grep '^NAME=' /etc/os-release | cut -d= -f2- | tr -d '"')
    REV=$(grep '^VERSION_ID=' /etc/os-release | cut -d= -f2- | tr -d '"')
  elif [ -f /etc/openwrt_version ] ; then
    DIST="OpenWrt"
    REV=$(cat /etc/openwrt_version)
  elif [ -f /etc/pld-release ] ; then
    DIST=$(cat /etc/pld-release)
    REV=""
  elif [ -f /etc/SuSE-release ] ; then
    DIST=$(echo SLES $(grep VERSION /etc/SuSE-release | cut -d = -f 2 | tr -d " "))
    REV=$(echo SP$(grep PATCHLEVEL /etc/SuSE-release | cut -d = -f 2 | tr -d " "))
  fi
  if [ -f /etc/lsb-release -a "${IGNORE_LSB}" != 1 ] ; then
    LSB_DIST=$(lsb_release -si)
    LSB_REV=$(lsb_release -sr)
    if [ "$LSB_DIST" != "" ] ; then
      DIST=$LSB_DIST
    fi
    if [ "$LSB_REV" != "" ] ; then
      REV=$LSB_REV
    fi
  fi
  if [ "`uname -a | awk '{print $(NF)}'`" = "DD-WRT" ] ; then
    DIST="dd-wrt"
  fi
  if [ -n "${REV}" ]
  then
    OSSTR="${DIST} ${REV}"
  else
    OSSTR="${DIST}"
  fi
 elif [ "${OS}" = "Darwin" ] ; then
  if [ -f /usr/bin/sw_vers ] ; then
    OSSTR=`/usr/bin/sw_vers|grep -v Build|sed 's/^.*:.//'| tr "\n" ' '`
  fi
 elif [ "${OS}" = "FreeBSD" ] ; then
  OSSTR=`/usr/bin/uname -mior`
 fi
 echo ${OSSTR}
@@ -0,0 +1,9 @@
 #!/usr/bin/env bash
 echo '<<<dmi>>>'
 # requires dmidecode
 for FIELD in bios-vendor bios-version bios-release-date system-manufacturer system-product-name system-version system-serial-number system-uuid baseboard-manufacturer baseboard-product-name baseboard-version baseboard-serial-number baseboard-asset-tag chassis-manufacturer chassis-type chassis-version chassis-serial-number chassis-asset-tag processor-family processor-manufacturer processor-version processor-frequency
 do
  echo $FIELD="$(dmidecode -s $FIELD | grep -v '^#')"
 done
@@ -0,0 +1,22 @@
 #!/bin/bash
 # Cache the file for 30 minutes
 # If you want to override this, put the command in cron.
 # We cache because it is a 1sec delay, which is painful for the poller
 if [ -x /usr/bin/dpkg-query ]; then
  DATE=$(date +%s)
  FILE=/var/cache/librenms/agent-local-dpkg
  [ -d /var/cache/librenms ] || mkdir -p /var/cache/librenms
  if [ ! -e $FILE ]; then
    dpkg-query -W --showformat='${Status} ${Package} ${Version} ${Architecture} ${Installed-Size}\n'|grep " installed "|cut -d\  -f4- > $FILE
  fi
  FILEMTIME=$(stat -c %Y $FILE)
  FILEAGE=$(($DATE-$FILEMTIME))
  if [ $FILEAGE -gt 1800 ]; then
    dpkg-query -W --showformat='${Status} ${Package} ${Version} ${Architecture} ${Installed-Size}\n'|grep " installed "|cut -d\  -f4- > $FILE
  fi
  echo "<<<dpkg>>>"
  cat $FILE
 fi
@@ -0,0 +1,34 @@
 #!/bin/sh
 # Please make sure the paths below are correct.
 # Alternatively you can put them in $0.conf, meaning if you've named
 # this script ntp-client then it must go in ntp-client.conf .
 #
 # NTPQV output version of "ntpq -c rv"
 # Version 4 is the most common and up to date version.
 #
 # If you are unsure, which to set, run this script and make sure that
 # the JSON output variables match that in "ntpq -c rv".
 #
 ################################################################
 # Don't change anything unless you know what are you doing     #
 ################################################################
 BIN_NTPQ='/usr/bin/env ntpq'
 BIN_GREP='/usr/bin/env grep'
 BIN_AWK='/usr/bin/env awk'
 CONFIG=$0".conf"
 if [ -f "$CONFIG" ]; then
    # shellcheck disable=SC1090
    . "$CONFIG"
 fi
 NTP_OFFSET=$($BIN_NTPQ -c rv | $BIN_GREP "offset" | $BIN_AWK -Foffset= '{print $2}' | $BIN_AWK -F, '{print $1}')
 NTP_FREQUENCY=$($BIN_NTPQ -c rv | $BIN_GREP "frequency" | $BIN_AWK -Ffrequency= '{print $2}' | $BIN_AWK -F, '{print $1}')
 NTP_SYS_JITTER=$($BIN_NTPQ -c rv | $BIN_GREP "sys_jitter" | $BIN_AWK -Fsys_jitter= '{print $2}' | $BIN_AWK -F, '{print $1}')
 NTP_CLK_JITTER=$($BIN_NTPQ -c rv | $BIN_GREP "clk_jitter" | $BIN_AWK -Fclk_jitter= '{print $2}' | $BIN_AWK -F, '{print $1}')
 NTP_WANDER=$($BIN_NTPQ -c rv | $BIN_GREP "clk_wander" | $BIN_AWK -Fclk_wander= '{print $2}' | $BIN_AWK -F, '{print $1}')
 NTP_VERSION=$($BIN_NTPQ -c rv | $BIN_GREP "version" | $BIN_AWK -F'ntpd ' '{print $2}' | $BIN_AWK -F. '{print $1}')
 echo '{"data":{"offset":"'"$NTP_OFFSET"'","frequency":"'"$NTP_FREQUENCY"'","sys_jitter":"'"$NTP_SYS_JITTER"'","clk_jitter":"'"$NTP_CLK_JITTER"'","clk_wander":"'"$NTP_WANDER"'"},"version":"'"$NTP_VERSION"'","error":"0","errorString":""}'
 exit 0
@@ -0,0 +1,89 @@
 #!/bin/sh
 # Please make sure the paths below are correct.
 # Alternatively you can put them in $0.conf, meaning if you've named
 # this script ntp-client.sh then it must go in ntp-client.sh.conf .
 #
 # NTPQV output version of "ntpq -c rv" 
 # p1 DD-WRT and some other outdated linux distros
 # p11 FreeBSD 11 and any linux distro that is up to date
 #
 # If you are unsure, which to set, run this script and make sure that
 # the JSON output variables match that in "ntpq -c rv".
 #
 BIN_NTPD='/usr/bin/env ntpd'
 BIN_NTPQ='/usr/bin/env ntpq'
 BIN_NTPDC='/usr/bin/env ntpdc'
 BIN_GREP='/usr/bin/env grep'
 BIN_TR='/usr/bin/env tr'
 BIN_CUT='/usr/bin/env cut'
 BIN_SED="/usr/bin/env sed"
 BIN_AWK='/usr/bin/env awk'
 NTPQV="p11"
 ################################################################
 # Don't change anything unless you know what are you doing     #
 ################################################################
 CONFIG=$0".conf"
 if [ -f $CONFIG ]; then
    . $CONFIG
 fi
 VERSION=1
 STRATUM=`$BIN_NTPQ -c rv | $BIN_GREP -Eow "stratum=[0-9]+" | $BIN_CUT -d "=" -f 2`
 # parse the ntpq info that requires version specific info
 NTPQ_RAW=`$BIN_NTPQ -c rv | $BIN_GREP jitter | $BIN_SED 's/[[:alpha:]=,_]/ /g'`
 if [ $NTPQV = "p11" ]; then
 	OFFSET=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $3}'`
 	FREQUENCY=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $4}'`
 	SYS_JITTER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $5}'`
 	CLK_JITTER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $6}'`
 	CLK_WANDER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $7}'`
 fi
 if [ $NTPQV = "p1" ]; then
 	OFFSET=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $2}'`
 	FREQUENCY=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $3}'`
 	SYS_JITTER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $4}'`
 	CLK_JITTER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $5}'`
 	CLK_WANDER=`echo $NTPQ_RAW | $BIN_AWK -F ' ' '{print $6}'`
 fi
 VER=`$BIN_NTPD --version`
 if [ "$VER" = '4.2.6p5' ]; then
  USECMD=`echo $BIN_NTPDC -c iostats`
 else
  USECMD=`echo $BIN_NTPQ -c iostats localhost`
 fi
 CMD2=`$USECMD | $BIN_TR -d ' ' | $BIN_CUT -d : -f 2 | $BIN_TR '\n' ' '`
 TIMESINCERESET=`echo $CMD2 | $BIN_AWK -F ' ' '{print $1}'`
 RECEIVEDBUFFERS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $2}'`
 FREERECEIVEBUFFERS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $3}'`
 USEDRECEIVEBUFFERS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $4}'`
 LOWWATERREFILLS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $5}'`
 DROPPEDPACKETS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $6}'`
 IGNOREDPACKETS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $7}'`
 RECEIVEDPACKETS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $8}'`
 PACKETSSENT=`echo $CMD2 | $BIN_AWK -F ' ' '{print $9}'`
 PACKETSENDFAILURES=`echo $CMD2 | $BIN_AWK -F ' ' '{print $10}'`
 INPUTWAKEUPS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $11}'`
 USEFULINPUTWAKEUPS=`echo $CMD2 | $BIN_AWK -F ' ' '{print $12}'`
 echo '{"data":{"offset":"'$OFFSET\
 '","frequency":"'$FREQUENCY\
 '","sys_jitter":"'$SYS_JITTER\
 '","clk_jitter":"'$CLK_JITTER\
 '","clk_wander":"'$CLK_WANDER\
 '","stratum":"'$STRATUM\
 '","time_since_reset":"'$TIMESINCERESET\
 '","receive_buffers":"'$RECEIVEDBUFFERS\
 '","free_receive_buffers":"'$FREERECEIVEBUFFERS\
 '","used_receive_buffers":"'$USEDRECEIVEBUFFERS\
 '","low_water_refills":"'$LOWWATERREFILLS\
 '","dropped_packets":"'$DROPPEDPACKETS\
 '","ignored_packets":"'$IGNOREDPACKETS\
 '","received_packets":"'$RECEIVEDPACKETS\
 '","packets_sent":"'$PACKETSSENT\
 '","packet_send_failures":"'$PACKETSENDFAILURES\
 '","input_wakeups":"'$PACKETSENDFAILURES\
 '","useful_input_wakeups":"'$USEFULINPUTWAKEUPS\
 '"},"error":"0","errorString":"","version":"'$VERSION'"}'
@@ -0,0 +1,73 @@
 #!/usr/bin/env bash
 ################################################################
 # copy this script to /etc/snmp/ and make it executable:       #
 # chmod +x /etc/snmp/os-updates.sh                             #
 # ------------------------------------------------------------ #
 # edit your snmpd.conf and include:                            #
 # extend osupdate /opt/os-updates.sh 			       #
 #--------------------------------------------------------------#
 # restart snmpd and activate the app for desired host          #
 #--------------------------------------------------------------#
 # please make sure you have the path/binaries below            #
 ################################################################ 
 BIN_WC='/usr/bin/wc'
 BIN_GREP='/bin/grep'
 CMD_GREP='-c'
 CMD_WC='-l'
 BIN_ZYPPER='/usr/bin/zypper'
 CMD_ZYPPER='-q lu'
 BIN_YUM='/usr/bin/yum'
 CMD_YUM='-q check-update'
 BIN_DNF='/usr/bin/dnf'
 CMD_DNF='-q check-update'
 BIN_APT='/usr/bin/apt-get'
 CMD_APT='-qq -s upgrade'
 BIN_PACMAN='/usr/bin/pacman'
 CMD_PACMAN='-Sup'
 ################################################################
 # Don't change anything unless you know what are you doing     #
 ################################################################
 if [ -f $BIN_ZYPPER ]; then
    # OpenSUSE
    UPDATES=`$BIN_ZYPPER $CMD_ZYPPER | $BIN_WC $CMD_WC`
    if [ $UPDATES -ge 2 ]; then
        echo $(($UPDATES-2));
    else
        echo "0";
    fi
 elif [ -f $BIN_DNF ]; then
    # Fedora
    UPDATES=`$BIN_DNF $CMD_DNF | $BIN_WC $CMD_WC`
    if [ $UPDATES -ge 1 ]; then
        echo $(($UPDATES-1));
    else
        echo "0";
    fi
 elif [ -f $BIN_PACMAN ]; then
    # Arch
    UPDATES=`$BIN_PACMAN $CMD_PACMAN | $BIN_WC $CMD_WC`
    if [ $UPDATES -ge 1 ]; then
        echo $(($UPDATES-1));
    else
        echo "0";
    fi
 elif [ -f $BIN_YUM ]; then
    # CentOS / Redhat
    UPDATES=`$BIN_YUM $CMD_YUM | $BIN_WC $CMD_WC`
    if [ $UPDATES -ge 1 ]; then
        echo $(($UPDATES-1));
    else
        echo "0";
    fi
 elif [ -f $BIN_APT ]; then
    # Debian / Devuan / Ubuntu
    UPDATES=`$BIN_APT $CMD_APT | $BIN_GREP $CMD_GREP 'Inst'`
    if [ $UPDATES -ge 1 ]; then
        echo $UPDATES;
    else
        echo "0";
    fi
 else
    echo "0";
 fi
@@ -0,0 +1,13 @@
 #!/bin/bash
 #Written by Valec 2006. Steal and share.
 #Get postfix queue lengths
 #extend mailq /opt/observer/scripts/getmailq.sh
 QUEUES="incoming active deferred hold"
 for i in $QUEUES; do
        COUNT=$(qshape "$i" | grep TOTAL | awk '{print $2}')
        printf "$COUNT\n"
 done
@@ -0,0 +1,548 @@
 #!/usr/bin/env perl
 # add this to your snmpd.conf file as below
 # extend postfixdetailed /etc/snmp/postfixdetailed
 # The cache file to use.
 my $cache='/var/cache/postfixdetailed';
 # the location of pflogsumm
 my $pflogsumm='/usr/bin/env pflogsumm';
 #totals
 #    847   received                 = received
 #    852   delivered                = delivered
 #      0   forwarded                = forwarded
 #      3   deferred  (67  deferrals)= deferred
 #      0   bounced                  = bounced
 #    593   rejected (41%)           = rejected
 #      0   reject warnings          = rejectw
 #      0   held                     = held
 #      0   discarded (0%)           = discarded
 #  16899k  bytes received           = bytesr
 #  18009k  bytes delivered          = bytesd
 #    415   senders                  = senders
 #    266   sending hosts/domains    = sendinghd
 #     15   recipients               = recipients
 #      9   recipient hosts/domains  = recipienthd
 ######message deferral detail
 #Connection refused  = deferralcr
 #Host is down  = deferralhid
 ########message reject detail
 #Client host rejected                                     = chr
 #Helo command rejected: need fully-qualified hostname     = hcrnfqh
 #Sender address rejected: Domain not found                = sardnf
 #Sender address rejected: not owned by user               = sarnobu
 #blocked using                                            = bu
 #Recipient address rejected: User unknown                 = raruu
 #Helo command rejected: Invalid name                      = hcrin
 #Sender address rejected: need fully-qualified address    = sarnfqa
 #Recipient address rejected: Domain not found             = rardnf
 #Recipient address rejected: need fully-qualified address = rarnfqa
 #Improper use of SMTP command pipelining                  = iuscp
 #Message size exceeds fixed limit                         = msefl
 #Server configuration error                               = sce
 #Server configuration problem                             = scp
 #unknown reject reason                                    = urr
 my $old='';
 #reads in the old data if it exists
 if ( -f $cache ){
 	open(my $fh, "<", $cache) or die "Can't open '".$cache."'";
 	# if this is over 2048, something is most likely wrong
 	read($fh , $old , 2048);
 	close($fh);
 }
 my ( $received,
 	 $delivered,
 	 $forwarded,
 	 $deferred,
 	 $bounced,
 	 $rejected,
 	 $rejectw,
 	 $held,
 	 $discarded,
 	 $bytesr,
 	 $bytesd,
 	 $senders,
 	 $sendinghd,
 	 $recipients,
 	 $recipienthd,
 	 $deferralcr,
 	 $deferralhid,
 	 $chr,
 	 $hcrnfqh,
 	 $sardnf,
 	 $sarnobu,
 	 $bu,
 	 $raruu,
 	 $hcrin,
 	 $sarnfqa,
 	 $rardnf,
 	 $rarnfqa,
 	 $iuscp,
 	 $sce,
 	 $scp,
 	 $urr,
 	 $msefl) = split ( /\n/, $old );
 if ( ! defined( $received ) ){ $received=0; }
 if ( ! defined( $delivered ) ){ $delivered=0; }
 if ( ! defined( $forwarded ) ){ $forwarded=0; }
 if ( ! defined( $deferred ) ){ $deferred=0; }
 if ( ! defined( $bounced ) ){ $bounced=0; }
 if ( ! defined( $rejected ) ){ $rejected=0; }
 if ( ! defined( $rejectw ) ){ $rejectw=0; }
 if ( ! defined( $held ) ){ $held=0; }
 if ( ! defined( $discarded ) ){ $discarded=0; }
 if ( ! defined( $bytesr ) ){ $bytesr=0; }
 if ( ! defined( $bytesd ) ){ $bytesd=0; }
 if ( ! defined( $senders ) ){ $senders=0; }
 if ( ! defined( $sendinghd ) ){ $sendinghd=0; }
 if ( ! defined( $recipients ) ){ $recipients=0; }
 if ( ! defined( $recipienthd ) ){ $recipienthd=0; }
 if ( ! defined( $deferralcr ) ){ $deferralcr=0; }
 if ( ! defined( $deferralhid ) ){ $deferralhid=0; }
 if ( ! defined( $chr ) ){ $chr=0; }
 if ( ! defined( $hcrnfqh ) ){ $hcrnfqh=0; }
 if ( ! defined( $sardnf ) ){ $sardnf=0; }
 if ( ! defined( $sarnobu ) ){ $sarnobu=0; }
 if ( ! defined( $bu ) ){ $bu=0; }
 if ( ! defined( $raruu ) ){ $raruu=0; }
 if ( ! defined( $hcrin ) ){ $hcrin=0; }
 if ( ! defined( $sarnfqa ) ){ $sarnfqa=0; }
 if ( ! defined( $rardnf ) ){ $rardnf=0; }
 if ( ! defined( $rarnfqa ) ){ $rarnfqa=0; }
 if ( ! defined( $iuscp ) ){ $iuscp=0; }
 if ( ! defined( $msefl ) ){ $msefl=0; }
 if ( ! defined( $sce ) ){ $sce=0; }
 if ( ! defined( $scp ) ){ $scp=0; }
 if ( ! defined( $urr ) ){ $urr=0; }
 #init current variables
 my $receivedC=0;
 my $deliveredC=0;
 my $forwardedC=0;
 my $deferredC=0;
 my $bouncedC=0;
 my $rejectedC=0;
 my $rejectwC=0;
 my $heldC=0;
 my $discardedC=0;
 my $bytesrC=0;
 my $bytesdC=0;
 my $sendersC=0;
 my $sendinghdC=0;
 my $recipientsC=0;
 my $recipienthdC=0;
 my $deferralcrC=0;
 my $deferralhidC=0;
 my $hcrnfqhC=0;
 my $sardnfC=0;
 my $sarnobuC=0;
 my $buC=0;
 my $raruuC=0;
 my $hcrinC=0;
 my $sarnfqaC=0;
 my $rardnfC=0;
 my $rarnfqaC=0;
 my $iuscpC=0;
 my $mseflC=0;
 my $sceC=0;
 my $scpC=0;
 my $urrC=0;
 sub newValue{
 	my $old=$_[0];
 	my $new=$_[1];
 	#if new is undefined, just default to 0... this should never happen
 	if ( !defined( $new ) ){
 		warn('New not defined');
 		return 0;
 	}
 	#sets it to 0 if old is not defined
 	if ( !defined( $old ) ){
 		warn('Old not defined');
 		$old=0;
 	}
 	#make sure they are both numberic and if not set to zero
 	if( $old !~ /^[0123456789]*$/ ){
 		warn('Old not numeric');
 		$old=0;
 	}
 	if( $new !~ /^[0123456789]*$/ ){
 		warn('New not numeric');
 		$new=0;
 	}
 	#log rotation happened
 	if ( $old > $new ){
 		return $new;
 	};
 	return $new - $old;
 }
 my $output=`$pflogsumm /var/log/maillog`;
 #holds RBL values till the end when it is compared to the old one
 my $buNew=0;
 #holds client host rejected values till the end when it is compared to the old one
 my $chrNew=0;
 # holds recipient address rejected values till the end when it is compared to the old one
 my $raruuNew=0;
 #holds the current values for checking later
 my $current='';
 my @outputA=split( /\n/, $output );
 my $int=0;
 while ( defined( $outputA[$int] ) ){
 	my $line=$outputA[$int];
 	$line=~s/^ *//;
 	$line=~s/ +/ /g;
 	$line=~s/\)$//;
 	my $handled=0;
 	#received line
 	if ( ( $line =~ /[0123456789] received$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$receivedC=$line;
 		$received=newValue( $received, $line );
 		$handled=1;
 	}
 	#delivered line
 	if ( ( $line =~ /[0123456789] delivered$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$deliveredC=$line;
 		$delivered=newValue( $delivered, $line );
 		$handled=1;
 	}
 	#forward line
 	if ( ( $line =~ /[0123456789] forwarded$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$forwardedC=$line;
 		$forwarded=newValue( $forwarded, $line );
 		$handled=1;
 	}
 	#defereed line
 	if ( ( $line =~ /[0123456789] deferred \(/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$deferredC=$line;
 		$deferred=newValue( $deferred, $line );
 		$handled=1;
 	}
 	#bounced line
 	if ( ( $line =~ /[0123456789] bounced$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$bouncedC=$line;
 		$bounced=newValue( $bounced, $line );
 		$handled=1;
 	}
 	#rejected line
 	if ( ( $line =~ /[0123456789] rejected \(/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$rejectedC=$line;
 		$rejected=newValue( $rejected, $line );
 		$handled=1;
 	}
 	#reject warning line
 	if ( ( $line =~ /[0123456789] reject warnings/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$rejectwC=$line;
 		$rejectw=newValue( $rejectw, $line );
 		$handled=1;
 	}
 	#held line
 	if ( ( $line =~ /[0123456789] held$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$heldC=$line;
 		$held=newValue( $held, $line );
 		$handled=1;
 	}
 	#discarded line
 	if ( ( $line =~ /[0123456789] discarded \(/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$discardedC=$line;
 		$discarded=newValue( $discarded, $line );
 		$handled=1;
 	}
 	#bytes received line
 	if ( ( $line =~ /[0123456789kM] bytes received$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$line=~s/k/000/;
 		$line=~s/M/000000/;
 		$bytesrC=$line;
 		$bytesr=newValue( $bytesr, $line );
 		$handled=1;
 	}
 	#bytes delivered line
 	if ( ( $line =~ /[0123456789kM] bytes delivered$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$line=~s/k/000/;
 		$line=~s/M/000000/;
 		$bytesdC=$line;
 		$bytesd=newValue( $bytesd, $line );
 		$handled=1;
 	}
 	#senders line
 	if ( ( $line =~ /[0123456789] senders$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$sendersC=$line;
 		$senders=newValue( $senders, $line );
 		$handled=1;
 	}
 	#sendering hosts/domains line
 	if ( ( $line =~ /[0123456789] sending hosts\/domains$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$sendinghdC=$line;
 		$sendinghd=newValue( $sendinghd, $line );
 		$handled=1;
 	}
 	#recipients line
 	if ( ( $line =~ /[0123456789] recipients$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$recipientsC=$line;
 		$recipients=newValue( $recipients, $line );
 		$handled=1;
 	}
 	#recipients line
 	if ( ( $line =~ /[0123456789] recipient hosts\/domains$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$recipienthdC=$line;
 		$recipienthd=newValue( $recipienthd, $line );
 		$handled=1;
 	}
 	# deferrals connectios refused
 	if ( ( $line =~ /[0123456789] 25\: Connection refused$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$deferralcrC=$line;
 		$deferralcr=newValue( $deferralcr, $line );
 		$handled=1;
 	}
 	# deferrals Host is down
 	if ( ( $line =~ /Host is down$/ ) && ( ! $handled ) ){
 		$line=~s/ .*//;
 		$deferralcrC=$line;
 		$deferralhidC=$line;
 		$deferralhid=newValue( $deferralhid, $line );
 		$handled=1;
 	}
 	# Client host rejected
 	if ( ( $line =~ /Client host rejected/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$chrNew=$chrNew + $line;
 		$handled=1;
 	}
 	#Helo command rejected: need fully-qualified hostname
 	if ( ( $line =~ /Helo command rejected\: need fully\-qualified hostname/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$hcrnfqhC=$line;
 		$hcrnfqh=newValue( $hcrnfqh, $line );
 		$handled=1;
 	}
 	#Sender address rejected: Domain not found
 	if ( ( $line =~ /Sender address rejected\: Domain not found/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$sardnfC=$line;
 		$sardnf=newValue( $sardnf, $line );
 		$handled=1;
 	}
 	#Sender address rejected: not owned by user
 	if ( ( $line =~ /Sender address rejected\: not owned by user/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$sarnobuC=$line;
 		$sarnobu=newValue( $sarnobu, $line );
 		$handled=1;
 	}
 	#blocked using
 	# These lines are RBLs so there will be more than one.
 	# Use $buNew to add them all up.
 	if ( ( $line =~ /blocked using/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$buNew=$buNew + $line;
 		$handled=1;
 	}
 	#Recipient address rejected: User unknown
 	if ( ( $line =~ /Recipient address rejected\: User unknown/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$raruuNew=$raruuNew + $line;
 		$handled=1;
 	}
 	#Helo command rejected: Invalid name
 	if ( ( $line =~ /Helo command rejected\: Invalid name/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$hcrinC=$line;
 		$hcrin=newValue( $hcrin, $line );
 	}
 	#Sender address rejected: need fully-qualified address
 	if ( ( $line =~ /Sender address rejected\: need fully-qualified address/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$sarnfqaC=$line;
 		$sarnfqa=newValue( $sarnfqa, $line );
 	}
 	#Recipient address rejected: Domain not found
 	if ( ( $line =~ /Recipient address rejected\: Domain not found/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$rardnfC=$line;
 		$rardnf=newValue( $rardnf, $line );
 	}
 	#Improper use of SMTP command pipelining
 	if ( ( $line =~ /Improper use of SMTP command pipelining/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$iuscpC=$line;
 		$iuscp=newValue( $iuscp, $line );
 	}
 	#Message size exceeds fixed limit
 	if ( ( $line =~ /Message size exceeds fixed limit/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$mseflC=$line;
 		$msefl=newValue( $msefl, $line );
 	}
 	#Server configuration error
 	if ( ( $line =~ /Server configuration error/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$sceC=$line;
 		$sce=newValue( $sce, $line );
 	}
 	#Server configuration problem
 	if ( ( $line =~ /Server configuration problem/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$scpC=$line;
 		$scp=newValue( $scp, $line );
 	}
 	#unknown reject reason
 	if ( ( $line =~ /unknown reject reason/ ) && ( ! $handled ) ){
 		$line=~s/.*\: //g;
 		$urrC=$line;
 		$urr=newValue( $urr, $line );
 	}
 	$int++;
 }
 # final client host rejected total
 $chr=newValue( $chr, $chrNew );
 # final RBL total
 $bu=newValue( $bu, $buNew );
 # final recipient address rejected total
 $raruu=newValue( $raruu, $raruuNew );
 my $data=$received."\n".
 	$delivered."\n".
 	$forwarded."\n".
 	$deferred."\n".
 	$bounced."\n".
 	$rejected."\n".
 	$rejectw."\n".
 	$held."\n".
 	$discarded."\n".
 	$bytesr."\n".
 	$bytesd."\n".
 	$senders."\n".
 	$sendinghd."\n".
 	$recipients."\n".
 	$recipienthd."\n".
 	$deferralcr."\n".
 	$deferralhid."\n".
 	$chr."\n".
 	$hcrnfqh."\n".
 	$sardnf."\n".
 	$sarnobu."\n".
 	$bu."\n".
 	$raruu."\n".
 	$hcrin."\n".
 	$sarnfqa."\n".
 	$rardnf."\n".
 	$rarnfqa."\n".
 	$iuscp."\n".
 	$sce."\n".
 	$scp."\n".
 	$urr."\n".
 	$msefl."\n";
 print $data;
 my $current=$receivedC."\n".
 	$deliveredC."\n".
 	$forwardedC."\n".
 	$deferredC."\n".
 	$bouncedC."\n".
 	$rejectedC."\n".
 	$rejectwC."\n".
 	$heldC."\n".
 	$discardedC."\n".
 	$bytesrC."\n".
 	$bytesdC."\n".
 	$sendersC."\n".
 	$sendinghdC."\n".
 	$recipientsC."\n".
 	$recipienthdC."\n".
 	$deferralcrC."\n".
 	$deferralhidC."\n".
 	$chrNew."\n".
 	$hcrnfqhC."\n".
 	$sardnfC."\n".
 	$sarnobuC."\n".
 	$buNew."\n".
 	$raruuNew."\n".
 	$hcrinC."\n".
 	$sarnfqaC."\n".
 	$rardnfC."\n".
 	$rarnfqaC."\n".
 	$iuscpC."\n".
 	$sceC."\n".
 	$scpC."\n".
 	$urrC."\n".
 	$mseflC."\n";
 open(my $fh, ">", $cache) or die "Can't open '".$cache."'";
 print $fh $current;
 close($fh);
@@ -0,0 +1,46 @@
 #!/bin/bash
 #######################################
 # please read DOCS to succesfully get #
 # raspberry sensors into your host    #
 #######################################
 picmd='/usr/bin/vcgencmd'
 pised='/bin/sed'
 getTemp='measure_temp'
 getVoltsCore='measure_volts core'
 getVoltsRamC='measure_volts sdram_c'
 getVoltsRamI='measure_volts sdram_i'
 getVoltsRamP='measure_volts sdram_p'
 getFreqArm='measure_clock arm'
 getFreqCore='measure_clock core'
 getStatusH264='codec_enabled H264'
 getStatusMPG2='codec_enabled MPG2'
 getStatusWVC1='codec_enabled WVC1'
 getStatusMPG4='codec_enabled MPG4'
 getStatusMJPG='codec_enabled MJPG'
 getStatusWMV9='codec_enabled WMV9'
 $picmd $getTemp | $pised 's|[^0-9.]||g'
 $picmd "$getVoltsCore" | $pised 's|[^0-9.]||g'
 $picmd "$getVoltsRamC" | $pised 's|[^0-9.]||g'
 $picmd "$getVoltsRamI" | $pised 's|[^0-9.]||g'
 $picmd "$getVoltsRamP" | $pised 's|[^0-9.]||g'
 $picmd "$getFreqArm"  | $pised 's/frequency([0-9]*)=//g'
 $picmd "$getFreqCore" | $pised 's/frequency([0-9]*)=//g'
 $picmd "$getStatusH264" | $pised 's/H264=//g'
 $picmd "$getStatusMPG2" | $pised 's/MPG2=//g'
 $picmd "$getStatusWVC1" | $pised 's/WVC1=//g'
 $picmd "$getStatusMPG4" | $pised 's/MPG4=//g'
 $picmd "$getStatusMJPG" | $pised 's/MJPG=//g'
 $picmd "$getStatusWMV9" | $pised 's/WMV9=//g'
 $picmd "$getStatusH264" | $pised 's/enabled/2/g'
 $picmd "$getStatusMPG2" | $pised 's/enabled/2/g'
 $picmd "$getStatusWVC1" | $pised 's/enabled/2/g'
 $picmd "$getStatusMPG4" | $pised 's/enabled/2/g'
 $picmd "$getStatusMJPG" | $pised 's/enabled/2/g'
 $picmd "$getStatusWMV9" | $pised 's/enabled/2/g'
 $picmd "$getStatusH264" | $pised 's/disabled/1/g'
 $picmd "$getStatusMPG2" | $pised 's/disabled/1/g'
 $picmd "$getStatusWVC1" | $pised 's/disabled/1/g'
 $picmd "$getStatusMPG4" | $pised 's/disabled/1/g'
 $picmd "$getStatusMJPG" | $pised 's/disabled/1/g'
 $picmd "$getStatusWMV9" | $pised 's/disabled/1/g'
@@ -0,0 +1,929 @@
 #!/usr/bin/env perl
 #Copyright (c) 2024, Zane C. Bowers-Hadley
 #All rights reserved.
 #
 #Redistribution and use in source and binary forms, with or without modification,
 #are permitted provided that the following conditions are met:
 #
 #   * Redistributions of source code must retain the above copyright notice,
 #    this list of conditions and the following disclaimer.
 #   * Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
 #
 #THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 #ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 #WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 #IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 #INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 #BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 #DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 #LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 #OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 #THE POSSIBILITY OF SUCH DAMAGE.
 =for comment
 Add this to snmpd.conf like below.
    extend smart /etc/snmp/smart
 Then add to root's cron tab, if you have more than a few disks.
    */5 * * * * /etc/snmp/extends/smart -u
 You will also need to create the config file, which defaults to the same path as the script,
 but with .config appended. So if the script is located at /etc/snmp/smart, the config file
 will be /etc/snmp/extends/smart.config. Alternatively you can also specific a config via -c.
 Anything starting with a # is comment. The format for variables is $variable=$value. Empty
 lines are ignored. Spaces and tabes at either the start or end of a line are ignored. Any
 line with out a matched variable or # are treated as a disk.
    #This is a comment
    cache=/var/cache/smart
    smartctl=/usr/local/sbin/smartctl
    useSN=0
    ada0
    da5 /dev/da5 -d sat
    twl0,0 /dev/twl0 -d 3ware,0
    twl0,1 /dev/twl0 -d 3ware,1
    twl0,2 /dev/twl0 -d 3ware,2
 The variables are as below.
    cache = The path to the cache file to use. Default: /var/cache/smart
    smartctl = The path to use for smartctl. Default: /usr/bin/env smartctl
    useSN = If set to 1, it will use the disks SN for reporting instead of the device name.
            1 is the default. 0 will use the device name.
 A disk line is can be as simple as just a disk name under /dev/. Such as in the config above
 The line "ada0" would resolve to "/dev/ada0" and would be called with no special argument. If
 a line has a space in it, everything before the space is treated as the disk name and is what
 used for reporting and everything after that is used as the argument to be passed to smartctl.
 If you want to guess at the configuration, call it with -g and it will print out what it thinks
 it should be.
 Switches:
 -c <config>   The config file to use.
 -u            Update
 -p            Pretty print the JSON.
 -Z            GZip+Base64 compress the results.
 -g            Guess at the config and print it to STDOUT
 -C            Enable manual checking for guess and cciss.
 -S            Set useSN to 0 when using -g
 -t <test>     Run the specified smart self test on all the devices.
 -U            When calling cciss_vol_status, call it with -u.
 -G <modes>    Guess modes to use. This is a comma seperated list.
              Default :: scan-open,cciss-vol-status
 Guess Modes:
 - scan :: Use "--scan" with smartctl. "scan-open" will take presidence.
 - scan-open :: Call smartctl with "--scan-open".
 - cciss-vol-status :: Freebsd/Linux specific and if it sees /dev/sg0(on Linux) or
    /dev/ciss0(on FreebSD) it will attempt to find drives via cciss-vol-status,
    and then optionally checking for disks via smrtctl if -C is given. Should be noted
    though that -C will not find drives that are currently missing/failed. If -U is given,
    cciss_vol_status will be called with -u.
 =cut
 ##
 ## You should not need to touch anything below here.
 ##
 use warnings;
 use strict;
 use Getopt::Std;
 use JSON;
 use MIME::Base64;
 use IO::Compress::Gzip qw(gzip $GzipError);
 my $cache    = '/var/cache/smart';
 my $smartctl = '/usr/bin/env smartctl';
 my @disks;
 my $useSN = 1;
 $Getopt::Std::STANDARD_HELP_VERSION = 1;
 sub main::VERSION_MESSAGE {
 	print "SMART SNMP extend 0.3.2\n";
 }
 sub main::HELP_MESSAGE {
 	&VERSION_MESSAGE;
 	print "\n" . "-u   Update '" . $cache . "'\n" . '-g            Guess at the config and print it to STDOUT
 -c <config>   The config file to use.
 -p            Pretty print the JSON.
 -Z            GZip+Base64 compress the results.
 -C            Enable manual checking for guess and cciss.
 -S            Set useSN to 0 when using -g
 -t <test>     Run the specified smart self test on all the devices.
 -U            When calling cciss_vol_status, call it with -u.
 -G <modes>    Guess modes to use. This is a comma seperated list.
              Default :: scan-open,cciss-vol-status
 Scan Modes:
 - scan :: Use "--scan" with smartctl. "scan-open" will take presidence.
 - scan-open :: Call smartctl with "--scan-open".
 - cciss-vol-status :: Freebsd/Linux specific and if it sees /dev/sg0(on Linux) or
    /dev/ciss0(on FreebSD) it will attempt to find drives via cciss-vol-status,
    and then optionally checking for disks via smrtctl if -C is given. Should be noted
    though that -C will not find drives that are currently missing/failed. If -U is given,
    cciss_vol_status will be called with -u.
 ';
 } ## end sub main::HELP_MESSAGE
 #gets the options
 my %opts = ();
 getopts( 'ugc:pZhvCSGt:U', \%opts );
 if ( $opts{h} ) {
 	&HELP_MESSAGE;
 	exit;
 }
 if ( $opts{v} ) {
 	&VERSION_MESSAGE;
 	exit;
 }
 #
 # figure out what scan modes to use if -g specified
 #
 my $scan_modes = {
 	'scan-open'        => 0,
 	'scan'             => 0,
 	'cciss_vol_status' => 0,
 };
 if ( $opts{g} ) {
 	if ( !defined( $opts{G} ) ) {
 		$opts{G} = 'scan-open,cciss_vol_status';
 	}
 	$opts{G} =~ s/[\ \t]//g;
 	my @scan_modes_split = split( /,/, $opts{G} );
 	foreach my $mode (@scan_modes_split) {
 		if ( !defined $scan_modes->{$mode} ) {
 			die( '"' . $mode . '" is not a recognized scan mode' );
 		}
 		$scan_modes->{$mode} = 1;
 	}
 } ## end if ( $opts{g} )
 # configure JSON for later usage
 # only need to do this if actually running as in -g is not specified
 my $json;
 if ( !$opts{g} ) {
 	$json = JSON->new->allow_nonref->canonical(1);
 	if ( $opts{p} ) {
 		$json->pretty;
 	}
 }
 #
 #
 # guess if asked
 #
 #
 if ( defined( $opts{g} ) ) {
 	#get what path to use for smartctl
 	$smartctl = `which smartctl`;
 	chomp($smartctl);
 	if ( $? != 0 ) {
 		warn("'which smartctl' failed with a exit code of $?");
 		exit 1;
 	}
 	#try to touch the default cache location and warn if it can't be done
 	system( 'touch ' . $cache . '>/dev/null' );
 	if ( $? != 0 ) {
 		$cache = '#Could not touch ' . $cache . "You will need to manually set it\n" . "cache=?\n";
 	} else {
 		system( 'rm -f ' . $cache . '>/dev/null' );
 		$cache = 'cache=' . $cache . "\n";
 	}
 	my $drive_lines = '';
 	#
 	#
 	# scan-open and scan guess mode handling
 	#
 	#
 	if ( $scan_modes->{'scan-open'} || $scan_modes->{'scan'} ) {
 		# used for checking if a disk has been found more than once
 		my %found_disks_names;
 		my @argumentsA;
 		# use scan-open if it is set, overriding scan if it is also set
 		my $mode = 'scan';
 		if ( $scan_modes->{'scan-open'} ) {
 			$mode = 'scan-open';
 		}
 		#have smartctl scan and see if it finds anythings not get found
 		my $scan_output  = `$smartctl --$mode`;
 		my @scan_outputA = split( /\n/, $scan_output );
 		# remove non-SMART devices sometimes returned
 		@scan_outputA = grep( !/ses[0-9]/,  @scan_outputA );    # not a disk, but may or may not have SMART attributes
 		@scan_outputA = grep( !/pass[0-9]/, @scan_outputA );    # very likely a duplicate and a disk under another name
 		@scan_outputA = grep( !/cd[0-9]/,   @scan_outputA );    # CD drive
 		if ( $^O eq 'freebsd' ) {
 			@scan_outputA = grep( !/sa[0-9]/,  @scan_outputA );    # tape drive
 			@scan_outputA = grep( !/ctl[0-9]/, @scan_outputA );    # CAM target layer
 		} elsif ( $^O eq 'linux' ) {
 			@scan_outputA = grep( !/st[0-9]/, @scan_outputA );     # SCSI tape drive
 			@scan_outputA = grep( !/ht[0-9]/, @scan_outputA );     # ATA tape drive
 		}
 		# make the first pass, figuring out what all we have and trimming comments
 		foreach my $arguments (@scan_outputA) {
 			my $name = $arguments;
 			$arguments =~ s/ \#.*//;                               # trim the comment out of the argument
 			$name      =~ s/ .*//;
 			$name      =~ s/\/dev\///;
 			if ( defined( $found_disks_names{$name} ) ) {
 				$found_disks_names{$name}++;
 			} else {
 				$found_disks_names{$name} = 0;
 			}
 			push( @argumentsA, $arguments );
 		} ## end foreach my $arguments (@scan_outputA)
 		# second pass, putting the lines together
 		my %current_disk;
 		foreach my $arguments (@argumentsA) {
 			my $not_virt = 1;
 			# check to see if we have a virtual device
 			my @virt_check = split( /\n/, `smartctl -i $arguments 2> /dev/null` );
 			foreach my $virt_check_line (@virt_check) {
 				if ( $virt_check_line =~ /(?i)Product\:.*LOGICAL VOLUME/ ) {
 					$not_virt = 0;
 				}
 			}
 			my $name = $arguments;
 			$name =~ s/ .*//;
 			$name =~ s/\/dev\///;
 			# only add it if not a virtual RAID drive
 			# HP RAID virtual disks will show up with very basical but totally useless smart data
 			if ($not_virt) {
 				if ( $found_disks_names{$name} == 0 ) {
 					# If no other devices, just name it after the base device.
 					$drive_lines = $drive_lines . $name . " " . $arguments . "\n";
 				} else {
 					# if more than one, start at zero and increment, apennding comma number to the base device name
 					if ( defined( $current_disk{$name} ) ) {
 						$current_disk{$name}++;
 					} else {
 						$current_disk{$name} = 0;
 					}
 					$drive_lines = $drive_lines . $name . "," . $current_disk{$name} . " " . $arguments . "\n";
 				}
 			} ## end if ($not_virt)
 		} ## end foreach my $arguments (@argumentsA)
 	} ## end if ( $scan_modes->{'scan-open'} || $scan_modes...)
 	#
 	#
 	# scan mode handler for cciss_vol_status
 	# /dev/sg* devices for cciss on Linux
 	# /dev/ccis* devices for cciss on FreeBSD
 	#
 	#
 	if ( $scan_modes->{'cciss_vol_status'} && ( $^O eq 'linux' || $^O eq 'freebsd' ) ) {
 		my $cciss;
 		if ( $^O eq 'freebsd' ) {
 			$cciss = 'ciss';
 		} elsif ( $^O eq 'linux' ) {
 			$cciss = 'sg';
 		}
 		my $uarg = '';
 		if ( $opts{U} ) {
 			$uarg = '-u';
 		}
 		# generate the initial device path that will be checked
 		my $sg_int = 0;
 		my $device = '/dev/' . $cciss . $sg_int;
 		my $sg_process = 1;
 		if ( -e $device ) {
 			my $output = `which cciss_vol_status 2> /dev/null`;
 			if ( $? != 0 && !$opts{C} ) {
 				$sg_process = 0;
 				$drive_lines
 					= $drive_lines
 					. "# -C not given, but "
 					. $device
 					. " exists and cciss_vol_status is not present\n"
 					. "# in path or 'ccis_vol_status -V "
 					. $device
 					. "' is failing\n";
 			} ## end if ( $? != 0 && !$opts{C} )
 		} ## end if ( -e $device )
 		my $seen_lines   = {};
 		my $ignore_lines = {};
 		while ( -e $device && $sg_process ) {
 			my $output = `cciss_vol_status -V $uarg $device 2> /dev/null`;
 			if ( $? != 0 && $output eq '' && !$opts{C} ) {
 				# just empty here as we just want to skip it if it fails and there is no C
 				# warning is above
 			} elsif ( $? != 0 && $output eq '' && $opts{C} ) {
 				my $drive_count = 0;
 				my $continue    = 1;
 				while ($continue) {
 					my $output = `$smartctl -i $device -d cciss,$drive_count 2> /dev/null`;
 					if ( $? != 0 ) {
 						$continue = 0;
 					} else {
 						my $add_it = 0;
 						my $id;
 						while ( $output =~ /(?i)Serial Number:(.*)/g ) {
 							$id = $1;
 							$id =~ s/^\s+|\s+$//g;
 						}
 						if ( defined($id) && !defined( $seen_lines->{$id} ) ) {
 							$add_it = 1;
 							$seen_lines->{$id} = 1;
 						}
 						if ( $continue && $add_it ) {
 							$drive_lines
 								= $drive_lines
 								. $cciss . '0-'
 								. $drive_count . ' '
 								. $device
 								. ' -d cciss,'
 								. $drive_count . "\n";
 						}
 					} ## end else [ if ( $? != 0 ) ]
 					$drive_count++;
 				} ## end while ($continue)
 			} else {
 				my $drive_count = 0;
 				# count the connector lines, this will make sure failed are founded as well
 				my $seen_conectors = {};
 				while ( $output =~ /(connector +\d+[IA]\ +box +\d+\ +bay +\d+.*)/g ) {
 					my $cciss_drive_line = $1;
 					my $connector        = $cciss_drive_line;
 					$connector =~ s/(.*\ bay +\d+).*/$1/;
 					if (   !defined( $seen_lines->{$cciss_drive_line} )
 						&& !defined( $seen_conectors->{$connector} )
 						&& !defined( $ignore_lines->{$cciss_drive_line} ) )
 					{
 						$seen_lines->{$cciss_drive_line} = 1;
 						$seen_conectors->{$connector}    = 1;
 						$drive_count++;
 					} else {
 						# going to be a connector we've already seen
 						# which will happen when it is processing replacement drives
 						# so save this as a device to ignore
 						$ignore_lines->{$cciss_drive_line} = 1;
 					}
 				} ## end while ( $output =~ /(connector +\d+[IA]\ +box +\d+\ +bay +\d+.*)/g)
 				my $drive_int = 0;
 				while ( $drive_int < $drive_count ) {
 					$drive_lines
 						= $drive_lines
 						. $cciss
 						. $sg_int . '-'
 						. $drive_int . ' '
 						. $device
 						. ' -d cciss,'
 						. $drive_int . "\n";
 					$drive_int++;
 				} ## end while ( $drive_int < $drive_count )
 			} ## end else [ if ( $? != 0 && $output eq '' && !$opts{C})]
 			$sg_int++;
 			$device = '/dev/' . $cciss . $sg_int;
 		} ## end while ( -e $device && $sg_process )
 	} ## end if ( $scan_modes->{'cciss_vol_status'} && ...)
 	my $useSN = 1;
 	if ( $opts{S} ) {
 		$useSN = 0;
 	}
 	print '# scan_modes='
 		. $opts{G}
 		. "\nuseSN="
 		. $useSN . "\n"
 		. 'smartctl='
 		. $smartctl . "\n"
 		. $cache
 		. $drive_lines;
 	exit 0;
 } ## end if ( defined( $opts{g} ) )
 #get which config file to use
 my $config = $0 . '.config';
 if ( defined( $opts{c} ) ) {
 	$config = $opts{c};
 }
 #reads the config file, optionally
 my $config_file = '';
 open( my $readfh, "<", $config ) or die "Can't open '" . $config . "'";
 read( $readfh, $config_file, 1000000 );
 close($readfh);
 #
 #
 # parse the config file and remove comments and empty lines
 #
 #
 my @configA = split( /\n/, $config_file );
@configA = grep( !/^$/,        @configA );
@configA = grep( !/^\#/,       @configA );
@configA = grep( !/^[\s\t]*$/, @configA );
 my $configA_int = 0;
 while ( defined( $configA[$configA_int] ) ) {
 	my $line = $configA[$configA_int];
 	chomp($line);
 	$line =~ s/^[\t\s]+//;
 	$line =~ s/[\t\s]+$//;
 	my ( $var, $val ) = split( /=/, $line, 2 );
 	my $matched;
 	if ( $var eq 'cache' ) {
 		$cache   = $val;
 		$matched = 1;
 	}
 	if ( $var eq 'smartctl' ) {
 		$smartctl = $val;
 		$matched  = 1;
 	}
 	if ( $var eq 'useSN' ) {
 		$useSN   = $val;
 		$matched = 1;
 	}
 	if ( !defined($val) ) {
 		push( @disks, $line );
 	}
 	$configA_int++;
 } ## end while ( defined( $configA[$configA_int] ) )
 #
 #
 # run the specified self test on all disks if asked
 #
 #
 if ( defined( $opts{t} ) ) {
 	# make sure we have something that atleast appears sane for the test name
 	my $valid_tesks = {
 		'offline'        => 1,
 		'short'          => 1,
 		'long'           => 1,
 		'conveyance'     => 1,
 		'afterselect,on' => 1,
 	};
 	if ( !defined( $valid_tesks->{ $opts{t} } ) && $opts{t} !~ /select,(\d+[\-\+]\d+|next|next\+\d+|redo\+\d+)/ ) {
 		print '"' . $opts{t} . "\" does not appear to be a valid test\n";
 		exit 1;
 	}
 	print "Running the SMART $opts{t} on all devices in the config...\n\n";
 	foreach my $line (@disks) {
 		my $disk;
 		my $name;
 		if ( $line =~ /\ / ) {
 			( $name, $disk ) = split( /\ /, $line, 2 );
 		} else {
 			$disk = $line;
 			$name = $line;
 		}
 		if ( $disk !~ /\// ) {
 			$disk = '/dev/' . $disk;
 		}
 		print "\n------------------------------------------------------------------\nDoing "
 			. $smartctl . ' -t '
 			. $opts{t} . ' '
 			. $disk
 			. "  ...\n\n";
 		print `$smartctl -t $opts{t} $disk` . "\n";
 	} ## end foreach my $line (@disks)
 	exit 0;
 } ## end if ( defined( $opts{t} ) )
 #if set to 1, no cache will be written and it will be printed instead
 my $noWrite = 0;
 #
 #
 # if no -u, it means we are being called from snmped
 #
 #
 if ( !defined( $opts{u} ) ) {
 	# if the cache file exists, print it, otherwise assume one is not being used
 	if ( -f $cache ) {
 		my $old = '';
 		open( my $readfh, "<", $cache ) or die "Can't open '" . $cache . "'";
 		read( $readfh, $old, 1000000 );
 		close($readfh);
 		print $old;
 		exit 0;
 	} else {
 		$opts{u} = 1;
 		$noWrite = 1;
 	}
 } ## end if ( !defined( $opts{u} ) )
 #
 #
 # Process each disk
 #
 #
 my $to_return = {
 	data        => { disks => {}, exit_nonzero => 0, unhealthy => 0, useSN => $useSN },
 	version     => 1,
 	error       => 0,
 	errorString => '',
 };
 foreach my $line (@disks) {
 	my $disk;
 	my $name;
 	if ( $line =~ /\ / ) {
 		( $name, $disk ) = split( /\ /, $line, 2 );
 	} else {
 		$disk = $line;
 		$name = $line;
 	}
 	if ( $disk !~ /\// ) {
 		$disk = '/dev/' . $disk;
 	}
 	my $output = `$smartctl -A $disk`;
 	my %IDs    = (
 		'5'            => 'null',
 		'10'           => 'null',
 		'173'          => 'null',
 		'177'          => 'null',
 		'183'          => 'null',
 		'184'          => 'null',
 		'187'          => 'null',
 		'188'          => 'null',
 		'190'          => 'null',
 		'194'          => 'null',
 		'196'          => 'null',
 		'197'          => 'null',
 		'198'          => 'null',
 		'199'          => 'null',
 		'231'          => 'null',
 		'232'          => 'null',
 		'233'          => 'null',
 		'9'            => 'null',
 		'disk'         => $disk,
 		'serial'       => undef,
 		'selftest_log' => undef,
 		'health_pass'  => 0,
 		max_temp       => 'null',
 		exit           => $?,
 	);
 	$IDs{'disk'} =~ s/^\/dev\///;
 	# if polling exited non-zero above, no reason running the rest of the checks
 	my $disk_id = $name;
 	if ( $IDs{exit} != 0 ) {
 		$to_return->{data}{exit_nonzero}++;
 	} else {
 		my @outputA;
 		if ( $output =~ /NVMe Log/ ) {
 			# we have an NVMe drive with annoyingly different output
 			my %mappings = (
 				'Temperature'     => 194,
 				'Power Cycles'    => 12,
 				'Power On Hours'  => 9,
 				'Percentage Used' => 231,
 			);
 			foreach ( split( /\n/, $output ) ) {
 				if (/:/) {
 					my ( $key, $val ) = split(/:/);
 					$val =~ s/^\s+|\s+$|\D+//g;
 					if ( exists( $mappings{$key} ) ) {
 						if ( $mappings{$key} == 231 ) {
 							$IDs{ $mappings{$key} } = 100 - $val;
 						} else {
 							$IDs{ $mappings{$key} } = $val;
 						}
 					}
 				} ## end if (/:/)
 			} ## end foreach ( split( /\n/, $output ) )
 		} else {
 			@outputA = split( /\n/, $output );
 			my $outputAint = 0;
 			while ( defined( $outputA[$outputAint] ) ) {
 				my $line = $outputA[$outputAint];
 				$line =~ s/^ +//;
 				$line =~ s/  +/ /g;
 				if ( $line =~ /^[0123456789]+ / ) {
 					my @lineA      = split( /\ /, $line, 10 );
 					my $raw        = $lineA[9];
 					my $normalized = $lineA[3];
 					my $id         = $lineA[0];
 					# Crucial SSD
 					# 202, Percent_Lifetime_Remain, same as 231, SSD Life Left
 					if (   $id == 202
 						&& $line =~ /Percent_Lifetime_Remain/ )
 					{
 						$IDs{231} = $raw;
 					}
 					# single int raw values
 					if (   ( $id == 5 )
 						|| ( $id == 10 )
 						|| ( $id == 173 )
 						|| ( $id == 183 )
 						|| ( $id == 184 )
 						|| ( $id == 187 )
 						|| ( $id == 196 )
 						|| ( $id == 197 )
 						|| ( $id == 198 )
 						|| ( $id == 199 ) )
 					{
 						my @rawA = split( /\ /, $raw );
 						$IDs{$id} = $rawA[0];
 					} ## end if ( ( $id == 5 ) || ( $id == 10 ) || ( $id...))
 					# single int normalized values
 					if (   ( $id == 177 )
 						|| ( $id == 230 )
 						|| ( $id == 231 )
 						|| ( $id == 232 )
 						|| ( $id == 233 ) )
 					{
 				 # annoying non-standard disk
 				 # WDC WDS500G2B0A
 				 # 230 Media_Wearout_Indicator 0x0032   100   100   ---    Old_age   Always       -       0x002e000a002e
 				 # 232 Available_Reservd_Space 0x0033   100   100   004    Pre-fail  Always       -       100
 				 # 233 NAND_GB_Written_TLC     0x0032   100   100   ---    Old_age   Always       -       9816
 						if (   $id == 230
 							&& $line =~ /Media_Wearout_Indicator/ )
 						{
 							$IDs{233} = int($normalized);
 						} elsif ( $id == 232
 							&& $line =~ /Available_Reservd_Space/ )
 						{
 							$IDs{232} = int($normalized);
 						} else {
 							# only set 233 if it has not been set yet
 							# if it was set already then the above did it and we don't want
 							# to overwrite it
 							if ( $id == 233 && $IDs{233} eq "null" ) {
 								$IDs{$id} = int($normalized);
 							} elsif ( $id != 233 ) {
 								$IDs{$id} = int($normalized);
 							}
 						} ## end else [ if ( $id == 230 && $line =~ /Media_Wearout_Indicator/)]
 					} ## end if ( ( $id == 177 ) || ( $id == 230 ) || (...))
 					# 9, power on hours
 					if ( $id == 9 ) {
 						my @runtime = split( /[\ h]/, $raw );
 						$IDs{$id} = $runtime[0];
 					}
 					# 188, Command_Timeout
 					if ( $id == 188 ) {
 						my $total   = 0;
 						my @rawA    = split( /\ /, $raw );
 						my $rawAint = 0;
 						while ( defined( $rawA[$rawAint] ) ) {
 							$total = $total + $rawA[$rawAint];
 							$rawAint++;
 						}
 						$IDs{$id} = $total;
 					} ## end if ( $id == 188 )
 					# 190, airflow temp
 					# 194, temp
 					if (   ( $id == 190 )
 						|| ( $id == 194 ) )
 					{
 						my ($temp) = split( /\ /, $raw );
 						$IDs{$id} = $temp;
 					}
 				} ## end if ( $line =~ /^[0123456789]+ / )
 				# SAS Wrapping
 				# Section by Cameron Munroe (munroenet[at]gmail.com)
 				# Elements in Grown Defect List.
 				# Marking as 5 Reallocated_Sector_Ct
 				if ( $line =~ "Elements in grown defect list:" ) {
 					my @lineA = split( /\ /, $line, 10 );
 					my $raw   = $lineA[5];
 					# Reallocated Sector Count ID
 					$IDs{5} = $raw;
 				}
 				# Current Drive Temperature
 				# Marking as 194 Temperature_Celsius
 				if ( $line =~ "Current Drive Temperature:" ) {
 					my @lineA = split( /\ /, $line, 10 );
 					my $raw   = $lineA[3];
 					# Temperature C ID
 					$IDs{194} = $raw;
 				}
 				# End of SAS Wrapper
 				$outputAint++;
 			} ## end while ( defined( $outputA[$outputAint] ) )
 		} ## end else [ if ( $output =~ /NVMe Log/ ) ]
 		#get the selftest logs
 		$output  = `$smartctl -l selftest $disk`;
 		@outputA = split( /\n/, $output );
 		my @completed = grep( /Completed/, @outputA );
 		$IDs{'completed'} = scalar @completed;
 		my @interrupted = grep( /Interrupted/, @outputA );
 		$IDs{'interrupted'} = scalar @interrupted;
 		my @read_failure = grep( /read failure/, @outputA );
 		$IDs{'read_failure'} = scalar @read_failure;
 		my @read_failure2 = grep( /Failed in segment/, @outputA );
 		$IDs{'read_failure'} = $IDs{'read_failure'} + scalar @read_failure2;
 		my @unknown_failure = grep( /unknown failure/, @outputA );
 		$IDs{'unknown_failure'} = scalar @unknown_failure;
 		my @extended = grep( /\d.*\ ([Ee]xtended|[Ll]ong).*(?![Dd]uration)/, @outputA );
 		$IDs{'extended'} = scalar @extended;
 		my @short = grep( /[Ss]hort/, @outputA );
 		$IDs{'short'} = scalar @short;
 		my @conveyance = grep( /[Cc]onveyance/, @outputA );
 		$IDs{'conveyance'} = scalar @conveyance;
 		my @selective = grep( /[Ss]elective/, @outputA );
 		$IDs{'selective'} = scalar @selective;
 		my @offline = grep( /(\d|[Bb]ackground|[Ff]oreground)+\ +[Oo]ffline/, @outputA );
 		$IDs{'offline'} = scalar @offline;
 		# if we have logs, actually grab the log output
 		if (   $IDs{'completed'} > 0
 			|| $IDs{'interrupted'} > 0
 			|| $IDs{'read_failure'} > 0
 			|| $IDs{'extended'} > 0
 			|| $IDs{'short'} > 0
 			|| $IDs{'conveyance'} > 0
 			|| $IDs{'selective'} > 0
 			|| $IDs{'offline'} > 0 )
 		{
 			my @headers = grep( /(Num\ +Test.*LBA| Description .*[Hh]ours)/, @outputA );
 			my @log_lines;
 			push( @log_lines, @extended, @short, @conveyance, @selective, @offline );
 			$IDs{'selftest_log'} = join( "\n", @headers, sort(@log_lines) );
 		} ## end if ( $IDs{'completed'} > 0 || $IDs{'interrupted'...})
 		# get the drive serial number, if needed
 		$disk_id = $name;
 		$output  = `$smartctl -i $disk`;
 		# generally upper case, HP branded drives seem to report with lower case n
 		while ( $output =~ /(?i)Serial Number:(.*)/g ) {
 			$IDs{'serial'} = $1;
 			$IDs{'serial'} =~ s/^\s+|\s+$//g;
 		}
 		if ($useSN) {
 			$disk_id = $IDs{'serial'};
 		}
 		while ( $output =~ /(?i)Model Family:(.*)/g ) {
 			$IDs{'model_family'} = $1;
 			$IDs{'model_family'} =~ s/^\s+|\s+$//g;
 		}
 		while ( $output =~ /(?i)Device Model:(.*)/g ) {
 			$IDs{'device_model'} = $1;
 			$IDs{'device_model'} =~ s/^\s+|\s+$//g;
 		}
 		while ( $output =~ /(?i)Model Number:(.*)/g ) {
 			$IDs{'model_number'} = $1;
 			$IDs{'model_number'} =~ s/^\s+|\s+$//g;
 		}
 		while ( $output =~ /(?i)Firmware Version:(.*)/g ) {
 			$IDs{'fw_version'} = $1;
 			$IDs{'fw_version'} =~ s/^\s+|\s+$//g;
 		}
 		# mainly HP drives
 		while ( $output =~ /(?i)Vendor:(.*)/g ) {
 			$IDs{'vendor'} = $1;
 			$IDs{'vendor'} =~ s/^\s+|\s+$//g;
 		}
 		# mainly HP drives
 		while ( $output =~ /(?i)Product:(.*)/g ) {
 			$IDs{'product'} = $1;
 			$IDs{'product'} =~ s/^\s+|\s+$//g;
 		}
 		# mainly HP drives
 		while ( $output =~ /(?i)Revision:(.*)/g ) {
 			$IDs{'revision'} = $1;
 			$IDs{'revision'} =~ s/^\s+|\s+$//g;
 		}
 		# figure out what to use for the max temp, if there is one
 		if ( $IDs{'190'} =~ /^\d+$/ ) {
 			$IDs{max_temp} = $IDs{'190'};
 		} elsif ( $IDs{'194'} =~ /^\d+$/ ) {
 			$IDs{max_temp} = $IDs{'194'};
 		}
 		if ( $IDs{'194'} =~ /^\d+$/ && defined( $IDs{max_temp} ) && $IDs{'194'} > $IDs{max_temp} ) {
 			$IDs{max_temp} = $IDs{'194'};
 		}
 		$output = `$smartctl -H $disk`;
 		if ( $output =~ /SMART\ overall\-health\ self\-assessment\ test\ result\:\ PASSED/ ) {
 			$IDs{'health_pass'} = 1;
 		} elsif ( $output =~ /SMART\ Health\ Status\:\ OK/ ) {
 			$IDs{'health_pass'} = 1;
 		}
 		if ( !$IDs{'health_pass'} ) {
 			$to_return->{data}{unhealthy}++;
 		}
 	} ## end else [ if ( $IDs{exit} != 0 ) ]
 	# only bother to save this if useSN is not being used
 	if ( !$useSN ) {
 		$to_return->{data}{disks}{$disk_id} = \%IDs;
 	} elsif ( $IDs{exit} == 0 && defined($disk_id) ) {
 		$to_return->{data}{disks}{$disk_id} = \%IDs;
 	}
 	# smartctl will in some cases exit zero when it can't pull data for cciss
 	# so if we get a zero exit, but no serial then it means something errored
 	# and the device is likely dead
 	if ( $IDs{exit} == 0 && !defined( $IDs{serial} ) ) {
 		$to_return->{data}{unhealthy}++;
 	}
 } ## end foreach my $line (@disks)
 my $toReturn = $json->encode($to_return);
 if ( !$opts{p} ) {
 	$toReturn = $toReturn . "\n";
 }
 if ( $opts{Z} ) {
 	my $toReturnCompressed;
 	gzip \$toReturn => \$toReturnCompressed;
 	my $compressed = encode_base64($toReturnCompressed);
 	$compressed =~ s/\n//g;
 	$compressed = $compressed . "\n";
 	if ( length($compressed) < length($toReturn) ) {
 		$toReturn = $compressed;
 	}
 } ## end if ( $opts{Z} )
 if ( !$noWrite ) {
 	open( my $writefh, ">", $cache ) or die "Can't open '" . $cache . "'";
 	print $writefh $toReturn;
 	close($writefh);
 } else {
 	print $toReturn;
 }
@@ -0,0 +1,3 @@
 smartctl=/usr/sbin/smartctl
 cache=/var/cache/smart
 sda
@@ -0,0 +1,45 @@
 #!/bin/sh
 ################################################################
 # Instructions:                                                #
 # 1. copy this script to /etc/snmp/ and make it executable:    #
 #    chmod +x ups-nut.sh                                       #
 # 2. make sure UPS_NAME below matches the name of your UPS     #
 # 3. edit your snmpd.conf to include this line:                #
 #    extend ups-nut /etc/snmp/ups-nut.sh                       #
 # 4. restart snmpd on the host                                 #
 # 5. activate the app for the desired host in LibreNMS         #
 ################################################################
 UPS_NAME="${1:-APCUPS}"
 PATH=$PATH:/usr/bin:/bin
 TMP=$(upsc $UPS_NAME 2>/dev/null)
 for value in "battery\.charge: [0-9.]+" "battery\.(runtime\.)?low: [0-9]+" "battery\.runtime: [0-9]+" "battery\.voltage: [0-9.]+" "battery\.voltage\.nominal: [0-9]+" "input\.voltage\.nominal: [0-9.]+" "input\.voltage: [0-9.]+" "ups\.load: [0-9.]+"
 do
 	OUT=$(echo "$TMP" | grep -Eo "$value" | awk '{print $2}' | LANG=C sort | head -n 1)
 	if [ -n "$OUT" ]; then
 		echo "$OUT"
 	else
 		echo "Unknown"
 	fi
 done
 for value in "ups\.status:[A-Z ]{0,}OL" "ups\.status:[A-Z ]{0,}OB" "ups\.status:[A-Z ]{0,}LB" "ups\.status:[A-Z ]{0,}HB" "ups\.status:[A-Z ]{0,}RB" "ups\.status:[A-Z ]{0,}CHRG" "ups\.status:[A-Z ]{0,}DISCHRG" "ups\.status:[A-Z ]{0,}BYPASS" "ups\.status:[A-Z ]{0,}CAL" "ups\.status:[A-Z ]{0,}OFF" "ups\.status:[A-Z ]{0,}OVER" "ups\.status:[A-Z ]{0,}TRIM" "ups\.status:[A-Z ]{0,}BOOST" "ups\.status:[A-Z ]{0,}FSD" "ups\.alarm:[A-Z ]"
 do
    UNKNOWN=$(echo "$TMP" | grep -Eo "ups\.status:")
    if [ -z "$UNKNOWN" ]; then
        echo "Unknown"
    else
        OUT=$(echo "$TMP" | grep -Eo "$value")
        if [ -n "$OUT" ]; then
            echo "1"
        else
            echo "0"
        fi
    fi
 done
 UPSTEMP="ups\.temperature: [0-9.]+"
 OUT=$(echo "$TMP" | grep -Eo "$UPSTEMP" | awk '{print $2}' | LANG=C sort | head -n 1)
 [ -n "$OUT" ] && echo "$OUT" || echo "Unknown"
@@ -0,0 +1,46 @@
 #
 # Known Element Enterprises Customized Config File
 # auditd
 # Initial version 2025-06-27 
 #
 local_events = yes
 write_logs = yes
 log_file = /var/log/audit/audit.log
 log_group = adm
 log_format = ENRICHED
 flush = INCREMENTAL_ASYNC
 freq = 50
 max_log_file = 8
 num_logs = 5
 priority_boost = 4
 name_format = NONE
 max_log_file_action = keep_logs
 space_left = 75
 space_left_action = email
 action_mail_acct = root
 admin_space_left_action = halt
 disk_full_action = SUSPEND
 disk_error_action = SUSPEND
 admin_space_left = 50
 verify_email = yes
 use_libwrap = yes
 tcp_listen_queue = 5
 tcp_max_per_addr = 1
 tcp_client_max_idle = 0
 transport = TCP
 distribute_network = no
 q_depth = 2000
 overflow_action = SYSLOG
 max_restarts = 10
 plugin_dir = /etc/audit/plugins.d
 end_of_event_timeout = 2
 ##tcp_client_ports = 1024-65535
 ##tcp_listen_port = 60
 ##krb5_key_file = /etc/audit/audit.key
 krb5_principal = auditd
 ##name = mydomain
@@ -0,0 +1,5 @@
 This system is the property of Known Element Enterprises LLC.
 Authorized uses only. All activity may be monitored and reported.
 All activities subject to monitoring/recording/review in real time and/or at a later time.
@@ -0,0 +1,5 @@
 This system is the property of Known Element Enterprises LLC.
 Authorized uses only. All activity may be monitored and reported.
 All activities subject to monitoring/recording/review in real time and/or at a later time.
@@ -0,0 +1,5 @@
 This system is the property of Known Element Enterprises LLC.
 Authorized uses only. All activity may be monitored and reported.
 All activities subject to monitoring/recording/review in real time and/or at a later time.
@@ -0,0 +1,2 @@
 #/etc/cockpit/disallowed-users
 # List of users which are not allowed to login to Cockpit
@@ -0,0 +1,14 @@
 option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
 send host-name = gethostname();
 request subnet-mask, broadcast-address, time-offset, routers,
        domain-name, host-name,
        domain-name-servers, domain-search, ntp-servers,
        rfc3442-classless-static-routes;
 # Pin DNS and NTP to the redundant pfv-netinfra-01/02 pair regardless of what
 # the DHCP server advertises, so every host on this build uses the same
 # authoritative recursive resolvers and time sources.
 supersede domain-name-servers 192.168.3.252, 192.168.3.253;
 supersede domain-search "knel.net";
 supersede ntp-servers 192.168.3.252, 192.168.3.253;
@@ -0,0 +1,23 @@
 # see "man logrotate" for details
 # global options do not affect preceding include directives
 # rotate log files weekly
 weekly
 # keep 4 weeks worth of backlogs
 rotate 4
 # create new (empty) log files after rotating old ones
 create 0640 root utmp
 # use date as a suffix of the rotated file
 #dateext
 # uncomment this if you want your log files compressed
 #compress
 # packages drop log rotation information into this directory
 include /etc/logrotate.d
 # system-specific logs may also be configured here.
@@ -0,0 +1 @@
 install cramfs /bin/true
@@ -0,0 +1 @@
 install dccp /bin/true
@@ -0,0 +1 @@
 install freevxfs /bin/true
@@ -0,0 +1 @@
 install hfs /bin/true
@@ -0,0 +1 @@
 install hfsplus /bin/true
@@ -0,0 +1 @@
 install jffs2 /bin/true
@@ -0,0 +1 @@
 install rds /bin/true
@@ -0,0 +1 @@
 install sctp /bin/true
@@ -0,0 +1 @@
 install squashfs /bin/true
@@ -0,0 +1 @@
 install tipc /bin/true
@@ -0,0 +1 @@
 install udf /bin/true
@@ -0,0 +1 @@
 install usb-storage /bin/true
@@ -0,0 +1,21 @@
 driftfile /var/lib/ntp/ntp.drift
 leapfile /usr/share/zoneinfo/leap-seconds.list
 # Redundant upstream time sources: pfv-netinfra-01/02 (Technitium/Pi-hole hosts
 # also serving NTP). IPs are used (not hostnames) because the knel.net name for
 # these hosts resolves to a Tailscale CGNAT address, not the LAN address, and
 # because NTP must come up before DNS is available. iburst speeds initial sync.
 server 192.168.3.252 iburst
 server 192.168.3.253 iburst
 # Hardened client: sync from the configured servers but never serve time to
 # anyone else. Note: `interface listen 127.0.0.1` must NOT be used here — it
 # binds ntpd to loopback, making outbound queries carry a 127.0.0.1 source
 # address that upstream servers cannot reply to (symptoms: peers stuck in
 # .INIT. with reach 0). Use restrict rules to control access instead.
 restrict default ignore
 restrict 127.0.0.1
 restrict ::1
 restrict 192.168.3.252 nomodify notrap nopeer
 restrict 192.168.3.253 nomodify notrap nopeer
@@ -0,0 +1,2 @@
 # Uncomment to start SNMP subagent and enable CDP, SONMP and EDP protocol
 DAEMON_ARGS="-x -c -s -e"
@@ -0,0 +1,11 @@
 # Managed by KNELServerBuild — do not edit; changes will be overwritten.
 #
 # Redundant recursive DNS via pfv-netinfra-01/02 (Technitium + Pi-hole).
 # IPs are used (required: nameserver directives must be addresses, and the
 # knel.net name for these hosts resolves to a Tailscale CGNAT address rather
 # than the LAN address). If the primary is unreachable, glibc's resolver
 # automatically falls through to the secondary.
 domain knel.net
 search knel.net
 nameserver 192.168.3.252
 nameserver 192.168.3.253
@@ -0,0 +1,3 @@
 # See man 5 aliases for format
 postmaster:    root
 root: coo@turnsys.com
@@ -0,0 +1 @@
 /.*/    tsysrootaccount@knel.net
--- a/Show More
+++ b/Show More
		`@@ -0,0 +1,2 @@`
							`#/etc/cockpit/disallowed-users`
							`# List of users which are not allowed to login to Cockpit`
		`@@ -0,0 +1,2 @@`
							`# Uncomment to start SNMP subagent and enable CDP, SONMP and EDP protocol`
							`DAEMON_ARGS="-x -c -s -e"`