Test: Disable adb auth

.cargo/audit.toml

@@ -1,15 +0,0 @@
-[advisories]
-ignore = [
-    # RSA Marvin Attack in `rsa`, dragged in through rustcrypto (dev builds)
-    # and adb_client (USB signing only, unrelated to marvin attack which
-    # targets decryption).
-    "RUSTSEC-2023-0071",
-    # paste crate being unmaintained is not important. it's not dealing with
-    # user-input. we could get rid of this warning by disabling the image
-    # dependency in adb-client.
-    "RUSTSEC-2024-0436",
-    # rustls-webpki 0.102.8 CRL Distribution Point flaw (via rustls-rustcrypto).
-    # Only affects dev builds, production firmware uses ring-tls.
-    # TODO: Remove once rustls-rustcrypto releases a version newer than 0.0.2-alpha.
-    "RUSTSEC-2026-0049",
-]

.cargo/config.toml

@@ -1,17 +1,3 @@
-[alias]
-# Build the daemon with "firmware" profile and post-quantum TLS backend.
-# Needs an arm-linux-musleabihf cross-compiler in PATH, e.g. a toolchain
-# from https://musl.cc, or run inside messense/rust-musl-cross:armv7-musleabihf
-# (which is what CI does, see .github/workflows/main.yml).
-build-daemon-firmware = "build -p rayhunter-daemon --bin rayhunter-daemon --target armv7-unknown-linux-musleabihf --profile firmware --no-default-features --features pq-tls"
-# Build the daemon with "firmware-devel" profile and "rustcrypto" backend.
-# Works with just the Rust toolchain, and is medium-slow to build. Binaries are slightly larger.
-build-daemon-firmware-devel = "build -p rayhunter-daemon --bin rayhunter-daemon --target armv7-unknown-linux-musleabihf --profile firmware-devel"
-# Build rootshell for firmware
-build-rootshell-firmware = "build -p rootshell --bin rootshell --target armv7-unknown-linux-musleabihf --profile firmware"
-# Build rootshell for development
-build-rootshell-firmware-devel = "build -p rootshell --bin rootshell --target armv7-unknown-linux-musleabihf --profile firmware-devel"
-
 [target.aarch64-apple-darwin]
 linker = "rust-lld"
 rustflags = ["-C", "target-feature=+crt-static"]

.gitattributes

@@ -7,4 +7,3 @@
 dist/config.toml.in eol=lf
 dist/scripts/misc-daemon eol=lf
 dist/scripts/rayhunter_daemon eol=lf
-scripts/*.sh eol=lf

.github/ISSUE_TEMPLATE/bug.yaml

@@ -2,12 +2,6 @@ name: Bug Report
 description: File a bug report.
 labels: ["bug"]
 body:
-  - type: checkboxes
-    attributes:
-      label: Prerequisites
-      options:
-        - label: I have read [CONTRIBUTING.md](https://github.com/EFForg/rayhunter/blob/main/CONTRIBUTING.md)
-          required: true
   - type: textarea
     attributes:
       label: Bug Report Details

.github/ISSUE_TEMPLATE/config.yml

@@ -1,10 +1,8 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
-  - name: Frequently Asked Questions
-    url: https://efforg.github.io/rayhunter/faq.html
-  - name: Questions and community
-    url: https://efforg.github.io/rayhunter/support-feedback-community.html
-    about: If you're having trouble using Rayhunter and aren't sure you've found a bug or request for a new feature, please first try asking for help on GitHub discussions or Mattermost
+  - name: Rayhunter Mattermost
+    url: https://opensource.eff.org/signup_user_complete/?id=6iqur37ucfrctfswrs14iscobw&md=link&sbr=su
+    about: If you're having trouble using Rayhunter and aren't sure you've found a bug or request for a new feature, please first try asking for help here. There is a much larger community there of people familiar with the project who will be able to more quickly answer your questions.
   - name: Rayhunter Security Policy
     url: https://github.com/EFForg/rayhunter/security/advisories/new
     about: Please report security vulnerabilities here.

.github/ISSUE_TEMPLATE/feature.yaml

@@ -2,12 +2,6 @@ name: Feature Request
 description: Suggest a new feature or improvement to Rayhunter
 labels: ["enhancement"]
 body:
-  - type: checkboxes
-    attributes:
-      label: Prerequisites
-      options:
-        - label: I have read [CONTRIBUTING.md](https://github.com/EFForg/rayhunter/blob/main/CONTRIBUTING.md)
-          required: true
   - type: textarea
     id: problem
     attributes:

.github/ISSUE_TEMPLATE/installer-bug.yaml

@@ -2,12 +2,6 @@ name: Installer Issue
 description: File an bug related to an installer issue.
 labels: ["bug", "installer"]
 body:
-  - type: checkboxes
-    attributes:
-      label: Prerequisites
-      options:
-        - label: I have read [CONTRIBUTING.md](https://github.com/EFForg/rayhunter/blob/main/CONTRIBUTING.md)
-          required: true
   - type: input
     attributes:
       label: Rayhunter Version

.github/dependabot.yml

@@ -1,53 +0,0 @@
-# open-pull-requests-limit is used to disable automated version updates
-# security updates are unaffected. see
-# * https://docs.github.com/en/code-security/how-tos/secure-your-supply-chain/secure-your-dependencies/configuring-dependabot-version-updates#disabling-dependabot-version-updates
-# * https://docs.github.com/en/code-security/reference/supply-chain-security/dependabot-options-reference#open-pull-requests-limit-
-version: 2
-updates:
-  # Rust dependencies
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 0
-    groups:
-      security:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-
-  # Python dependencies
-  - package-ecosystem: "pip"
-    directory: "/tools"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 0
-    groups:
-      security:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-
-  # daemon/web Node.js dependencies
-  - package-ecosystem: "npm"
-    directory: "/daemon/web"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 0
-    groups:
-      security:
-        applies-to: "security-updates"
-        patterns:
-          - "*"
-
-  # installer-gui Node.js dependencies
-  - package-ecosystem: "npm"
-    directory: "/installer-gui"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 0
-    groups:
-      security:
-        applies-to: "security-updates"
-        patterns:
-          - "*"

.github/pull_request_template.md

@@ -1,13 +1,6 @@
 ## Pull Request Checklist
 
-- [ ] The Rayhunter team has recently expressed interest in reviewing a PR for this.
-  - If not, this PR may be closed due our limited resources and need to prioritize how we spend them.
+- [ ] The Rayhunter team has recently expressed interest in reviewing a PR for this. If not, this PR may be closed due our limited resources and need to prioritize how we spend them.
 - [ ] Added or updated any documentation as needed to support the changes in this PR.
-- [ ] Code has been linted and run through `cargo fmt`.
-- [ ] If any new functionality has been added, unit tests were also added.
-- [ ] [CONTRIBUTING.md](https://github.com/EFForg/rayhunter/blob/main/CONTRIBUTING.md) has been read.
-- [ ] Your pull request is fewer than ~400 lines of code.
-
-You must check one of:
-- [ ] No generative AI (including LLMs) tools were used to create this PR.
-- [ ] Generative AI was used to create this PR. I certify that I have read and understand the code, and *that all comments and descriptions were authored by myself* and are not the product of generative AI.
+- [ ] Code has been linted and run through `cargo fmt`
+- [ ] If any new functionality has been added, unit tests were also added

.github/workflows/main.yml

@@ -11,9 +11,6 @@ env:
   CARGO_TERM_COLOR: always
   FILE_ROOTSHELL: ../../rootshell/rootshell
   FILE_RAYHUNTER_DAEMON: ../../rayhunter-daemon/rayhunter-daemon
-  FILE_WPA_SUPPLICANT: ../../wpa-supplicant/wpa_supplicant
-  FILE_WPA_CLI: ../../wpa-supplicant/wpa_cli
-  FILE_IW: ../../wpa-supplicant/iw
   RUSTFLAGS: "-Dwarnings"
 
 jobs:
@@ -23,89 +20,66 @@ jobs:
     permissions:
       contents: read
     outputs:
-      code_changed: ${{ steps.files_changed.outputs.code_count != '0' }}
-      daemon_changed: ${{ steps.files_changed.outputs.daemon_count != '0' }}
-      daemon_needed: ${{ steps.files_changed.outputs.daemon_count != '0' || steps.files_changed.outputs.installer_build != '0' }}
-      web_changed: ${{ steps.files_changed.outputs.web_count != '0' }}
-      docs_changed: ${{ steps.files_changed.outputs.docs_count != '0' || steps.files_changed.outputs.daemon_count != '0' }}
-      installer_changed: ${{ steps.files_changed.outputs.installer_count != '0' }}
-      installer_gui_changed: ${{ steps.files_changed.outputs.installer_gui_count != '0' }}
-      rootshell_needed: ${{ steps.files_changed.outputs.rootshell_count != '0' || steps.files_changed.outputs.installer_build != '0' }}
+      code_changed: ${{ steps.files_changed.outputs.code_count }}
+      daemon_changed: ${{ steps.files_changed.outputs.daemon_count }}
+      web_changed: ${{ steps.files_changed.outputs.web_count }}
+      docs_changed: ${{ steps.files_changed.outputs.docs_count }}
+      installer_changed: ${{ steps.files_changed.outputs.installer_count }}
+      rootshell_changed: ${{ steps.files_changed.outputs.rootshell_count }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          persist-credentials: false
       - name: detect file changes
         id: files_changed
         run: |
           lcommit=${{ github.event.pull_request.base.sha || 'origin/main' }}
 
-          # If we are on main, if workflow/cargo config files changed, or if
-          # the latest commit message contains "#build-all", run everything.
-          # Use #build-all in a commit message to force a full build on a PR
-          # branch (useful for testing release builds without merging to main).
-          if [ ${GITHUB_REF} = 'refs/heads/main' ] || git diff --name-only $lcommit..HEAD | grep -qe ^.github/workflows/ -e ^.cargo || git log -1 --format='%s %b' | grep -qF '#build-all'
+          # If we are on main, or if these workflow files are being changed, run everything
+          if [ ${{ github.ref }} = 'refs/heads/main' ] || git diff --name-only $lcommit..HEAD | grep -qe ^.github/workflows/ -e ^.cargo
           then
             echo "building everything"
             echo code_count=forced >> "$GITHUB_OUTPUT"
             echo daemon_count=forced >> "$GITHUB_OUTPUT"
             echo web_count=forced >> "$GITHUB_OUTPUT"
             echo docs_count=forced >> "$GITHUB_OUTPUT"
-            echo installer_build=forced >> "$GITHUB_OUTPUT"
             echo installer_count=forced >> "$GITHUB_OUTPUT"
-            echo installer_gui_count=forced >> "$GITHUB_OUTPUT"
             echo rootshell_count=forced >> "$GITHUB_OUTPUT"
           else
             echo "code_count=$(git diff --name-only $lcommit...HEAD | grep -e ^daemon -e ^installer -e ^check -e ^lib -e ^rootshell -e ^telcom-parser | wc -l)" >> "$GITHUB_OUTPUT"
             echo "daemon_count=$(git diff --name-only $lcommit...HEAD | grep -e ^daemon -e ^lib -e ^telcom-parser | wc -l)" >> "$GITHUB_OUTPUT"
             echo "web_count=$(git diff --name-only $lcommit...HEAD | grep -e ^daemon/web | wc -l)" >> "$GITHUB_OUTPUT"
             echo "docs_count=$(git diff --name-only $lcommit...HEAD | grep -e ^book.toml -e ^doc | wc -l)" >> "$GITHUB_OUTPUT"
+            echo "installer_count=$(git diff --name-only $lcommit...HEAD | grep -e ^installer | wc -l)" >> "$GITHUB_OUTPUT"
             echo "rootshell_count=$(git diff --name-only $lcommit...HEAD | grep -e ^rootshell | wc -l)" >> "$GITHUB_OUTPUT"
-
-            installer_count=$(git diff --name-only $lcommit...HEAD | grep -e ^installer/ | wc -l)
-            installer_gui_count=$(git diff --name-only $lcommit...HEAD | grep -e ^installer-gui | wc -l)
-
-            if [ $installer_count != "0" ] || [ $installer_gui_count != "0" ]; then
-              echo "installer_build=1" >> "$GITHUB_OUTPUT"
-            else
-              echo "installer_build=0" >> "$GITHUB_OUTPUT"
-            fi
-
-            echo "installer_count=$installer_count" >> "$GITHUB_OUTPUT"
-            echo "installer_gui_count=$installer_gui_count" >> "$GITHUB_OUTPUT"
           fi
 
   mdbook_test:
     name: Test mdBook Documentation builds
     needs: files_changed
-    if: needs.files_changed.outputs.docs_changed == 'true'
+    if: needs.files_changed.outputs.docs_changed != '0'
     runs-on: ubuntu-latest
     permissions:
       contents: read
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: Swatinem/rust-cache@v2
       - name: Install mdBook
         run: |
           cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
       - name: Test mdBook
         run: mdbook test
 
-  mdbook_build:
-    name: Build mdBook for Github Pages
+  mdbook_publish:
+    name: Publish mdBook to Github Pages
     needs: mdbook_test
     if: ${{ github.ref == 'refs/heads/main' }}
     permissions:
+      pages: write
       contents: write
+      id-token: write
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: Swatinem/rust-cache@v2
       - name: Install mdBook
         run: |
           cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
@@ -113,25 +87,24 @@ jobs:
       - name: Build mdBook
         run: mdbook build
 
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
       - name: Upload artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-pages-artifact@v3
         with:
-          name: book
           path: book
+      - name: Deploy to Github Pages
+        uses: actions/deploy-pages@v4
 
   check_and_test:
     needs: files_changed
-    if: needs.files_changed.outputs.code_changed == 'true'
+    if: needs.files_changed.outputs.code_changed != '0'
     runs-on: ubuntu-latest
     permissions:
       contents: read
     steps:
     - uses: actions/checkout@v4
-      with:
-        persist-credentials: false
     - uses: dtolnay/rust-toolchain@stable
-      with:
-        components: rustfmt, clippy
     - uses: Swatinem/rust-cache@v2
     - name: Check formatting
       run: cargo fmt --all --check
@@ -141,45 +114,17 @@ jobs:
         npm install
         npm run build
         popd
-        cargo check --verbose
+        NO_FIRMWARE_BIN=true cargo check --verbose
     - name: Run tests
       run: |
-        cargo test --verbose
+        NO_FIRMWARE_BIN=true cargo test --verbose
     - name: Run clippy
       run: |
-        cargo clippy --verbose
+        NO_FIRMWARE_BIN=true cargo clippy --verbose
 
-  installer_gui_check:
-    # we test the GUI installer separately to:
-    # 1) mimic the default behavior of cargo commands for rayhunter devs where
-    #    installer-gui isn't one of the default workspace packages
-    # 2) avoid slowing down development on changes unrelated to the GUI installer
+  test_web_frontend:
     needs: files_changed
-    if: needs.files_changed.outputs.installer_gui_changed == 'true'
-    # we run this on macos simply because no additional OS packages need to be
-    # installed
-    runs-on: macos-latest
-    permissions:
-      contents: read
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        persist-credentials: false
-    - uses: dtolnay/rust-toolchain@stable
-      with:
-        components: clippy
-    - uses: Swatinem/rust-cache@v2
-    # we don't need to run cargo fmt here because both cargo fmt and cargo
-    # fmt --all runs on all workspace packages so this is handled by
-    # check_and_test above
-    - name: Check
-      run: cargo check --package installer-gui --verbose
-    - name: Run clippy
-      run: cargo clippy --package installer-gui --verbose
-
-  test_daemon_frontend:
-    needs: files_changed
-    if: needs.files_changed.outputs.web_changed == 'true'
+    if: needs.files_changed.outputs.web_changed != '0'
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -188,54 +133,33 @@ jobs:
         working-directory: daemon/web
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - run: npm install
       - run: npm run lint
       - run: npm run check
       - run: npm run test
 
-  test_installer_frontend:
-    needs: files_changed
-    if: needs.files_changed.outputs.installer_gui_changed == 'true'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    defaults:
-      run:
-        working-directory: installer-gui
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - run: npm install
-      - run: npm run lint
-      - run: npm run check
-
   windows_installer_check_and_test:
     needs: files_changed
-    if: needs.files_changed.outputs.installer_changed == 'true'
+    if: needs.files_changed.outputs.installer_changed != '0'
     runs-on: windows-latest
     permissions:
       contents: read
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: Swatinem/rust-cache@v2
       - name: cargo check
         shell: bash
         run: |
           cd installer
-          cargo check --verbose
+          NO_FIRMWARE_BIN=true cargo check --verbose
       - name: cargo test
         shell: bash
         run: |
           cd installer
-          cargo test --verbose --no-default-features
+          NO_FIRMWARE_BIN=true cargo test --verbose --no-default-features
 
   build_rayhunter_check:
-    if: needs.files_changed.outputs.daemon_changed == 'true'
+    if: needs.files_changed.outputs.daemon_changed != '0'
     needs:
       - check_and_test
       - files_changed
@@ -266,8 +190,6 @@ jobs:
     runs-on: ${{ matrix.platform.os }}
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.platform.target }}
@@ -281,7 +203,7 @@ jobs:
           if-no-files-found: error
 
   build_rootshell:
-    if: needs.files_changed.outputs.rootshell_needed == 'true'
+    if: needs.files_changed.outputs.rootshell_changed != '0'
     needs:
       - check_and_test
       - files_changed
@@ -290,46 +212,20 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: armv7-unknown-linux-musleabihf
       - uses: Swatinem/rust-cache@v2
       - name: Build rootshell (armv7)
-        run: cargo build -p rootshell --bin rootshell --target armv7-unknown-linux-musleabihf --profile=firmware
+        run: cargo build --bin rootshell --target armv7-unknown-linux-musleabihf --profile=firmware
       - uses: actions/upload-artifact@v4
         with:
           name: rootshell
           path: target/armv7-unknown-linux-musleabihf/firmware/rootshell
           if-no-files-found: error
 
-  build_wpa_supplicant:
-    if: needs.files_changed.outputs.installer_changed == 'true'
-    needs:
-      - files_changed
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - name: Install cross-compiler
-        run: sudo apt-get update && sudo apt-get install -y gcc-arm-linux-gnueabihf
-      - name: Build wpa_supplicant (armv7)
-        run: CC=arm-linux-gnueabihf-gcc STRIP=arm-linux-gnueabihf-strip HOST=arm-linux-gnueabihf scripts/build-wpa-supplicant.sh
-      - uses: actions/upload-artifact@v4
-        with:
-          name: wpa-supplicant
-          path: |
-            tools/build-wpa-supplicant/out/wpa_supplicant
-            tools/build-wpa-supplicant/out/wpa_cli
-            tools/build-wpa-supplicant/out/iw
-          if-no-files-found: error
-
   build_rayhunter:
-    if: needs.files_changed.outputs.daemon_needed == 'true'
+    if: needs.files_changed.outputs.daemon_changed != '0'
     needs:
       - check_and_test
       - files_changed
@@ -339,27 +235,25 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
         with:
-          persist-credentials: false
-      - name: Build frontend
+          targets: armv7-unknown-linux-musleabihf
+      - uses: Swatinem/rust-cache@v2
+      - name: Build rayhunter-daemon (armv7)
         run: |
           pushd daemon/web
           npm install
           npm run build
           popd
-      - name: Build rayhunter-daemon (armv7)
-        # Cross-compile inside messense/rust-musl-cross, which bundles an
-        # arm-linux-musleabihf cross gcc that aws-lc-sys needs.
-        run: |
-          mkdir -p "$HOME/.cargo-musl-cross"
-          docker run --rm \
-            --user "$(id -u):$(id -g)" \
-            -v "$PWD":/work \
-            -v "$HOME/.cargo-musl-cross":/cargo-home \
-            -e CARGO_HOME=/cargo-home \
-            -w /work \
-            messense/rust-musl-cross:armv7-musleabihf \
-            cargo build-daemon-firmware
+          # Run with -p so that cargo will select the minimum feature set for this package.
+          #
+          # Otherwise, it will consider the union of all requested features
+          # from all packages in the workspace. For example, if installer
+          # requires tokio with "full" feature, it will be included no matter
+          # what the feature selection in rayhunter-daemon is.
+          #
+          # https://github.com/rust-lang/cargo/issues/4463
+          cargo build -p rayhunter-daemon --bin rayhunter-daemon --target armv7-unknown-linux-musleabihf --profile=firmware
       - uses: actions/upload-artifact@v4
         with:
           name: rayhunter-daemon
@@ -367,14 +261,13 @@ jobs:
           if-no-files-found: error
 
   build_rust_installer:
-    if: needs.files_changed.outputs.installer_changed == 'true'
+    if: needs.files_changed.outputs.installer_changed != '0'
     permissions:
       contents: read
       packages: write
     needs:
       - build_rayhunter
       - build_rootshell
-      - build_wpa_supplicant
       - files_changed
       - windows_installer_check_and_test
     strategy:
@@ -401,8 +294,6 @@ jobs:
     runs-on: ${{ matrix.platform.os }}
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: actions/download-artifact@v4
       - uses: dtolnay/rust-toolchain@stable
         with:
@@ -415,145 +306,6 @@ jobs:
           path: target/${{ matrix.platform.target }}/release/installer${{ matrix.platform.os == 'windows-latest' && '.exe' || '' }}
           if-no-files-found: error
 
-  build_installer_gui_linux:
-    if: needs.files_changed.outputs.installer_gui_changed == 'true'
-    permissions:
-      contents: read
-      packages: write
-    needs:
-      - build_rayhunter
-      - build_rootshell
-      - files_changed
-      - installer_gui_check
-      - test_installer_frontend
-    strategy:
-      matrix:
-        platform:
-          # we want to use the oldest supported version of ubuntu here to
-          # maximize compatibility with older versions of glibc
-          - name: linux-x64
-            os: ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
-          - name: linux-aarch64
-            os: ubuntu-22.04-arm
-            target: aarch64-unknown-linux-gnu
-    runs-on: ${{ matrix.platform.os }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.platform.target }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Install tauri dependencies
-        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.1-dev build-essential curl wget file libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev xdg-utils
-      - name: Build GUI installer
-        shell: bash
-        run: |
-          cd installer-gui
-          npm install
-          npm run tauri build -- --target ${{ matrix.platform.target }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-${{ matrix.platform.name }}-appimage
-          path: target/${{ matrix.platform.target }}/release/bundle/appimage/*.AppImage
-          if-no-files-found: error
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-${{ matrix.platform.name }}-deb
-          path: target/${{ matrix.platform.target }}/release/bundle/deb/*.deb
-          if-no-files-found: error
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-${{ matrix.platform.name }}-rpm
-          path: target/${{ matrix.platform.target }}/release/bundle/rpm/*.rpm
-          if-no-files-found: error
-
-  build_installer_gui_macos:
-    if: needs.files_changed.outputs.installer_gui_changed == 'true'
-    permissions:
-      contents: read
-      packages: write
-    needs:
-      - build_rayhunter
-      - build_rootshell
-      - files_changed
-      - installer_gui_check
-      - test_installer_frontend
-    strategy:
-      matrix:
-        platform:
-          - name: macos-arm
-            target: aarch64-apple-darwin
-          - name: macos-intel
-            target: x86_64-apple-darwin
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.platform.target }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Build GUI installer
-        shell: bash
-        run: |
-          cd installer-gui
-          npm install
-          npm run tauri build -- --target ${{ matrix.platform.target }}
-          cd ..
-          mv "target/${{ matrix.platform.target }}/release/bundle/macos/"*.app .
-          zip -r "rayhunter-installer-${{ matrix.platform.name }}.app.zip" ./*.app
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-${{ matrix.platform.name }}-app
-          path: ./*.app.zip
-          if-no-files-found: error
-
-  build_installer_gui_windows:
-    if: needs.files_changed.outputs.installer_gui_changed == 'true'
-    permissions:
-      contents: read
-      packages: write
-    needs:
-      - build_rayhunter
-      - build_rootshell
-      - files_changed
-      - installer_gui_check
-      - test_installer_frontend
-    env:
-      TARGET: x86_64-pc-windows-msvc
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ env.TARGET }}
-      - uses: Swatinem/rust-cache@v2
-      - name: Build GUI installer
-        shell: bash
-        run: |
-          cd installer-gui
-          npm install
-          npm run tauri build -- --target ${{ env.TARGET }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-msi
-          path: target/${{ env.TARGET }}/release/bundle/msi/*.msi
-          if-no-files-found: error
-      - uses: actions/upload-artifact@v4
-        with:
-          name: gui-installer-exe
-          path: target/${{ env.TARGET }}/release/bundle/nsis/*.exe
-          if-no-files-found: error
-
   build_release_zip:
     permissions:
       contents: read
@@ -575,8 +327,6 @@ jobs:
           - windows-x86_64
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: actions/download-artifact@v4
       - name: Fix executable permissions on binaries
         run: chmod +x installer-*/installer rayhunter-check-*/rayhunter-check rayhunter-daemon/rayhunter-daemon
@@ -586,7 +336,7 @@ jobs:
       - name: Setup versioned release directory
         run: |
           platform="${{ matrix.platform }}"
-          dest="rayhunter-v${VERSION}-${{ matrix.platform }}"
+          dest="rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}"
           mkdir "$dest"
           # Handle installer with proper extension for Windows
           if [ "$platform" = "windows-x86_64" ]; then
@@ -594,7 +344,7 @@ jobs:
           else
             mv installer-$platform/installer "$dest"/installer
           fi
-          cp -r rayhunter-check-* rayhunter-daemon dist/scripts "$dest"/
+          cp -r rayhunter-check-* rayhunter-daemon rootshell/rootshell dist/* installer/install.ps1 "$dest"/
           zip -r "$dest.zip" "$dest"
           sha256sum "$dest.zip" > "$dest.zip.sha256"
 
@@ -606,57 +356,3 @@ jobs:
             rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}.zip
             rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}.zip.sha256
           if-no-files-found: error
-
-  openapi_build:
-    if: needs.files_changed.outputs.docs_changed == 'true'
-    needs:
-      - files_changed
-    permissions:
-      contents: write
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: armv7-unknown-linux-musleabihf
-      - uses: Swatinem/rust-cache@v2
-      - name: Build rayhunter-daemon openapi docs
-        run: |
-          mkdir -p daemon/web/build
-          touch daemon/web/build/{favicon.png,index.html.gz,rayhunter_orca_only.png,rayhunter_text.png}
-          cargo run --bin gen_api --features apidocs -- ./rayhunter-openapi.json
-      - name: Make swagger folder
-        run: |
-          mkdir api-docs
-          mv doc/swagger-ui.html api-docs/index.html
-          mv rayhunter-openapi.json api-docs/
-      - uses: actions/upload-artifact@v4
-        with:
-          name: api-docs
-          path: api-docs
-
-  github_pages_publish:
-    name: Upload new documentation to Github Pages
-    if: ${{ github.ref == 'refs/heads/main' }}
-    permissions:
-      pages: write
-      contents: write
-      id-token: write
-    needs:
-      - mdbook_build
-      - openapi_build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Setup Pages
-        uses: actions/configure-pages@v4
-      - uses: actions/download-artifact@v4
-      - name: Organize pages into directory
-        run: cp -a api-docs book/
-      - name: Upload pages
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: book
-      - name: Deploy Github Pages
-        uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -14,12 +14,10 @@ jobs:
       contents: read
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - name: Ensure all Cargo.toml files have the same version defined.
         run: |
-          defined_versions=$(find lib check daemon installer installer-gui rootshell telcom-parser -name Cargo.toml -exec grep ^version {} \; | sort -u | wc -l)
-          find lib check daemon installer installer-gui rootshell telcom-parser -name Cargo.toml -exec grep ^version {} \;
+          defined_versions=$(find lib check daemon installer rootshell telcom-parser -name Cargo.toml -exec grep ^version {} \; | sort -u | wc -l)
+          find lib check daemon installer rootshell telcom-parser -name Cargo.toml -exec grep ^version {} \;
           echo number of defined versions = $defined_versions
           if [ $defined_versions != "1" ]
           then
@@ -43,8 +41,6 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v4
-        with:
-          persist-credentials: false
       - uses: actions/download-artifact@v4
       - name: Create release
         run: |

.gitignore

@@ -1,4 +1,3 @@
 /target
 /book
 .DS_Store
-/tools/build-wpa-supplicant

CONTRIBUTING.md

@@ -1,85 +0,0 @@
-# How to contribute to Rayhunter
-
-## Filing issues and starting discussions
-
-Our issue tracker is [on GitHub](https://github.com/EFForg/rayhunter/issues).
-
-- If your rayhunter has found an IMSI-catcher, we strongly encourage you to
-  [send us that information
-  privately.](https://efforg.github.io/rayhunter/faq.html#help-rayhunters-line-is-redorangeyellowdotteddashed-what-should-i-do) via Signal.
-
-- Issues should be actionable. If you don't have a
-  specific feature request or bug report, consider [creating a
-  discussion](https://github.com/EFForg/rayhunter/discussions) or [joining our Mattermost](https://efforg.github.io/rayhunter/support-feedback-community.html) instead.
-
-  Example of a good bug report:
-
-  - "Installer broken on TP-Link M7350 v3.0"
-  - "Display does not update to green after finding"
-  - "The documentation is wrong" (though we encourage you to file a pull request directly)
-
-  Example of a good feature request:
-
-  - "Use LED on device XYZ for showing recording status"
-
-  Example of something that belongs into discussion:
-
-  - "In region XYZ, do I need an activated SIM?"
-  - "Where to buy this device in region XYZ?"
-  - "Can this device be supported?" While this is a valid feature
-    request, we just get this request too often, and without some exploratory
-    work done upfront it's often unclear initially if that device can be
-    supported at all.
-
-- The issue templates are mostly there to give you a clue what kind of
-  information is needed from you, and whether your request belongs into the issue
-  tracker. Fill them out to be on the safe side, but they are not mandatory.
-
-## Contributing patches
-
-To edit documentation or fix a bug, make a pull request. If you're about to
-write a substantial amount of code or implement a new feature, we strongly
-encourage you to talk to us before implementing it or check if any issues have
-been opened for it already. Otherwise there is a chance we will reject your
-contribution after you have spent time on it.
-
-On the other hand, for small documentation fixes you can file a PR without
-filing an issue.
-
-Otherwise:
-
-- Refer to [installing from
-  source](https://efforg.github.io/rayhunter/installing-from-source.html) for
-  how to build Rayhunter from the git repository.
-
-- Ensure that `cargo fmt` and `cargo clippy` have been run.
-
-- If you add new features, please do your best to both write tests for and also
-  manually test them. Our test coverage isn't great, but as new features are
-  added we are trying to prevent it from becoming worse.
-
-- Please keep your contributions to less than approximately 400 lines of code not counting tests, (going slightly over is fine, we aren't dogmatic about it.) This is because we are not able to give quality code review to contributions larger than that and risk introducing bugs into the system. [There was a study showing 400 LOC is the max most humans can handle.](https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/)
-
-If you have any questions [feel free to open a discussion or chat with us on Mattermost.](https://efforg.github.io/rayhunter/support-feedback-community.html)
-
-### Policy regarding AI-generated contributions:
-
-- Please refrain from submissions that you haven't thoroughly understood, reviewed, and tested.
-- Please disclose if your contribution was AI-generated
-- Descriptions and comments should be made by you
-
-You can read our [full policy](https://www.eff.org/about/opportunities/volunteer/coding-with-eff) and some writing on [our motivations](https://www.eff.org/deeplinks/2026/02/effs-policy-llm-assisted-contributions-our-open-source-projects).
-
-## Making releases
-
-This one is for maintainers of Rayhunter.
-
-1. Make a PR changing the versions in `Cargo.toml` and other files.
-   This could be automated better but right now it's manual. You can do this easily with sed:
-   `sed -i "" -E 's/x.x.x/y.y.y/g' */Cargo.toml installer-gui/src-tauri/Cargo.toml`
-
-2. Merge PR and make a tag.
-
-3. [Run release workflow.](https://github.com/EFForg/rayhunter/actions/workflows/release.yml)
-
-4. Write changelog, edit it into the release, announce on mattermost.

Cargo.toml

@@ -7,17 +7,5 @@ members = [
     "rootshell",
     "telcom-parser",
     "installer",
-    "installer-gui/src-tauri",
-]
-# at least for now, let's keep installer-gui out of the list of default
-# packages. installer-gui is still experimental and requires many new packages
-# both from cargo and the underlying operating system
-default-members = [
-    "lib",
-    "daemon",
-    "check",
-    "rootshell",
-    "telcom-parser",
-    "installer",
 ]
 resolver = "2"

README.md

@@ -3,7 +3,7 @@
 
 ![Rayhunter Logo - An Orca taking a bite out of a cellular signal bar](https://www.eff.org/files/styles/media_browser_preview/public/banner_library/rayhunter-banner.png)
 
-Rayhunter is a project for detecting IMSI catchers, also known as cell-site simulators or stingrays. It was first designed to run on a cheap mobile hotspot called the Orbic RC400L, but thanks to community efforts, it can [support some other devices as well](https://efforg.github.io/rayhunter/supported-devices.html).
+Rayhunter is a project for detecting IMSI catchers, also known as cell-site simulators or stingrays. It was first designed to run on a cheap mobile hotspot called the Orbic RC400L, but thanks to community efforts can [support some other devices as well](https://efforg.github.io/rayhunter/supported-devices.html).
 It's also designed to be as easy to install and use as possible, regardless of your level of technical skills, and to minimize false positives. 
 
 →  Check out the [installation guide](https://efforg.github.io/rayhunter/installation.html) to get started.

book.toml

@@ -6,4 +6,3 @@ title = "Rayhunter - An IMSI Catcher Catcher"
 
 [output.html]
 edit-url-template = "https://github.com/efforg/rayhunter/edit/main/{path}"
-additional-css = ["doc/custom.css"]

check/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rayhunter-check"
-version = "0.10.2"
+version = "0.6.1"
 edition = "2024"
 
 [dependencies]
@@ -10,4 +10,5 @@ log = "0.4.20"
 tokio = { version = "1.44.2", default-features = false, features = ["fs", "signal", "process", "rt-multi-thread"] }
 pcap-file-tokio = "0.1.0"
 clap = { version = "4.5.2", features = ["derive"] }
+simple_logger = "5.0.0"
 walkdir = "2.5.0"

check/src/main.rs

@@ -16,19 +16,19 @@ use walkdir::WalkDir;
 #[derive(Parser, Debug)]
 #[command(version, about)]
 struct Args {
-    #[arg(short = 'p', long, help = "A file or directory of packet captures")]
+    #[arg(short = 'p', long)]
     path: PathBuf,
 
-    #[arg(short = 'P', long, help = "Convert qmdl files to pcap before analysis")]
+    #[arg(short = 'P', long)]
     pcapify: bool,
 
-    #[arg(long, help = "Show why some packets were skipped during analysis")]
+    #[arg(long)]
     show_skipped: bool,
 
-    #[arg(short, long, help = "Only print warnings/errors to stdout")]
+    #[arg(short, long)]
     quiet: bool,
 
-    #[arg(short, long, help = "Show debug messages")]
+    #[arg(short, long)]
     debug: bool,
 }
 
@@ -177,7 +177,14 @@ async fn main() {
     } else {
         log::LevelFilter::Info
     };
-    rayhunter::init_logging(level);
+    simple_logger::SimpleLogger::new()
+        .with_colors(true)
+        .without_timestamps()
+        .with_level(level)
+        //Filter out a stupid massive amount of uneccesary warnings from hampi about undecoded extensions
+        .with_module_level("asn1_codecs", log::LevelFilter::Error)
+        .init()
+        .unwrap();
 
     let harness = Harness::new_with_config(&AnalyzerConfig::default());
     info!("Analyzers:");

daemon/Cargo.toml

@@ -1,27 +1,11 @@
 [package]
 name = "rayhunter-daemon"
-version = "0.10.2"
+version = "0.6.1"
 edition = "2024"
 rust-version = "1.88.0"
 
-[lib]
-name = "rayhunter_daemon"
-path = "src/lib.rs"
-
-[[bin]]
-name = "gen_api"
-path = "src/bin/gen_api.rs"
-required-features = ["apidocs"]
-
-[features]
-default = ["rustcrypto-tls"]
-rustcrypto-tls = ["reqwest/rustls-tls-webpki-roots-no-provider", "dep:rustls-rustcrypto"]
-pq-tls = ["reqwest/rustls-tls-webpki-roots-no-provider", "dep:rustls-post-quantum"]
-apidocs = ["dep:utoipa", "wifi-station/utoipa"]
-
 [dependencies]
 rayhunter = { path = "../lib" }
-wifi-station = { git = "https://github.com/BeigeBox/wifi-station", rev = "e8ec5b4" }
 toml = "0.8.8"
 serde = { version = "1.0.193", features = ["derive"] }
 tokio = { version = "1.44.2", default-features = false, features = ["fs", "signal", "process", "rt"] }
@@ -29,6 +13,7 @@ axum = { version = "0.8", default-features = false, features = ["http1", "tokio"
 thiserror = "1.0.52"
 libc = "0.2.150"
 log = "0.4.20"
+env_logger = { version = "0.11", default-features = false }
 tokio-util = { version = "0.7.10", features = ["rt", "io", "compat"] }
 futures-macro = "0.3.30"
 include_dir = "0.7.3"
@@ -37,12 +22,11 @@ tokio-stream = { version = "0.1.14", default-features = false, features = ["io-u
 futures = { version = "0.3.30", default-features = false }
 serde_json = "1.0.114"
 image = { version =  "0.25.1", default-features = false, features = ["png", "gif"] }
-tempfile = "3.10.2"
+tempfile = "3.10.1"
 async_zip = { version = "0.0.17", features = ["tokio"] }
 anyhow = "1.0.98"
-reqwest = { version = "0.12.20", default-features = false, features = ["stream"] }
-rustls-rustcrypto = { version = "0.0.2-alpha", optional = true }
-rustls-post-quantum = { version = "0.2.4", optional = true }
+reqwest = { version = "0.12.20", default-features = false, features = [
+    "rustls-tls-webpki-roots-no-provider",
+] }
+rustls-rustcrypto = "0.0.2-alpha"
 async-trait = "0.1.88"
-utoipa = { version = "5.4.0", optional = true }
-url = "2.5.4"

daemon/src/analysis.rs

@@ -77,15 +77,10 @@ impl AnalysisWriter {
     }
 }
 
-/// The system status relating to QMDL file analysis
 #[derive(Debug, Serialize, Clone)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct AnalysisStatus {
-    /// The vector array of queued files
     queued: Vec<String>,
-    /// The file currently being analyzed
     running: Option<String>,
-    /// The vector array of finished files
     finished: Vec<String>,
 }
 
@@ -220,16 +215,6 @@ pub fn run_analysis_thread(
     });
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/analysis",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = AnalysisStatus)
-    ),
-    summary = "Analysis status",
-    description = "Show analysis status for all QMDL files."
-))]
 pub async fn get_analysis_status(
     State(state): State<Arc<ServerState>>,
 ) -> Result<Json<AnalysisStatus>, (StatusCode, String)> {
@@ -246,20 +231,6 @@ fn queue_qmdl(name: &str, analysis_status: &mut RwLockWriteGuard<AnalysisStatus>
     true
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/analysis/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Unable to queue analysis file")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL file to analyze")
-    ),
-    summary = "Start analysis",
-    description = "Begin analysis of QMDL file {name}."
-))]
 pub async fn start_analysis(
     State(state): State<Arc<ServerState>>,
     Path(qmdl_name): Path<String>,

daemon/src/battery/mod.rs

@@ -1,30 +1,17 @@
-use std::{path::Path, time::Duration};
+use std::path::Path;
 
-use log::{info, warn};
 use rayhunter::Device;
 use serde::Serialize;
-use tokio::select;
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
-use crate::{
-    error::RayhunterError,
-    notifications::{Notification, NotificationType},
-};
+use crate::error::RayhunterError;
 
 pub mod orbic;
 pub mod tmobile;
-pub mod tplink;
 pub mod wingtech;
 
-const LOW_BATTERY_LEVEL: u8 = 10;
-
-/// Device battery information
 #[derive(Clone, Copy, PartialEq, Debug, Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct BatteryState {
-    /// The current level in percentage of the device battery
     level: u8,
-    /// A boolean indicating whether the battery is currently being charged
     is_plugged_in: bool,
 }
 
@@ -55,67 +42,6 @@ pub async fn get_battery_status(device: &Device) -> Result<BatteryState, Rayhunt
         Device::Orbic => orbic::get_battery_state().await?,
         Device::Wingtech => wingtech::get_battery_state().await?,
         Device::Tmobile => tmobile::get_battery_state().await?,
-        Device::Tplink => tplink::get_battery_state().await?,
         _ => return Err(RayhunterError::FunctionNotSupportedForDeviceError),
     })
 }
-
-pub fn run_battery_notification_worker(
-    task_tracker: &TaskTracker,
-    device: Device,
-    notification_channel: tokio::sync::mpsc::Sender<Notification>,
-    shutdown_token: CancellationToken,
-) {
-    task_tracker.spawn(async move {
-        // Don't send a notification initially if the device starts at a low battery level.
-        let mut triggered = match get_battery_status(&device).await {
-            Err(RayhunterError::FunctionNotSupportedForDeviceError) => {
-                info!("Battery status not supported for this device, disabling battery notifications");
-                return;
-            }
-            Err(e) => {
-                warn!("Failed to get battery status: {e}");
-                true
-            }
-            Ok(status) => status.level <= LOW_BATTERY_LEVEL,
-        };
-
-        loop {
-            select! {
-                _ = shutdown_token.cancelled() => break,
-                _ = tokio::time::sleep(Duration::from_secs(15)) => {}
-            }
-
-            let status = match get_battery_status(&device).await {
-                Err(RayhunterError::FunctionNotSupportedForDeviceError) => {
-                    info!("Battery status not supported for this device, disabling battery notifications");
-                    break;
-                }
-                Err(e) => {
-                    warn!("Failed to get battery status: {e}");
-                    continue;
-                }
-                Ok(status) => status,
-            };
-
-            // To avoid flapping, if the notification has already been triggered
-            // wait until the device has been plugged in and the battery level
-            // is high enough to re-enable notifications.
-            if triggered && status.is_plugged_in && status.level > LOW_BATTERY_LEVEL {
-                triggered = false;
-                continue;
-            }
-            if !triggered && !status.is_plugged_in && status.level <= LOW_BATTERY_LEVEL {
-                notification_channel
-                    .send(Notification::new(
-                        NotificationType::LowBattery,
-                        "Rayhunter's battery is low".to_string(),
-                        None,
-                    ))
-                    .await
-                    .expect("Failed to send to notification channel");
-                triggered = true;
-            }
-        }
-    });
-}

daemon/src/battery/tplink.rs

@@ -1,39 +0,0 @@
-use crate::{battery::BatteryState, error::RayhunterError};
-
-pub async fn get_battery_state() -> Result<BatteryState, RayhunterError> {
-    let uci_battery = tokio::process::Command::new("uci")
-        .arg("get")
-        .arg("battery.battery_mgr.power_level")
-        .output()
-        .await?;
-
-    let uci_plugged_in = tokio::process::Command::new("uci")
-        .arg("get")
-        .arg("battery.battery_mgr.is_charging")
-        .output()
-        .await?;
-
-    if !uci_battery.status.success() {
-        return Err(RayhunterError::BatteryLevelParseError);
-    }
-
-    if !uci_plugged_in.status.success() {
-        return Err(RayhunterError::BatteryPluggedInStatusParseError);
-    }
-
-    let uci_battery = String::from_utf8_lossy(&uci_battery.stdout)
-        .trim_end()
-        .parse()
-        .map_err(|_| RayhunterError::BatteryLevelParseError)?;
-
-    let uci_plugged_in = match String::from_utf8_lossy(&uci_plugged_in.stdout).trim_end() {
-        "0" => Ok(false),
-        "1" => Ok(true),
-        _ => Err(RayhunterError::BatteryPluggedInStatusParseError),
-    }?;
-
-    Ok(BatteryState {
-        level: uci_battery,
-        is_plugged_in: uci_plugged_in,
-    })
-}

daemon/src/bin/gen_api.rs

@@ -1,12 +0,0 @@
-use std::{env, fs};
-
-fn main() {
-    let content = rayhunter_daemon::ApiDocs::generate();
-    let mut filename = "openapi.json".to_string();
-    let args: Vec<String> = env::args().collect();
-    if args.len() > 1 {
-        filename = args[1].to_string();
-    }
-
-    fs::write(filename, content).unwrap();
-}

daemon/src/config.rs

@@ -5,88 +5,19 @@ use rayhunter::Device;
 use rayhunter::analysis::analyzer::AnalyzerConfig;
 
 use crate::error::RayhunterError;
-use crate::notifications::NotificationType;
 
-/// The structure of a valid rayhunter configuration
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(default)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct Config {
-    /// Path to store QMDL files
     pub qmdl_store_path: String,
-    /// Listening port
     pub port: u16,
-    /// Debug mode
     pub debug_mode: bool,
-    /// Internal device name
     pub device: Device,
-    /// UI level
     pub ui_level: u8,
-    /// Colorblind mode
     pub colorblind_mode: bool,
-    /// Key input mode
     pub key_input_mode: u8,
-    /// ntfy.sh URL
     pub ntfy_url: Option<String>,
-    /// Vector containing the types of enabled notifications
-    pub enabled_notifications: Vec<NotificationType>,
-    /// Vector containing the list of enabled analyzers
     pub analyzers: AnalyzerConfig,
-    /// Minimum disk space required to start a recording
-    pub min_space_to_start_recording_mb: u64,
-    /// Minimum disk space required to continue a recording
-    pub min_space_to_continue_recording_mb: u64,
-    /// Wifi client SSID
-    pub wifi_ssid: Option<String>,
-    /// Wifi client password
-    pub wifi_password: Option<String>,
-    /// Wifi security type (wpa_psk or sae)
-    pub wifi_security: Option<wifi_station::SecurityType>,
-    /// Wifi client mode
-    pub wifi_enabled: bool,
-    /// Vector containing wifi client DNS servers
-    pub dns_servers: Option<Vec<String>>,
-    /// Wifi client firewall mode
-    pub firewall_restrict_outbound: bool,
-    /// Vector containing additional wifi client firewall ports to open
-    pub firewall_allowed_ports: Option<Vec<u16>>,
-    /// Optional WebDAV upload configuration. When unset, no upload worker runs.
-    pub webdav: Option<WebdavConfig>,
-}
-
-/// Configuration for uploading finished QMDL recordings to a WebDAV server.
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(default)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
-pub struct WebdavConfig {
-    /// WebDAV server base URL, e.g. "https://example.com/remote.php/files/untitaker/my-subfolder/"
-    pub url: String,
-    /// Optional username for HTTP Basic auth
-    pub username: Option<String>,
-    /// Optional password for HTTP Basic auth
-    pub password: Option<String>,
-    /// Timeout (in seconds) for each upload request
-    pub upload_timeout_secs: u64,
-    /// How often (in seconds) the worker scans for entries to upload
-    pub poll_interval_secs: u64,
-    /// Minimum age (in seconds) an entry must have before it becomes eligible for upload
-    pub min_age_secs: i64,
-    /// Delete the file locally after a successful upload
-    pub delete_on_upload: bool,
-}
-
-impl Default for WebdavConfig {
-    fn default() -> Self {
-        WebdavConfig {
-            url: String::new(),
-            username: None,
-            password: None,
-            upload_timeout_secs: 300,
-            poll_interval_secs: 3600,
-            min_age_secs: 86400,
-            delete_on_upload: false,
-        }
-    }
 }
 
 impl Default for Config {
@@ -101,87 +32,20 @@ impl Default for Config {
             key_input_mode: 0,
             analyzers: AnalyzerConfig::default(),
             ntfy_url: None,
-            enabled_notifications: vec![NotificationType::Warning, NotificationType::LowBattery],
-            min_space_to_start_recording_mb: 1,
-            min_space_to_continue_recording_mb: 1,
-            wifi_ssid: None,
-            wifi_password: None,
-            wifi_security: None,
-            wifi_enabled: false,
-            dns_servers: None,
-            firewall_restrict_outbound: true,
-            firewall_allowed_ports: None,
-            webdav: None,
         }
     }
 }
 
-impl Config {
-    pub fn wifi_config(&self) -> wifi_station::WifiConfig {
-        let (wpa_bin, hostapd_conf, ctrl_interface) = match self.device {
-            Device::Tmobile | Device::Wingtech => (
-                Some("/usr/sbin/wpa_supplicant".into()),
-                Some("/data/configs/hostapd.conf".into()),
-                None,
-            ),
-            Device::Uz801 => (
-                Some("/system/bin/wpa_supplicant".into()),
-                Some("/data/misc/wifi/hostapd.conf".into()),
-                Some("/data/misc/wifi/sockets".into()),
-            ),
-            _ => (None, None, None),
-        };
-        wifi_station::WifiConfig {
-            wifi_enabled: self.wifi_enabled,
-            dns_servers: self.dns_servers.clone(),
-            wifi_ssid: self.wifi_ssid.clone(),
-            wifi_password: self.wifi_password.clone(),
-            security_type: self.wifi_security,
-            wpa_supplicant_bin: wpa_bin.or_else(|| resolve_bin("wpa_supplicant")),
-            hostapd_conf,
-            ctrl_interface,
-            udhcpc_hook_path: Some("/data/rayhunter/udhcpc-hook.sh".into()),
-            dhcp_lease_path: Some("/data/rayhunter/dhcp_lease".into()),
-            wpa_conf_path: Some("/data/rayhunter/wpa_sta.conf".into()),
-            iw_bin: resolve_bin("iw"),
-            udhcpc_bin: resolve_bin("udhcpc"),
-            crash_log_dir: Some("/data/rayhunter/crash-logs".into()),
-            wakelock_name: Some("rayhunter".into()),
-        }
-    }
-}
-
-fn resolve_bin(name: &str) -> Option<String> {
-    let local = format!("/data/rayhunter/bin/{name}");
-    if std::path::Path::new(&local).exists() {
-        return Some(local);
-    }
-    None
-}
-
 pub async fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
 where
     P: AsRef<std::path::Path>,
 {
-    let mut config = if let Ok(config_file) = tokio::fs::read_to_string(&path).await {
-        toml::from_str(&config_file).map_err(RayhunterError::ConfigFileParsingError)?
+    if let Ok(config_file) = tokio::fs::read_to_string(&path).await {
+        Ok(toml::from_str(&config_file).map_err(RayhunterError::ConfigFileParsingError)?)
     } else {
         warn!("unable to read config file, using default config");
-        Config::default()
-    };
-
-    if let Some((ssid, security)) =
-        wifi_station::read_network_from_wpa_conf("/data/rayhunter/wpa_sta.conf")
-    {
-        config.wifi_ssid = Some(ssid);
-        config.wifi_security = Some(security);
-    } else {
-        config.wifi_ssid = None;
-        config.wifi_security = None;
+        Ok(Config::default())
     }
-    config.wifi_password = None;
-
-    Ok(config)
 }
 
 pub struct Args {

daemon/src/crypto_provider.rs

@@ -1,23 +0,0 @@
-use std::sync::Once;
-
-static INSTALL: Once = Once::new();
-
-/// Install the default rustls `CryptoProvider` for the current process.
-///
-/// This is idempotent so that it's easier to use in tests, but also panics loudly if the
-/// initialization fails.
-pub fn install_default() {
-    // Crypto providers fail if they get initialized multiple times, but we don't want to just
-    // ignore all errors, hence the use of once.
-    INSTALL.call_once(|| {
-        #[cfg(feature = "rustcrypto-tls")]
-        rustls_rustcrypto::provider()
-            .install_default()
-            .expect("failed to install rustcrypto crypto provider");
-
-        #[cfg(feature = "pq-tls")]
-        rustls_post_quantum::provider()
-            .install_default()
-            .expect("failed to install aws-lc-rs post-quantum crypto provider");
-    });
-}

daemon/src/diag.rs

@@ -10,7 +10,6 @@ use axum::http::header::CONTENT_TYPE;
 use axum::response::{IntoResponse, Response};
 use futures::{StreamExt, TryStreamExt, future};
 use log::{debug, error, info, warn};
-use rayhunter::Device;
 use tokio::fs::File;
 use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::sync::mpsc::{Receiver, Sender};
@@ -18,8 +17,6 @@ use tokio::sync::{RwLock, oneshot};
 use tokio_stream::wrappers::LinesStream;
 use tokio_util::task::TaskTracker;
 
-#[cfg(feature = "apidocs")]
-use rayhunter::analysis::analyzer::ReportMetadata;
 use rayhunter::analysis::analyzer::{AnalysisLineNormalizer, AnalyzerConfig, EventType};
 use rayhunter::diag::{DataType, MessagesContainer};
 use rayhunter::diag_device::DiagDevice;
@@ -27,18 +24,13 @@ use rayhunter::qmdl::QmdlWriter;
 
 use crate::analysis::{AnalysisCtrlMessage, AnalysisWriter};
 use crate::display;
-use crate::notifications::{Notification, NotificationType};
+use crate::notifications::Notification;
 use crate::qmdl_store::{RecordingStore, RecordingStoreError};
 use crate::server::ServerState;
-use crate::stats::DiskStats;
-
-const DISK_CHECK_BYTES_INTERVAL: usize = 256 * 1024;
 
 pub enum DiagDeviceCtrlMessage {
     StopRecording,
-    StartRecording {
-        response_tx: Option<oneshot::Sender<Result<(), String>>>,
-    },
+    StartRecording,
     DeleteEntry {
         name: String,
         response_tx: oneshot::Sender<Result<(), RecordingStoreError>>,
@@ -54,12 +46,8 @@ pub struct DiagTask {
     analysis_sender: Sender<AnalysisCtrlMessage>,
     analyzer_config: AnalyzerConfig,
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
-    min_space_to_start_mb: u64,
-    min_space_to_continue_mb: u64,
     state: DiagState,
     max_type_seen: EventType,
-    bytes_since_space_check: usize,
-    low_space_warned: bool,
 }
 
 enum DiagState {
@@ -70,99 +58,35 @@ enum DiagState {
     Stopped,
 }
 
-enum DiskSpaceCheck {
-    Ok(u64),
-    Warning(u64),
-    Critical(u64),
-    Failed,
-}
-
-fn check_disk_space(path: &std::path::Path, warning_mb: u64, critical_mb: u64) -> DiskSpaceCheck {
-    match DiskStats::new(path.to_str().unwrap()) {
-        Ok(stats) => {
-            let available_mb = stats.available_bytes.unwrap_or(0) / 1024 / 1024;
-            if available_mb < critical_mb {
-                DiskSpaceCheck::Critical(available_mb)
-            } else if available_mb < warning_mb {
-                DiskSpaceCheck::Warning(available_mb)
-            } else {
-                DiskSpaceCheck::Ok(available_mb)
-            }
-        }
-        Err(e) => {
-            warn!("Failed to check disk space: {e}");
-            DiskSpaceCheck::Failed
-        }
-    }
-}
-
 impl DiagTask {
     fn new(
         ui_update_sender: Sender<display::DisplayState>,
         analysis_sender: Sender<AnalysisCtrlMessage>,
         analyzer_config: AnalyzerConfig,
         notification_channel: tokio::sync::mpsc::Sender<Notification>,
-        min_space_to_start_mb: u64,
-        min_space_to_continue_mb: u64,
     ) -> Self {
         Self {
             ui_update_sender,
             analysis_sender,
             analyzer_config,
             notification_channel,
-            min_space_to_start_mb,
-            min_space_to_continue_mb,
             state: DiagState::Stopped,
             max_type_seen: EventType::Informational,
-            bytes_since_space_check: 0,
-            low_space_warned: false,
         }
     }
 
-    /// Start recording, returning an error if disk space is too low.
-    async fn start(&mut self, qmdl_store: &mut RecordingStore) -> Result<(), String> {
-        self.max_type_seen = EventType::Informational;
-        self.bytes_since_space_check = 0;
-        self.low_space_warned = false;
-
-        match check_disk_space(
-            &qmdl_store.path,
-            self.min_space_to_start_mb,
-            self.min_space_to_continue_mb,
-        ) {
-            DiskSpaceCheck::Critical(mb) | DiskSpaceCheck::Warning(mb) => {
-                let msg = format!(
-                    "Insufficient disk space: {}MB available, {}MB required",
-                    mb, self.min_space_to_start_mb
-                );
-                error!("{msg}");
-                return Err(msg);
-            }
-            DiskSpaceCheck::Ok(mb) => {
-                info!("Starting recording with {}MB disk space available", mb);
-            }
-            DiskSpaceCheck::Failed => {}
-        }
-
-        let (qmdl_file, analysis_file) = match qmdl_store.new_entry().await {
-            Ok(files) => files,
-            Err(e) => {
-                let msg = format!("failed creating QMDL file entry: {e}");
-                error!("{msg}");
-                return Err(msg);
-            }
-        };
+    /// Start recording
+    async fn start(&mut self, qmdl_store: &mut RecordingStore) {
+        let (qmdl_file, analysis_file) = qmdl_store
+            .new_entry()
+            .await
+            .expect("failed creating QMDL file entry");
         self.stop_current_recording().await;
         let qmdl_writer = QmdlWriter::new(qmdl_file);
-        let analysis_writer = match AnalysisWriter::new(analysis_file, &self.analyzer_config).await
-        {
-            Ok(writer) => Box::new(writer),
-            Err(e) => {
-                let msg = format!("failed to create analysis writer: {e}");
-                error!("{msg}");
-                return Err(msg);
-            }
-        };
+        let analysis_writer = AnalysisWriter::new(analysis_file, &self.analyzer_config)
+            .await
+            .map(Box::new)
+            .expect("failed to write to analysis file");
         self.state = DiagState::Recording {
             qmdl_writer,
             analysis_writer,
@@ -174,17 +98,11 @@ impl DiagTask {
         {
             warn!("couldn't send ui update message: {e}");
         }
-        Ok(())
     }
 
-    /// Stop recording, optionally annotating the entry with a reason.
-    async fn stop(&mut self, qmdl_store: &mut RecordingStore, reason: Option<String>) {
+    /// Stop recording
+    async fn stop(&mut self, qmdl_store: &mut RecordingStore) {
         self.stop_current_recording().await;
-        if let Some(reason) = reason
-            && let Err(e) = qmdl_store.set_current_stop_reason(reason).await
-        {
-            warn!("couldn't set stop reason: {e}");
-        }
         if let Some((_, entry)) = qmdl_store.get_current_entry()
             && let Err(e) = self
                 .analysis_sender
@@ -213,7 +131,7 @@ impl DiagTask {
         name: &str,
     ) -> Result<(), RecordingStoreError> {
         if qmdl_store.is_current_entry(name) {
-            self.stop(qmdl_store, None).await;
+            self.stop(qmdl_store).await;
         }
         let res = qmdl_store.delete_entry(name).await;
         if let Err(e) = res.as_ref() {
@@ -226,7 +144,7 @@ impl DiagTask {
         &mut self,
         qmdl_store: &mut RecordingStore,
     ) -> Result<(), RecordingStoreError> {
-        self.stop(qmdl_store, None).await;
+        self.stop(qmdl_store).await;
         let res = qmdl_store.delete_all_entries().await;
         if let Err(e) = res.as_ref() {
             error!("Error deleting QMDL entries {e}");
@@ -264,54 +182,10 @@ impl DiagTask {
             analysis_writer,
         } = &mut self.state
         {
-            if self.bytes_since_space_check >= DISK_CHECK_BYTES_INTERVAL {
-                self.bytes_since_space_check = 0;
-                match check_disk_space(
-                    &qmdl_store.path,
-                    self.min_space_to_start_mb,
-                    self.min_space_to_continue_mb,
-                ) {
-                    DiskSpaceCheck::Critical(mb) => {
-                        let reason = format!(
-                            "Disk space critically low ({}MB free), recording stopped automatically",
-                            mb
-                        );
-                        error!("{reason}");
-
-                        self.notification_channel
-                            .send(Notification::new(
-                                NotificationType::Warning,
-                                reason.clone(),
-                                None,
-                            ))
-                            .await
-                            .ok();
-
-                        self.stop(qmdl_store, Some(reason)).await;
-                        return;
-                    }
-                    DiskSpaceCheck::Warning(mb) if !self.low_space_warned => {
-                        self.low_space_warned = true;
-                        warn!("Disk space low: {}MB remaining", mb);
-                        self.notification_channel
-                            .send(Notification::new(
-                                NotificationType::Warning,
-                                format!("Disk space low: {}MB free", mb),
-                                Some(Duration::from_secs(30)),
-                            ))
-                            .await
-                            .ok();
-                    }
-                    _ => {}
-                }
-            }
-
-            if let Err(e) = qmdl_writer.write_container(&container).await {
-                let reason = format!("failed to write to QMDL (disk full?): {e}");
-                error!("{reason}");
-                self.stop(qmdl_store, Some(reason)).await;
-                return;
-            }
+            qmdl_writer
+                .write_container(&container)
+                .await
+                .expect("failed to write to QMDL writer");
             debug!(
                 "total QMDL bytes written: {}, updating manifest...",
                 qmdl_writer.total_written
@@ -319,31 +193,21 @@ impl DiagTask {
             let index = qmdl_store
                 .current_entry
                 .expect("DiagDevice had qmdl_writer, but QmdlStore didn't have current entry???");
-            if let Err(e) = qmdl_store
+            qmdl_store
                 .update_entry_qmdl_size(index, qmdl_writer.total_written)
                 .await
-            {
-                let reason = format!("failed to update manifest (disk full?): {e}");
-                error!("{reason}");
-                self.stop(qmdl_store, Some(reason)).await;
-                return;
-            }
+                .expect("failed to update qmdl file size");
             debug!("done!");
-            let container_bytes: usize = container.messages.iter().map(|m| m.data.len()).sum();
-            self.bytes_since_space_check += container_bytes;
-            let max_type = match analysis_writer.analyze(container).await {
-                Ok(t) => t,
-                Err(e) => {
-                    warn!("failed to analyze container: {e}");
-                    EventType::Informational
-                }
-            };
+            let max_type = analysis_writer
+                .analyze(container)
+                .await
+                .expect("failed to analyze container");
 
             if max_type > EventType::Informational {
                 info!("a heuristic triggered on this run!");
                 self.notification_channel
                     .send(Notification::new(
-                        NotificationType::Warning,
+                        "heuristic-warning".to_string(),
                         format!("Rayhunter has detected a {:?} severity event", max_type),
                         Some(Duration::from_secs(60 * 5)),
                     ))
@@ -371,7 +235,7 @@ impl DiagTask {
 #[allow(clippy::too_many_arguments)]
 pub fn run_diag_read_thread(
     task_tracker: &TaskTracker,
-    device: Device,
+    mut dev: DiagDevice,
     mut qmdl_file_rx: Receiver<DiagDeviceCtrlMessage>,
     qmdl_file_tx: Sender<DiagDeviceCtrlMessage>,
     ui_update_sender: Sender<display::DisplayState>,
@@ -379,43 +243,25 @@ pub fn run_diag_read_thread(
     analysis_sender: Sender<AnalysisCtrlMessage>,
     analyzer_config: AnalyzerConfig,
     notification_channel: tokio::sync::mpsc::Sender<Notification>,
-    min_space_to_start_mb: u64,
-    min_space_to_continue_mb: u64,
 ) {
     task_tracker.spawn(async move {
-        info!("Using configuration for device: {0:?}", device);
-        let mut dev = DiagDevice::new(&device)
-            .await?;
-        dev.config_logs()
-            .await?;
-
         let mut diag_stream = pin!(dev.as_stream().into_stream());
-        let mut diag_task = DiagTask::new(
-            ui_update_sender,
-            analysis_sender,
-            analyzer_config,
-            notification_channel,
-            min_space_to_start_mb,
-            min_space_to_continue_mb
-        );
+        let mut diag_task = DiagTask::new(ui_update_sender, analysis_sender, analyzer_config, notification_channel);
         qmdl_file_tx
-            .send(DiagDeviceCtrlMessage::StartRecording { response_tx: None })
+            .send(DiagDeviceCtrlMessage::StartRecording)
             .await
             .unwrap();
         loop {
             tokio::select! {
                 msg = qmdl_file_rx.recv() => {
                     match msg {
-                        Some(DiagDeviceCtrlMessage::StartRecording { response_tx }) => {
+                        Some(DiagDeviceCtrlMessage::StartRecording) => {
                             let mut qmdl_store = qmdl_store_lock.write().await;
-                            let result = diag_task.start(qmdl_store.deref_mut()).await;
-                            if let Some(tx) = response_tx {
-                                tx.send(result).ok();
-                            }
+                            diag_task.start(qmdl_store.deref_mut()).await;
                         },
                         Some(DiagDeviceCtrlMessage::StopRecording) => {
                             let mut qmdl_store = qmdl_store_lock.write().await;
-                            diag_task.stop(qmdl_store.deref_mut(), None).await;
+                            diag_task.stop(qmdl_store.deref_mut()).await;
                         },
                         // None means all the Senders have been dropped, so it's
                         // time to go
@@ -458,18 +304,6 @@ pub fn run_diag_read_thread(
 }
 
 /// Start recording API for web thread
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/start-recording",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::FORBIDDEN, description = "System is in debug mode"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Recording action unsuccessful")
-    ),
-    summary = "Start recording",
-    description = "Begin a new data capture."
-))]
 pub async fn start_recording(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
@@ -477,12 +311,9 @@ pub async fn start_recording(
         return Err((StatusCode::FORBIDDEN, "server is in debug mode".to_string()));
     }
 
-    let (response_tx, response_rx) = oneshot::channel();
     state
         .diag_device_ctrl_sender
-        .send(DiagDeviceCtrlMessage::StartRecording {
-            response_tx: Some(response_tx),
-        })
+        .send(DiagDeviceCtrlMessage::StartRecording)
         .await
         .map_err(|e| {
             (
@@ -491,29 +322,10 @@ pub async fn start_recording(
             )
         })?;
 
-    match response_rx.await {
-        Ok(Ok(())) => Ok((StatusCode::ACCEPTED, "ok".to_string())),
-        Ok(Err(reason)) => Err((StatusCode::INSUFFICIENT_STORAGE, reason)),
-        Err(e) => Err((
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("failed to receive start recording response: {e}"),
-        )),
-    }
+    Ok((StatusCode::ACCEPTED, "ok".to_string()))
 }
 
 /// Stop recording API for web thread
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/stop-recording",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::FORBIDDEN, description = "System is in debug mode"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Recording action unsuccessful")
-    ),
-    summary = "Stop recording",
-    description = "Stop current data capture."
-))]
 pub async fn stop_recording(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
@@ -533,22 +345,6 @@ pub async fn stop_recording(
     Ok((StatusCode::ACCEPTED, "ok".to_string()))
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/delete-recording/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::FORBIDDEN, description = "System is in debug mode"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Delete action unsuccessful"),
-        (status = StatusCode::BAD_REQUEST, description = "Bad recording name or no such recording")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL file to delete")
-    ),
-    summary = "Delete recording",
-    description = "Remove data capture file named {name}."
-))]
 pub async fn delete_recording(
     State(state): State<Arc<ServerState>>,
     Path(qmdl_name): Path<String>,
@@ -588,18 +384,6 @@ pub async fn delete_recording(
     }
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/delete-all-recordings",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::FORBIDDEN, description = "System is in debug mode"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Delete action unsuccessful")
-    ),
-    summary = "Delete all recordings",
-    description = "Remove all saved data capture files."
-))]
 pub async fn delete_all_recordings(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
@@ -631,21 +415,6 @@ pub async fn delete_all_recordings(
     }
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/analysis-report/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = ReportMetadata, content_type = "application/x-ndjson"),
-        (status = StatusCode::SERVICE_UNAVAILABLE, description = "No QMDL files available; start a new recording."),
-        (status = StatusCode::NOT_FOUND, description = "File {name} not found")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL file to analyze")
-    ),
-    summary = "Analysis report",
-    description = "Download processed analysis report for QMDL file {name}, as well as the types (and versions) of analyzers used."
-))]
 pub async fn get_analysis_report(
     State(state): State<Arc<ServerState>>,
     Path(qmdl_name): Path<String>,

daemon/src/display/generic_framebuffer.rs

@@ -9,7 +9,9 @@ use rayhunter::analysis::analyzer::EventType;
 
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
+use tokio::sync::oneshot;
+use tokio::sync::oneshot::error::TryRecvError;
+use tokio_util::task::TaskTracker;
 
 use include_dir::{Dir, include_dir};
 
@@ -102,7 +104,7 @@ pub trait GenericFramebuffer: Send + 'static {
             resized_img = img;
         }
         let img_rgba8 = resized_img.as_rgba8().unwrap();
-        let mut buf = Vec::with_capacity((height * width).try_into().unwrap());
+        let mut buf = Vec::new();
         for y in 0..height {
             for x in 0..width {
                 let px = img_rgba8.get_pixel(x, y);
@@ -145,7 +147,7 @@ pub trait GenericFramebuffer: Send + 'static {
 
     async fn draw_patterned_line(&mut self, color: Color, height: u32, pattern: LinePattern) {
         let width = self.dimensions().width;
-        let mut buffer = Vec::with_capacity((height * width).try_into().unwrap());
+        let mut buffer = Vec::new();
 
         for _row in 0..height {
             for col in 0..width {
@@ -171,14 +173,13 @@ pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
     mut fb: impl GenericFramebuffer,
-    shutdown_token: CancellationToken,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
     mut ui_update_rx: Receiver<DisplayState>,
 ) {
     static IMAGE_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/images/");
     let display_level = config.ui_level;
     if display_level == 0 {
         info!("Invisible mode, not spawning UI.");
-        return;
     }
 
     let colorblind_mode = config.colorblind_mode;
@@ -203,9 +204,13 @@ pub fn update_ui(
             );
         }
         loop {
-            if shutdown_token.is_cancelled() {
-                info!("received UI shutdown");
-                break;
+            match ui_shutdown_rx.try_recv() {
+                Ok(_) => {
+                    info!("received UI shutdown");
+                    break;
+                }
+                Err(TryRecvError::Empty) => {}
+                Err(e) => panic!("error receiving shutdown message: {e}"),
             }
             match ui_update_rx.try_recv() {
                 Ok(state) => {
@@ -215,13 +220,9 @@ pub fn update_ui(
                 Err(e) => error!("error receiving framebuffer update message: {e}"),
             }
 
-            let mut status_bar_height = 2;
             match display_level {
                 2 => fb.draw_gif(img.unwrap()).await,
                 3 => fb.draw_img(img.unwrap()).await,
-                4 => {
-                    status_bar_height = fb.dimensions().height;
-                }
                 128 => {
                     fb.draw_line(Color::Cyan, 128).await;
                     fb.draw_line(Color::Pink, 102).await;
@@ -229,13 +230,12 @@ pub fn update_ui(
                     fb.draw_line(Color::Pink, 50).await;
                     fb.draw_line(Color::Cyan, 25).await;
                 }
-                // this branch is for ui_level 1, which is also the default if an
+                // this branch id for ui_level 1, which is also the default if an
                 // unknown value is used
                 _ => {}
             };
             let (color, pattern) = display_style;
-            fb.draw_patterned_line(color, status_bar_height, pattern)
-                .await;
+            fb.draw_patterned_line(color, 2, pattern).await;
             tokio::time::sleep(Duration::from_millis(REFRESH_RATE)).await;
         }
     });

daemon/src/display/headless.rs

@@ -1,6 +1,6 @@
 use log::info;
 use tokio::sync::mpsc::Receiver;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use crate::config;
@@ -9,7 +9,7 @@ use crate::display::DisplayState;
 pub fn update_ui(
     _task_tracker: &TaskTracker,
     _config: &config::Config,
-    _shutdown_token: CancellationToken,
+    _ui_shutdown_rx: oneshot::Receiver<()>,
     _ui_update_rx: Receiver<DisplayState>,
 ) {
     info!("Headless mode, not spawning UI.");

daemon/src/display/mod.rs

@@ -12,9 +12,7 @@ pub mod tplink_onebit;
 pub mod uz801;
 pub mod wingtech;
 
-/// A list of available display states
 #[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub enum DisplayState {
     /// We're recording but no warning has been found yet.
     Recording,

daemon/src/display/orbic.rs

@@ -4,7 +4,7 @@ use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 use async_trait::async_trait;
 
 use tokio::sync::mpsc::Receiver;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 const FB_PATH: &str = "/dev/fb0";
@@ -23,7 +23,7 @@ impl GenericFramebuffer for Framebuffer {
     }
 
     async fn write_buffer(&mut self, buffer: Vec<(u8, u8, u8)>) {
-        let mut raw_buffer = Vec::with_capacity(buffer.len() * 2);
+        let mut raw_buffer = Vec::new();
         for (r, g, b) in buffer {
             let mut rgb565: u16 = (r as u16 & 0b11111000) << 8;
             rgb565 |= (g as u16 & 0b11111100) << 3;
@@ -38,14 +38,14 @@ impl GenericFramebuffer for Framebuffer {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    ui_shutdown_rx: oneshot::Receiver<()>,
     ui_update_rx: Receiver<DisplayState>,
 ) {
     generic_framebuffer::update_ui(
         task_tracker,
         config,
         Framebuffer,
-        shutdown_token,
+        ui_shutdown_rx,
         ui_update_rx,
     )
 }

daemon/src/display/tmobile.rs

@@ -4,7 +4,7 @@
 /// DisplayState::WarningDetected { .. } => Signal LED slowly blinks red.
 use log::{error, info};
 use tokio::sync::mpsc;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use std::time::Duration;
@@ -27,7 +27,7 @@ async fn stop_blinking(path: String) {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
     mut ui_update_rx: mpsc::Receiver<DisplayState>,
 ) {
     let mut invisible: bool = false;
@@ -40,9 +40,13 @@ pub fn update_ui(
         let mut last_state = DisplayState::Paused;
 
         loop {
-            if shutdown_token.is_cancelled() {
-                info!("received UI shutdown");
-                break;
+            match ui_shutdown_rx.try_recv() {
+                Ok(_) => {
+                    info!("received UI shutdown");
+                    break;
+                }
+                Err(oneshot::error::TryRecvError::Empty) => {}
+                Err(e) => panic!("error receiving shutdown message: {e}"),
             }
             match ui_update_rx.try_recv() {
                 Ok(new_state) => state = new_state,

daemon/src/display/tplink.rs

@@ -1,6 +1,6 @@
 use log::info;
 use tokio::sync::mpsc::Receiver;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use crate::config;
@@ -11,7 +11,7 @@ use std::fs;
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    ui_shutdown_rx: oneshot::Receiver<()>,
     ui_update_rx: Receiver<DisplayState>,
 ) {
     let display_level = config.ui_level;
@@ -23,9 +23,9 @@ pub fn update_ui(
     // The alternative would be to make the entire initialization async
     if fs::exists(tplink_onebit::OLED_PATH).unwrap_or_default() {
         info!("detected one-bit display");
-        tplink_onebit::update_ui(task_tracker, config, shutdown_token, ui_update_rx)
+        tplink_onebit::update_ui(task_tracker, config, ui_shutdown_rx, ui_update_rx)
     } else {
         info!("fallback to framebuffer");
-        tplink_framebuffer::update_ui(task_tracker, config, shutdown_token, ui_update_rx)
+        tplink_framebuffer::update_ui(task_tracker, config, ui_shutdown_rx, ui_update_rx)
     }
 }

daemon/src/display/tplink_framebuffer.rs

@@ -2,13 +2,13 @@ use async_trait::async_trait;
 use std::os::fd::AsRawFd;
 use tokio::fs::OpenOptions;
 use tokio::io::AsyncWriteExt;
-use tokio_util::sync::CancellationToken;
 
 use crate::config;
 use crate::display::DisplayState;
 use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 
 use tokio::sync::mpsc::Receiver;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 const FB_PATH: &str = "/dev/fb0";
@@ -50,7 +50,7 @@ impl GenericFramebuffer for Framebuffer {
             rop: 0,
         };
 
-        let mut raw_buffer = Vec::with_capacity(buffer.len() * 2);
+        let mut raw_buffer = Vec::new();
         for (r, g, b) in buffer {
             let mut rgb565: u16 = (r as u16 & 0b11111000) << 8;
             rgb565 |= (g as u16 & 0b11111100) << 3;
@@ -80,14 +80,14 @@ impl GenericFramebuffer for Framebuffer {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    ui_shutdown_rx: oneshot::Receiver<()>,
     ui_update_rx: Receiver<DisplayState>,
 ) {
     generic_framebuffer::update_ui(
         task_tracker,
         config,
         Framebuffer,
-        shutdown_token,
+        ui_shutdown_rx,
         ui_update_rx,
     )
 }

daemon/src/display/tplink_onebit.rs

@@ -6,7 +6,8 @@ use crate::display::DisplayState;
 
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
+use tokio::sync::oneshot::error::TryRecvError;
 use tokio_util::task::TaskTracker;
 
 use std::time::Duration;
@@ -111,7 +112,7 @@ const STATUS_WARNING: &[u8] = pixelart! {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
     mut ui_update_rx: Receiver<DisplayState>,
 ) {
     let display_level = config.ui_level;
@@ -123,9 +124,13 @@ pub fn update_ui(
         let mut pixels = STATUS_SMILING;
 
         loop {
-            if shutdown_token.is_cancelled() {
-                info!("received UI shutdown");
-                break;
+            match ui_shutdown_rx.try_recv() {
+                Ok(_) => {
+                    info!("received UI shutdown");
+                    break;
+                }
+                Err(TryRecvError::Empty) => {}
+                Err(e) => panic!("error receiving shutdown message: {e}"),
             }
 
             match ui_update_rx.try_recv() {

daemon/src/display/uz801.rs

@@ -4,7 +4,7 @@
 /// DisplayState::WarningDetected => Signal LED is solid red.
 use log::{error, info};
 use tokio::sync::mpsc;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use std::time::Duration;
@@ -27,7 +27,7 @@ async fn led_off(path: String) {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
     mut ui_update_rx: mpsc::Receiver<DisplayState>,
 ) {
     let mut invisible: bool = false;
@@ -41,9 +41,13 @@ pub fn update_ui(
         let mut last_update = std::time::Instant::now();
 
         loop {
-            if shutdown_token.is_cancelled() {
-                info!("received UI shutdown");
-                break;
+            match ui_shutdown_rx.try_recv() {
+                Ok(_) => {
+                    info!("received UI shutdown");
+                    break;
+                }
+                Err(oneshot::error::TryRecvError::Empty) => {}
+                Err(e) => panic!("error receiving shutdown message: {e}"),
             }
             match ui_update_rx.try_recv() {
                 Ok(new_state) => state = new_state,

daemon/src/display/wingtech.rs

@@ -10,7 +10,7 @@ use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 use async_trait::async_trait;
 
 use tokio::sync::mpsc::Receiver;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 const FB_PATH: &str = "/dev/fb0";
@@ -28,7 +28,7 @@ impl GenericFramebuffer for Framebuffer {
     }
 
     async fn write_buffer(&mut self, buffer: Vec<(u8, u8, u8)>) {
-        let mut raw_buffer = Vec::with_capacity(buffer.len() * 2);
+        let mut raw_buffer = Vec::new();
         for (r, g, b) in buffer {
             let mut rgb565: u16 = (r as u16 & 0b11111000) << 8;
             rgb565 |= (g as u16 & 0b11111100) << 3;
@@ -43,14 +43,14 @@ impl GenericFramebuffer for Framebuffer {
 pub fn update_ui(
     task_tracker: &TaskTracker,
     config: &config::Config,
-    shutdown_token: CancellationToken,
+    ui_shutdown_rx: oneshot::Receiver<()>,
     ui_update_rx: Receiver<DisplayState>,
 ) {
     generic_framebuffer::update_ui(
         task_tracker,
         config,
         Framebuffer,
-        shutdown_token,
+        ui_shutdown_rx,
         ui_update_rx,
     )
 }

daemon/src/error.rs

@@ -1,3 +1,4 @@
+use rayhunter::diag_device::DiagDeviceError;
 use thiserror::Error;
 
 use crate::qmdl_store::RecordingStoreError;
@@ -6,6 +7,8 @@ use crate::qmdl_store::RecordingStoreError;
 pub enum RayhunterError {
     #[error("Config file parsing error: {0}")]
     ConfigFileParsingError(#[from] toml::de::Error),
+    #[error("Diag intialization error: {0}")]
+    DiagInitError(DiagDeviceError),
     #[error("Tokio error: {0}")]
     TokioError(#[from] tokio::io::Error),
     #[error("QmdlStore error: {0}")]

daemon/src/firewall.rs

@@ -1,92 +0,0 @@
-use anyhow::{Result, bail};
-use log::{info, warn};
-use tokio::process::Command;
-
-use wifi_station::detect_bridge_iface;
-
-use crate::config::Config;
-
-async fn run_iptables(args: &[&str]) -> Result<()> {
-    let out = Command::new("iptables").args(args).output().await?;
-    if !out.status.success() {
-        bail!(
-            "iptables {} failed: {}",
-            args.join(" "),
-            String::from_utf8_lossy(&out.stderr)
-        );
-    }
-    Ok(())
-}
-
-pub async fn apply(config: &Config) {
-    let _ = Command::new("iptables")
-        .args(["-F", "OUTPUT"])
-        .output()
-        .await;
-
-    if config.firewall_restrict_outbound {
-        // Fail open on partial setup error: reachability beats restriction when recovery means physical access.
-        match setup_outbound_whitelist(&config.firewall_allowed_ports, &config.ntfy_url).await {
-            Ok(()) => info!("outbound firewall active: allowing DHCP, DNS, HTTPS only"),
-            Err(e) => warn!("firewall setup failed: {e} (fail-open, outbound unrestricted)"),
-        }
-    }
-}
-
-async fn setup_outbound_whitelist(
-    extra_ports: &Option<Vec<u16>>,
-    ntfy_url: &Option<String>,
-) -> Result<()> {
-    run_iptables(&["-A", "OUTPUT", "-o", "lo", "-j", "ACCEPT"]).await?;
-    run_iptables(&["-A", "OUTPUT", "-o", detect_bridge_iface(), "-j", "ACCEPT"]).await?;
-    run_iptables(&[
-        "-A",
-        "OUTPUT",
-        "-m",
-        "state",
-        "--state",
-        "ESTABLISHED,RELATED",
-        "-j",
-        "ACCEPT",
-    ])
-    .await?;
-    run_iptables(&[
-        "-A", "OUTPUT", "-p", "udp", "--dport", "67:68", "-j", "ACCEPT",
-    ])
-    .await?;
-    run_iptables(&["-A", "OUTPUT", "-p", "udp", "--dport", "53", "-j", "ACCEPT"]).await?;
-    run_iptables(&["-A", "OUTPUT", "-p", "tcp", "--dport", "53", "-j", "ACCEPT"]).await?;
-    run_iptables(&[
-        "-A", "OUTPUT", "-p", "tcp", "--dport", "443", "-j", "ACCEPT",
-    ])
-    .await?;
-
-    if let Some(url) = ntfy_url
-        && let Ok(parsed) = url::Url::parse(url)
-        && let Some(port) = parsed.port_or_known_default()
-        && port != 443
-    {
-        let port_str = port.to_string();
-        run_iptables(&[
-            "-A", "OUTPUT", "-p", "tcp", "--dport", &port_str, "-j", "ACCEPT",
-        ])
-        .await?;
-        info!("firewall: auto-allowed port {port} for ntfy");
-    }
-
-    if let Some(ports) = extra_ports {
-        for port in ports {
-            let port_str = port.to_string();
-            run_iptables(&[
-                "-A", "OUTPUT", "-p", "tcp", "--dport", &port_str, "-j", "ACCEPT",
-            ])
-            .await?;
-        }
-    }
-
-    run_iptables(&["-A", "OUTPUT", "-j", "DROP"]).await?;
-
-    let _ = tokio::fs::write("/proc/sys/net/bridge/bridge-nf-call-iptables", "0").await;
-
-    Ok(())
-}

daemon/src/key_input.rs

@@ -3,7 +3,7 @@ use std::time::{Duration, Instant};
 use tokio::fs::File;
 use tokio::io::AsyncReadExt;
 use tokio::sync::mpsc::Sender;
-use tokio_util::sync::CancellationToken;
+use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use crate::config;
@@ -21,7 +21,7 @@ pub fn run_key_input_thread(
     task_tracker: &TaskTracker,
     config: &config::Config,
     diag_tx: Sender<DiagDeviceCtrlMessage>,
-    cancellation_token: CancellationToken,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
 ) {
     if config.key_input_mode == 0 {
         return;
@@ -43,7 +43,7 @@ pub fn run_key_input_thread(
 
         loop {
             tokio::select! {
-               _ = cancellation_token.cancelled() => {
+                _ = &mut ui_shutdown_rx => {
                     info!("received key input shutdown");
                     return;
                 }
@@ -81,9 +81,8 @@ pub fn run_key_input_thread(
                             {
                                 error!("Failed to send StopRecording: {e}");
                             }
-                            if let Err(e) = diag_tx
-                                .send(DiagDeviceCtrlMessage::StartRecording { response_tx: None })
-                                .await
+                            if let Err(e) =
+                                diag_tx.send(DiagDeviceCtrlMessage::StartRecording).await
                             {
                                 error!("Failed to send StartRecording: {e}");
                             }

daemon/src/lib.rs

@@ -1,74 +0,0 @@
-pub mod analysis;
-pub mod battery;
-pub mod config;
-pub mod crypto_provider;
-pub mod diag;
-pub mod display;
-pub mod error;
-pub mod firewall;
-pub mod key_input;
-pub mod notifications;
-pub mod pcap;
-pub mod qmdl_store;
-pub mod server;
-pub mod stats;
-pub mod webdav;
-
-#[cfg(feature = "apidocs")]
-use utoipa::OpenApi;
-
-// Add anotated paths to api docs
-#[cfg(feature = "apidocs")]
-#[derive(OpenApi)]
-#[openapi(
-    info(
-        description = "OpenAPI documentation for Rayhunter daemon\n\n**Note:** API endpoints are subject to change as needs arise, though we will try to keep them as stable as possible and notify about breaking changes in the changelogs for new versions.\n\nNo endpoints require any authentication. To use the in-browser execution on this page, you may need to disable CORS temporarily for your browser.",
-        license(
-            name = "GNU General Public License v3.0",
-            url = "https://github.com/EFForg/rayhunter/blob/main/LICENSE"
-        )
-    ),
-    paths(
-        pcap::get_pcap,
-        server::get_qmdl,
-        server::get_zip,
-        stats::get_system_stats,
-        stats::get_qmdl_manifest,
-        stats::get_log,
-        diag::start_recording,
-        diag::stop_recording,
-        diag::delete_recording,
-        diag::delete_all_recordings,
-        diag::get_analysis_report,
-        analysis::get_analysis_status,
-        analysis::start_analysis,
-        server::get_config,
-        server::set_config,
-        server::test_notification,
-        server::get_time,
-        server::set_time_offset,
-        server::debug_set_display_state
-    ),
-    servers(
-        (
-            url = "http://localhost:8080",
-            description = "ADB port bridge"
-        ),
-        (
-            url = "http://192.168.1.1:8080",
-            description = "Orbic WiFi GUI"
-        ),
-        (
-            url = "http://192.168.0.1:8080",
-            description = "TPLink WiFi GUI"
-        ),
-    )
-)]
-pub struct ApiDocs;
-
-#[cfg(feature = "apidocs")]
-impl ApiDocs {
-    pub fn generate() -> String {
-        ApiDocs::openapi().to_pretty_json().unwrap()
-    }
-}

daemon/src/main.rs

@@ -1,23 +1,20 @@
 mod analysis;
 mod battery;
 mod config;
-mod crypto_provider;
 mod diag;
 mod display;
 mod error;
-mod firewall;
 mod key_input;
 mod notifications;
 mod pcap;
 mod qmdl_store;
 mod server;
 mod stats;
-mod webdav;
 
 use std::net::SocketAddr;
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
-use crate::battery::run_battery_notification_worker;
 use crate::config::{parse_args, parse_config};
 use crate::diag::run_diag_read_thread;
 use crate::error::RayhunterError;
@@ -25,12 +22,9 @@ use crate::notifications::{NotificationService, run_notification_worker};
 use crate::pcap::get_pcap;
 use crate::qmdl_store::RecordingStore;
 use crate::server::{
-    ServerState, debug_set_display_state, get_config, get_qmdl, get_time, get_wifi_status, get_zip,
-    scan_wifi, serve_static, set_config, set_time_offset, test_notification,
+    ServerState, debug_set_display_state, get_config, get_qmdl, get_zip, serve_static, set_config,
 };
 use crate::stats::{get_qmdl_manifest, get_system_stats};
-use crate::webdav::run_webdav_upload_worker;
-use wifi_station::WifiStatus;
 
 use analysis::{
     AnalysisCtrlMessage, AnalysisStatus, get_analysis_status, run_analysis_thread, start_analysis,
@@ -45,13 +39,13 @@ use diag::{
 use log::{error, info};
 use qmdl_store::RecordingStoreError;
 use rayhunter::Device;
+use rayhunter::diag_device::DiagDevice;
 use stats::get_log;
 use tokio::net::TcpListener;
 use tokio::select;
-use tokio::sync::RwLock;
 use tokio::sync::mpsc::{self, Sender};
+use tokio::sync::{RwLock, oneshot};
 use tokio::task::JoinHandle;
-use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 
 type AppRouter = Router<Arc<ServerState>>;
@@ -73,11 +67,6 @@ fn get_router() -> AppRouter {
         .route("/api/analysis/{name}", post(start_analysis))
         .route("/api/config", get(get_config))
         .route("/api/config", post(set_config))
-        .route("/api/test-notification", post(test_notification))
-        .route("/api/wifi-status", get(get_wifi_status))
-        .route("/api/wifi-scan", post(scan_wifi))
-        .route("/api/time", get(get_time))
-        .route("/api/time-offset", post(set_time_offset))
         .route("/api/debug/display-state", post(debug_set_display_state))
         .route("/", get(|| async { Redirect::permanent("/index.html") }))
         .route("/{*path}", get(serve_static))
@@ -89,7 +78,7 @@ fn get_router() -> AppRouter {
 async fn run_server(
     task_tracker: &TaskTracker,
     state: Arc<ServerState>,
-    shutdown_token: CancellationToken,
+    server_shutdown_rx: oneshot::Receiver<()>,
 ) -> JoinHandle<()> {
     info!("spinning up server");
     let addr = SocketAddr::from(([0, 0, 0, 0], state.config.port));
@@ -99,12 +88,17 @@ async fn run_server(
     task_tracker.spawn(async move {
         info!("The orca is hunting for stingrays...");
         axum::serve(listener, app)
-            .with_graceful_shutdown(shutdown_token.cancelled_owned())
+            .with_graceful_shutdown(server_shutdown_signal(server_shutdown_rx))
             .await
             .unwrap();
     })
 }
 
+async fn server_shutdown_signal(server_shutdown_rx: oneshot::Receiver<()>) {
+    server_shutdown_rx.await.unwrap();
+    info!("Server received shutdown signal, exiting...");
+}
+
 // Loads a RecordingStore if one exists, and if not, only create one if we're
 // not in debug mode. If we fail to parse the manifest AND we're not in debug
 // mode, try to recover the manifest from the existing QMDL files
@@ -136,10 +130,15 @@ async fn init_qmdl_store(config: &config::Config) -> Result<RecordingStore, Rayh
 // Start a thread that'll track when user hits ctrl+c. When that happens,
 // trigger various cleanup tasks, including sending signals to other threads to
 // shutdown
+#[allow(clippy::too_many_arguments)]
 fn run_shutdown_thread(
     task_tracker: &TaskTracker,
     diag_device_sender: Sender<DiagDeviceCtrlMessage>,
-    shutdown_token: CancellationToken,
+    daemon_restart_rx: oneshot::Receiver<()>,
+    should_restart_flag: Arc<AtomicBool>,
+    server_shutdown_tx: oneshot::Sender<()>,
+    maybe_ui_shutdown_tx: Option<oneshot::Sender<()>>,
+    maybe_key_input_shutdown_tx: Option<oneshot::Sender<()>>,
     qmdl_store_lock: Arc<RwLock<RecordingStore>>,
     analysis_tx: Sender<AnalysisCtrlMessage>,
 ) -> JoinHandle<Result<(), RayhunterError>> {
@@ -151,9 +150,17 @@ fn run_shutdown_thread(
                 if let Err(err) = res {
                     error!("Unable to listen for shutdown signal: {err}");
                 }
+
+                should_restart_flag.store(false, Ordering::Relaxed);
             }
-            _ = shutdown_token.cancelled() => {}
-        }
+            res = daemon_restart_rx => {
+                if let Err(err) = res {
+                    error!("Unable to listen for shutdown signal: {err}");
+                }
+
+                should_restart_flag.store(true, Ordering::Relaxed);
+            }
+        };
 
         let mut qmdl_store = qmdl_store_lock.write().await;
         if qmdl_store.current_entry.is_some() {
@@ -162,7 +169,15 @@ fn run_shutdown_thread(
             info!("Done!");
         }
 
-        shutdown_token.cancel();
+        server_shutdown_tx
+            .send(())
+            .expect("couldn't send server shutdown signal");
+        if let Some(ui_shutdown_tx) = maybe_ui_shutdown_tx {
+            let _ = ui_shutdown_tx.send(());
+        }
+        if let Some(key_input_shutdown_tx) = maybe_key_input_shutdown_tx {
+            let _ = key_input_shutdown_tx.send(());
+        }
         diag_device_sender
             .send(DiagDeviceCtrlMessage::Exit)
             .await
@@ -177,9 +192,11 @@ fn run_shutdown_thread(
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<(), RayhunterError> {
-    rayhunter::init_logging(log::LevelFilter::Info);
+    env_logger::init();
 
-    crate::crypto_provider::install_default();
+    rustls_rustcrypto::provider()
+        .install_default()
+        .expect("Couldn't install rustcrypto provider");
 
     let args = parse_args();
 
@@ -206,20 +223,26 @@ async fn run_with_config(
     let (diag_tx, diag_rx) = mpsc::channel::<DiagDeviceCtrlMessage>(1);
     let (ui_update_tx, ui_update_rx) = mpsc::channel::<display::DisplayState>(1);
     let (analysis_tx, analysis_rx) = mpsc::channel::<AnalysisCtrlMessage>(5);
-    let restart_token = CancellationToken::new();
-    let shutdown_token = restart_token.child_token();
-    // Ensure shutdown_token is cancelled when this function exits for any
-    // reason (e.g. diag device init failure), so all spawned tasks get
-    // signaled to stop.
-    let _shutdown_guard = shutdown_token.clone().drop_guard();
+    let mut maybe_ui_shutdown_tx = None;
+    let mut maybe_key_input_shutdown_tx = None;
 
     let notification_service = NotificationService::new(config.ntfy_url.clone());
 
     if !config.debug_mode {
+        let (ui_shutdown_tx, ui_shutdown_rx) = oneshot::channel();
+        maybe_ui_shutdown_tx = Some(ui_shutdown_tx);
+        info!("Using configuration for device: {0:?}", config.device);
+        let mut dev = DiagDevice::new(&config.device)
+            .await
+            .map_err(RayhunterError::DiagInitError)?;
+        dev.config_logs()
+            .await
+            .map_err(RayhunterError::DiagInitError)?;
+
         info!("Starting Diag Thread");
         run_diag_read_thread(
             &task_tracker,
-            config.device.clone(),
+            dev,
             diag_rx,
             diag_tx.clone(),
             ui_update_tx.clone(),
@@ -227,30 +250,32 @@ async fn run_with_config(
             analysis_tx.clone(),
             config.analyzers.clone(),
             notification_service.new_handler(),
-            config.min_space_to_start_recording_mb,
-            config.min_space_to_continue_recording_mb,
         );
         info!("Starting UI");
 
         let update_ui = match &config.device {
-            Device::Orbic | Device::Moxee => display::orbic::update_ui,
+            Device::Orbic => display::orbic::update_ui,
             Device::Tplink => display::tplink::update_ui,
             Device::Tmobile => display::tmobile::update_ui,
             Device::Wingtech => display::wingtech::update_ui,
             Device::Pinephone => display::headless::update_ui,
             Device::Uz801 => display::uz801::update_ui,
         };
-        update_ui(&task_tracker, &config, shutdown_token.clone(), ui_update_rx);
+        update_ui(&task_tracker, &config, ui_shutdown_rx, ui_update_rx);
 
         info!("Starting Key Input service");
+        let (key_input_shutdown_tx, key_input_shutdown_rx) = oneshot::channel();
+        maybe_key_input_shutdown_tx = Some(key_input_shutdown_tx);
         key_input::run_key_input_thread(
             &task_tracker,
             &config,
             diag_tx.clone(),
-            shutdown_token.clone(),
+            key_input_shutdown_rx,
         );
     }
 
+    let (daemon_restart_tx, daemon_restart_rx) = oneshot::channel::<()>();
+    let (server_shutdown_tx, server_shutdown_rx) = oneshot::channel::<()>();
     let analysis_status_lock = Arc::new(RwLock::new(analysis_status));
     run_analysis_thread(
         &task_tracker,
@@ -259,46 +284,20 @@ async fn run_with_config(
         analysis_status_lock.clone(),
         config.analyzers.clone(),
     );
+    let should_restart_flag = Arc::new(AtomicBool::new(false));
 
     run_shutdown_thread(
         &task_tracker,
         diag_tx.clone(),
-        shutdown_token.clone(),
+        daemon_restart_rx,
+        should_restart_flag.clone(),
+        server_shutdown_tx,
+        maybe_ui_shutdown_tx,
+        maybe_key_input_shutdown_tx,
         qmdl_store_lock.clone(),
         analysis_tx.clone(),
     );
-
-    run_battery_notification_worker(
-        &task_tracker,
-        config.device.clone(),
-        notification_service.new_handler(),
-        shutdown_token.clone(),
-    );
-
-    run_notification_worker(
-        &task_tracker,
-        notification_service,
-        config.enabled_notifications.clone(),
-    );
-
-    let wifi_status = Arc::new(RwLock::new(WifiStatus::default()));
-    wifi_station::run_wifi_client(
-        &task_tracker,
-        &config.wifi_config(),
-        shutdown_token.clone(),
-        wifi_status.clone(),
-    );
-    firewall::apply(&config).await;
-
-    if let Some(webdav_config) = config.webdav.clone() {
-        run_webdav_upload_worker(
-            &task_tracker,
-            shutdown_token.clone(),
-            qmdl_store_lock.clone(),
-            webdav_config.into(),
-        );
-    }
-
+    run_notification_worker(&task_tracker, notification_service);
     let state = Arc::new(ServerState {
         config_path: args.config_path.clone(),
         config,
@@ -306,18 +305,16 @@ async fn run_with_config(
         diag_device_ctrl_sender: diag_tx,
         analysis_status_lock,
         analysis_sender: analysis_tx,
-        daemon_restart_token: restart_token.clone(),
+        daemon_restart_tx: Arc::new(RwLock::new(Some(daemon_restart_tx))),
         ui_update_sender: Some(ui_update_tx),
-        wifi_status,
-        wifi_scan_lock: tokio::sync::Mutex::new(()),
     });
-    run_server(&task_tracker, state, shutdown_token.clone()).await;
+    run_server(&task_tracker, state, server_shutdown_rx).await;
 
     task_tracker.close();
     task_tracker.wait().await;
 
     info!("see you space cowboy...");
-    Ok(restart_token.is_cancelled())
+    Ok(should_restart_flag.load(Ordering::Relaxed))
 }
 
 #[cfg(test)]

daemon/src/notifications.rs

@@ -5,43 +5,19 @@ use std::{
 };
 
 use log::error;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
 use tokio::sync::mpsc::{self, error::TryRecvError};
 use tokio_util::task::TaskTracker;
 
-pub const DEFAULT_NOTIFICATION_TIMEOUT: u64 = 10; //seconds
-
-#[derive(Error, Debug)]
-pub enum NotificationError {
-    #[error("HTTP request failed: {0}")]
-    RequestFailed(#[from] reqwest::Error),
-    #[error("Server returned error status: {0}")]
-    HttpError(reqwest::StatusCode),
-}
-
-/// Enum of valid notification types
-#[derive(Hash, Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
-pub enum NotificationType {
-    Warning,
-    LowBattery,
-}
-
 pub struct Notification {
-    notification_type: NotificationType,
+    message_type: String,
     message: String,
     debounce: Option<Duration>,
 }
 
 impl Notification {
-    pub fn new(
-        notification_type: NotificationType,
-        message: String,
-        debounce: Option<Duration>,
-    ) -> Self {
+    pub fn new(message_type: String, message: String, debounce: Option<Duration>) -> Self {
         Notification {
-            notification_type,
+            message_type,
             message,
             debounce,
         }
@@ -58,7 +34,6 @@ struct NotificationStatus {
 
 pub struct NotificationService {
     url: Option<String>,
-    timeout: u64,
     tx: mpsc::Sender<Notification>,
     rx: mpsc::Receiver<Notification>,
 }
@@ -66,12 +41,7 @@ pub struct NotificationService {
 impl NotificationService {
     pub fn new(url: Option<String>) -> Self {
         let (tx, rx) = mpsc::channel(10);
-        Self {
-            url,
-            timeout: DEFAULT_NOTIFICATION_TIMEOUT,
-            tx,
-            rx,
-        }
+        Self { url, tx, rx }
     }
 
     pub fn new_handler(&self) -> mpsc::Sender<Notification> {
@@ -79,31 +49,9 @@ impl NotificationService {
     }
 }
 
-/// Sends a notification message to the specified URL.
-pub async fn send_notification(
-    http_client: &reqwest::Client,
-    url: &str,
-    message: String,
-    timeout: u64,
-) -> Result<(), NotificationError> {
-    let response = http_client
-        .post(url)
-        .body(message)
-        .timeout(Duration::from_secs(timeout))
-        .send()
-        .await?;
-
-    if response.status().is_success() {
-        Ok(())
-    } else {
-        Err(NotificationError::HttpError(response.status()))
-    }
-}
-
 pub fn run_notification_worker(
     task_tracker: &TaskTracker,
     mut notification_service: NotificationService,
-    enabled_notifications: Vec<NotificationType>,
 ) {
     task_tracker.spawn(async move {
         if let Some(url) = notification_service.url
@@ -117,12 +65,8 @@ pub fn run_notification_worker(
                 loop {
                     match notification_service.rx.try_recv() {
                         Ok(notification) => {
-                            if !enabled_notifications.contains(&notification.notification_type) {
-                                continue;
-                            }
-
                             let status = notification_statuses
-                                .entry(notification.notification_type)
+                                .entry(notification.message_type)
                                 .or_insert_with(|| NotificationStatus {
                                     message: "".to_string(),
                                     needs_sending: true,
@@ -165,21 +109,24 @@ pub fn run_notification_worker(
                         }
                     }
 
-                    match send_notification(
-                        &http_client,
-                        &url,
-                        notification.message.clone(),
-                        notification_service.timeout,
-                    )
-                    .await
+                    match http_client
+                        .post(&url)
+                        .body(notification.message.clone())
+                        .send()
+                        .await
                     {
-                        Ok(()) => {
-                            notification.last_sent = Some(Instant::now());
-                            notification.failed_since_last_success = 0;
-                            notification.needs_sending = false;
+                        Ok(response) => {
+                            if response.status().is_success() {
+                                notification.last_sent = Some(Instant::now());
+                                notification.failed_since_last_success = 0;
+                                notification.needs_sending = false;
+                            } else {
+                                notification.failed_since_last_success += 1;
+                                notification.last_attempt = Some(Instant::now());
+                            }
                         }
                         Err(e) => {
-                            error!("Failed to send notification: {e}");
+                            error!("Failed to send notification to ntfy: {e}");
                             notification.failed_since_last_success += 1;
                             notification.last_attempt = Some(Instant::now());
                         }
@@ -199,243 +146,3 @@ pub fn run_notification_worker(
         }
     });
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use axum::{Router, body::Bytes, extract::State, routing::post};
-    use std::sync::Arc;
-    use tokio::net::TcpListener;
-    use tokio::sync::Mutex;
-
-    #[derive(Clone)]
-    struct TestServerState {
-        received_messages: Arc<Mutex<Vec<String>>>,
-    }
-
-    async fn capture_notification(
-        State(state): State<TestServerState>,
-        body: Bytes,
-    ) -> &'static str {
-        let message = String::from_utf8_lossy(&body).to_string();
-        state.received_messages.lock().await.push(message);
-        "OK"
-    }
-
-    async fn setup_test_server() -> (Arc<Mutex<Vec<String>>>, String) {
-        crate::crypto_provider::install_default();
-
-        let received_messages = Arc::new(Mutex::new(Vec::new()));
-        let test_state = TestServerState {
-            received_messages: received_messages.clone(),
-        };
-
-        let app = Router::new()
-            .route("/", post(capture_notification))
-            .with_state(test_state);
-
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-        let url = format!("http://{}", addr);
-
-        tokio::spawn(async move {
-            axum::serve(listener, app).await.unwrap();
-        });
-
-        tokio::time::sleep(Duration::from_millis(100)).await;
-
-        (received_messages, url)
-    }
-
-    async fn setup_timeout_server(timeout: u64) -> String {
-        crate::crypto_provider::install_default();
-
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-        let url = format!("http://{}", addr);
-
-        tokio::spawn(async move {
-            // Accept the connection but don't respond in the timeout
-            let (_socket, _addr) = listener.accept().await.unwrap();
-            tokio::time::sleep(Duration::from_secs(timeout * 2)).await;
-        });
-
-        tokio::time::sleep(Duration::from_millis(100)).await;
-
-        url
-    }
-
-    async fn cleanup_worker(sender: mpsc::Sender<Notification>, tracker: TaskTracker) {
-        drop(sender);
-        tracker.close();
-        tracker.wait().await;
-    }
-
-    #[tokio::test]
-    async fn test_send_notification_times_out() {
-        let timeout: u64 = 2;
-        let url = setup_timeout_server(timeout).await;
-
-        let http_client = reqwest::Client::new();
-        let result = send_notification(
-            &http_client,
-            &url,
-            "test warning message".to_string(),
-            timeout,
-        )
-        .await;
-
-        match result {
-            Err(NotificationError::RequestFailed(reqwest_error)) => {
-                println!("error = {:?}", reqwest_error);
-                assert!(reqwest_error.is_timeout());
-            }
-            _ => assert!(false),
-        }
-    }
-
-    #[tokio::test]
-    async fn test_notification_worker_sends_message() {
-        let (received_messages, url) = setup_test_server().await;
-
-        let task_tracker = TaskTracker::new();
-        let notification_service = NotificationService::new(Some(url));
-        let notification_sender = notification_service.new_handler();
-
-        run_notification_worker(
-            &task_tracker,
-            notification_service,
-            vec![NotificationType::Warning],
-        );
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::Warning,
-                "test warning message".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        tokio::time::sleep(Duration::from_secs(3)).await;
-
-        let messages = received_messages.lock().await;
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0], "test warning message");
-        drop(messages);
-
-        cleanup_worker(notification_sender, task_tracker).await;
-    }
-
-    #[tokio::test]
-    async fn test_notification_worker_filters_disabled_types() {
-        let (received_messages, url) = setup_test_server().await;
-
-        let task_tracker = TaskTracker::new();
-        let notification_service = NotificationService::new(Some(url));
-        let notification_sender = notification_service.new_handler();
-
-        run_notification_worker(
-            &task_tracker,
-            notification_service,
-            vec![NotificationType::Warning],
-        );
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::Warning,
-                "test warning".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::LowBattery,
-                "test low battery".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        tokio::time::sleep(Duration::from_secs(3)).await;
-
-        let messages = received_messages.lock().await;
-        assert_eq!(messages.len(), 1);
-        assert_eq!(messages[0], "test warning");
-        drop(messages);
-
-        cleanup_worker(notification_sender, task_tracker).await;
-    }
-
-    #[tokio::test]
-    async fn test_notification_worker_sends_enabled_types() {
-        let (received_messages, url) = setup_test_server().await;
-
-        let task_tracker = TaskTracker::new();
-        let notification_service = NotificationService::new(Some(url));
-        let notification_sender = notification_service.new_handler();
-
-        run_notification_worker(
-            &task_tracker,
-            notification_service,
-            vec![NotificationType::Warning, NotificationType::LowBattery],
-        );
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::Warning,
-                "test warning".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::LowBattery,
-                "test low battery".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        tokio::time::sleep(Duration::from_secs(3)).await;
-
-        let messages = received_messages.lock().await;
-        assert_eq!(messages.len(), 2);
-        // these are interchangeable, ordering not guaranteed
-        assert!(messages.contains(&"test warning".to_string()));
-        assert!(messages.contains(&"test low battery".to_string()));
-        drop(messages);
-
-        cleanup_worker(notification_sender, task_tracker).await;
-    }
-
-    #[tokio::test]
-    async fn test_notification_worker_with_no_url() {
-        let task_tracker = TaskTracker::new();
-        let notification_service = NotificationService::new(None);
-        let notification_sender = notification_service.new_handler();
-
-        run_notification_worker(
-            &task_tracker,
-            notification_service,
-            vec![NotificationType::Warning],
-        );
-
-        notification_sender
-            .send(Notification::new(
-                NotificationType::Warning,
-                "test warning".to_string(),
-                None,
-            ))
-            .await
-            .unwrap();
-
-        tokio::time::sleep(Duration::from_millis(500)).await;
-
-        cleanup_worker(notification_sender, task_tracker).await;
-    }
-}

daemon/src/pcap.rs

@@ -1,4 +1,4 @@
-use crate::server::ServerState;
+use crate::ServerState;
 
 use anyhow::Error;
 use axum::body::Body;
@@ -18,21 +18,6 @@ use tokio_util::io::ReaderStream;
 // Streams a pcap file chunk-by-chunk to the client by reading the QMDL data
 // written so far. This is done by spawning a thread which streams chunks of
 // pcap data to a channel that's piped to the client.
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/pcap/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::OK, description = "PCAP conversion successful", content_type = "application/vnd.tcpdump.pcap"),
-        (status = StatusCode::NOT_FOUND, description = "Could not find file {name}"),
-        (status = StatusCode::SERVICE_UNAVAILABLE, description = "QMDL file is empty")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL filename to convert and download")
-    ),
-    summary = "Download a PCAP file",
-    description = "Stream a PCAP file to a client in chunks by converting the QMDL data for file {name} written so far."
-))]
 pub async fn get_pcap(
     State(state): State<Arc<ServerState>>,
     Path(mut qmdl_name): Path<String>,

daemon/src/qmdl_store.rs

@@ -2,7 +2,7 @@ use std::io::{self, ErrorKind};
 use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
-use chrono::{DateTime, Local, TimeDelta};
+use chrono::{DateTime, Local};
 use log::{info, warn};
 use rayhunter::util::RuntimeMetadata;
 use serde::{Deserialize, Serialize};
@@ -45,36 +45,20 @@ pub struct Manifest {
     pub entries: Vec<ManifestEntry>,
 }
 
-/// The structure of an entry in the QMDL manifest table
 #[derive(Deserialize, Serialize, Clone, PartialEq, Debug)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct ManifestEntry {
-    /// The name of the entry
     pub name: String,
-    /// The system time when recording began
-    #[cfg_attr(feature = "apidocs", schema(value_type = String))]
     pub start_time: DateTime<Local>,
-    /// The system time when the last message was recorded to the file
-    #[cfg_attr(feature = "apidocs", schema(value_type = String))]
     pub last_message_time: Option<DateTime<Local>>,
-    /// The size of the QMDL file in bytes
     pub qmdl_size_bytes: usize,
-    /// The rayhunter daemon version which generated the file
     pub rayhunter_version: Option<String>,
-    /// The OS which created the file
     pub system_os: Option<String>,
-    /// The architecture on which the OS was running
     pub arch: Option<String>,
-    #[serde(default)]
-    pub stop_reason: Option<String>,
-    /// When the manifest was uploaded to a WebDAV server
-    #[cfg_attr(feature = "apidocs", schema(value_type = String))]
-    pub upload_time: Option<DateTime<Local>>,
 }
 
 impl ManifestEntry {
     fn new() -> Self {
-        let now = rayhunter::clock::get_adjusted_now();
+        let now = Local::now();
         let metadata = RuntimeMetadata::new();
         ManifestEntry {
             name: format!("{}", now.timestamp()),
@@ -84,8 +68,6 @@ impl ManifestEntry {
             rayhunter_version: Some(metadata.rayhunter_version),
             system_os: Some(metadata.system_os),
             arch: Some(metadata.arch),
-            stop_reason: None,
-            upload_time: None,
         }
     }
 
@@ -215,13 +197,11 @@ impl RecordingStore {
                 rayhunter_version: None,
                 system_os: None,
                 arch: None,
-                stop_reason: None,
-                upload_time: None,
             });
         }
 
         // sort chronologically
-        manifest_entries.sort_by_key(|a| a.start_time);
+        manifest_entries.sort_by(|a, b| a.start_time.cmp(&b.start_time));
 
         let mut store = RecordingStore {
             path: path.as_ref().to_path_buf(),
@@ -320,8 +300,7 @@ impl RecordingStore {
         size_bytes: usize,
     ) -> Result<(), RecordingStoreError> {
         self.manifest.entries[entry_index].qmdl_size_bytes = size_bytes;
-        self.manifest.entries[entry_index].last_message_time =
-            Some(rayhunter::clock::get_adjusted_now());
+        self.manifest.entries[entry_index].last_message_time = Some(Local::now());
         self.write_manifest().await
     }
 
@@ -347,23 +326,6 @@ impl RecordingStore {
         Ok(())
     }
 
-    pub fn get_next_unuploaded_entry(&self, min_age: TimeDelta) -> Option<String> {
-        let now = rayhunter::clock::get_adjusted_now();
-        self.manifest
-            .entries
-            .iter()
-            .filter_map(|entry| {
-                if self.is_current_entry(&entry.name) || entry.upload_time.is_some() {
-                    return None;
-                }
-                let age = now - entry.last_message_time.unwrap_or(entry.start_time);
-
-                (age > min_age).then_some((&entry.name, age))
-            })
-            .max_by_key(|(_, age)| *age)
-            .map(|(name, _)| name.clone())
-    }
-
     // Finds an entry by filename
     pub fn entry_for_name(&self, name: &str) -> Option<(usize, &ManifestEntry)> {
         let entry_index = self
@@ -379,33 +341,6 @@ impl RecordingStore {
         Some((entry_index, &self.manifest.entries[entry_index]))
     }
 
-    pub async fn set_current_stop_reason(
-        &mut self,
-        reason: String,
-    ) -> Result<(), RecordingStoreError> {
-        if let Some(idx) = self.current_entry {
-            self.manifest.entries[idx].stop_reason = Some(reason);
-            self.write_manifest().await?;
-        }
-        Ok(())
-    }
-
-    pub async fn mark_entry_as_uploaded(
-        &mut self,
-        name: &str,
-        upload_time: DateTime<Local>,
-    ) -> Result<(), RecordingStoreError> {
-        let entry_index = self
-            .manifest
-            .entries
-            .iter()
-            .position(|entry| entry.name == name)
-            .ok_or(RecordingStoreError::NoSuchEntryError)?;
-        self.manifest.entries[entry_index].upload_time = Some(upload_time);
-        self.write_manifest().await?;
-        Ok(())
-    }
-
     pub fn is_current_entry(&self, name: &str) -> bool {
         match self.current_entry {
             Some(idx) => match self.manifest.entries.get(idx) {
@@ -582,78 +517,4 @@ mod tests {
         store.delete_all_entries().await.unwrap();
         assert!(store.current_entry.is_none());
     }
-
-    #[tokio::test]
-    async fn test_mark_entry_as_uploaded_sets_time_and_persists() {
-        let dir = make_temp_dir();
-        let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        let _ = store.new_entry().await.unwrap();
-        let name = store.manifest.entries[0].name.clone();
-        store.close_current_entry().await.unwrap();
-
-        let upload_time = Local::now();
-        store
-            .mark_entry_as_uploaded(&name, upload_time)
-            .await
-            .unwrap();
-        assert_eq!(store.manifest.entries[0].upload_time, Some(upload_time));
-
-        let reloaded = RecordingStore::load(dir.path()).await.unwrap();
-        assert_eq!(reloaded.manifest.entries[0].upload_time, Some(upload_time));
-    }
-
-    #[tokio::test]
-    async fn test_mark_entry_as_uploaded_missing_entry() {
-        let dir = make_temp_dir();
-        let mut store = RecordingStore::create(dir.path()).await.unwrap();
-        assert!(matches!(
-            store.mark_entry_as_uploaded("nope", Local::now()).await,
-            Err(RecordingStoreError::NoSuchEntryError)
-        ));
-    }
-
-    #[tokio::test]
-    async fn test_get_next_unuploaded_entry() {
-        let dir = make_temp_dir();
-        let mut store = RecordingStore::create(dir.path()).await.unwrap();
-
-        for _ in 0..3 {
-            let _ = store.new_entry().await.unwrap();
-        }
-
-        store.manifest.entries[0].name = "entry-0".to_owned();
-        store.manifest.entries[0].start_time = Local::now() - TimeDelta::seconds(10);
-        store.manifest.entries[0].last_message_time = None;
-
-        store.manifest.entries[1].name = "entry-1".to_owned();
-        store.manifest.entries[1].start_time = Local::now() - TimeDelta::seconds(10);
-        store.manifest.entries[1].last_message_time = Some(Local::now() - TimeDelta::seconds(5));
-
-        store.manifest.entries[2].name = "entry-2".to_owned();
-        store.manifest.entries[2].start_time = Local::now() - TimeDelta::seconds(10);
-        store.manifest.entries[2].last_message_time = Some(Local::now() - TimeDelta::seconds(1));
-
-        assert_eq!(
-            store.get_next_unuploaded_entry(TimeDelta::seconds(3600)),
-            None,
-        );
-
-        assert_eq!(
-            store.get_next_unuploaded_entry(TimeDelta::seconds(3)),
-            Some("entry-0".to_owned())
-        );
-        store
-            .mark_entry_as_uploaded("entry-0", Local::now())
-            .await
-            .unwrap();
-        assert_eq!(
-            store.get_next_unuploaded_entry(TimeDelta::seconds(3)),
-            Some("entry-1".to_owned())
-        );
-        store
-            .mark_entry_as_uploaded("entry-1", Local::now())
-            .await
-            .unwrap();
-        assert_eq!(store.get_next_unuploaded_entry(TimeDelta::seconds(3)), None);
-    }
 }

daemon/src/server.rs

@@ -9,23 +9,19 @@ use axum::extract::State;
 use axum::http::header::{self, CONTENT_LENGTH, CONTENT_TYPE};
 use axum::http::{HeaderValue, StatusCode};
 use axum::response::{IntoResponse, Response};
-use chrono::{DateTime, Local};
 use log::{error, warn};
-use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use tokio::fs::write;
 use tokio::io::{AsyncReadExt, copy, duplex};
-use tokio::sync::RwLock;
 use tokio::sync::mpsc::Sender;
+use tokio::sync::{RwLock, oneshot};
 use tokio_util::compat::FuturesAsyncWriteCompatExt;
 use tokio_util::io::ReaderStream;
-use tokio_util::sync::CancellationToken;
 
+use crate::DiagDeviceCtrlMessage;
 use crate::analysis::{AnalysisCtrlMessage, AnalysisStatus};
 use crate::config::Config;
-use crate::diag::DiagDeviceCtrlMessage;
 use crate::display::DisplayState;
-use crate::notifications::DEFAULT_NOTIFICATION_TIMEOUT;
 use crate::pcap::generate_pcap_data;
 use crate::qmdl_store::RecordingStore;
 
@@ -36,27 +32,10 @@ pub struct ServerState {
     pub diag_device_ctrl_sender: Sender<DiagDeviceCtrlMessage>,
     pub analysis_status_lock: Arc<RwLock<AnalysisStatus>>,
     pub analysis_sender: Sender<AnalysisCtrlMessage>,
-    pub daemon_restart_token: CancellationToken,
+    pub daemon_restart_tx: Arc<RwLock<Option<oneshot::Sender<()>>>>,
     pub ui_update_sender: Option<Sender<DisplayState>>,
-    pub wifi_status: Arc<RwLock<wifi_station::WifiStatus>>,
-    pub wifi_scan_lock: tokio::sync::Mutex<()>,
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/qmdl/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::OK, description = "QMDL download successful", content_type = "application/octet-stream"),
-        (status = StatusCode::NOT_FOUND, description = "Could not find file {name}"),
-        (status = StatusCode::SERVICE_UNAVAILABLE, description = "QMDL file is empty, or error opening file")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL filename to convert and download")
-    ),
-    summary = "Download a QMDL file",
-    description = "Stream the QMDL file {name} to the client."
-))]
 pub async fn get_qmdl(
     State(state): State<Arc<ServerState>>,
     Path(qmdl_name): Path<String>,
@@ -94,6 +73,11 @@ pub async fn serve_static(
     let path = path.trim_start_matches('/');
 
     match path {
+        "rayhunter_icon.png" => (
+            [(header::CONTENT_TYPE, HeaderValue::from_static("image/png"))],
+            include_bytes!("../web/build/rayhunter_icon.png"),
+        )
+            .into_response(),
         "rayhunter_orca_only.png" => (
             [(header::CONTENT_TYPE, HeaderValue::from_static("image/png"))],
             include_bytes!("../web/build/rayhunter_orca_only.png"),
@@ -124,50 +108,17 @@ pub async fn serve_static(
     }
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/config",
-    tag = "Configuration",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = Config)
-    ),
-    summary = "Get config",
-    description = "Show the running configuration for Rayhunter."
-))]
 pub async fn get_config(
     State(state): State<Arc<ServerState>>,
 ) -> Result<Json<Config>, (StatusCode, String)> {
-    let mut config = state.config.clone();
-    config.wifi_password = None;
-    Ok(Json(config))
+    Ok(Json(state.config.clone()))
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/config",
-    tag = "Configuration",
-    request_body(
-        content = Option<[Config]>,
-        description = "Any or all configuration elements from the valid config schema to be altered may be passed. Invalid keys will be discarded. Invalid values or value types will return an error."
-    ),
-    responses(
-        (status = StatusCode::ACCEPTED, description = "Success"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Failed to parse or write config file"),
-        (status = 422, description = "Failed to deserialize JSON body")
-    ),
-    summary = "Set config",
-    description = "Write a new configuration for Rayhunter and trigger a restart."
-))]
 pub async fn set_config(
     State(state): State<Arc<ServerState>>,
     Json(config): Json<Config>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    let mut config_to_write = config.clone();
-    config_to_write.wifi_ssid = None;
-    config_to_write.wifi_password = None;
-    config_to_write.wifi_security = None;
-
-    let config_str = toml::to_string_pretty(&config_to_write).map_err(|err| {
+    let config_str = toml::to_string_pretty(&config).map_err(|err| {
         (
             StatusCode::INTERNAL_SERVER_ERROR,
             format!("failed to serialize config as TOML: {err}"),
@@ -181,145 +132,27 @@ pub async fn set_config(
         )
     })?;
 
-    wifi_station::update_wpa_conf(&config.wifi_config()).await;
-
     // Trigger daemon restart after writing config
-    state.daemon_restart_token.cancel();
-    Ok((
-        StatusCode::ACCEPTED,
-        "wrote config and triggered restart".to_string(),
-    ))
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/test-notification",
-    tag = "Configuration",
-    responses(
-        (status = StatusCode::OK, description = "Success"),
-        (status = StatusCode::BAD_REQUEST, description = "No notification URL set"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Failed to send HTTP request. Ensure your device can reach the internet.")
-    ),
-    summary = "Test ntfy notification",
-    description = "Send a test notification to the ntfy_url in the running configuration for Rayhunter."
-))]
-pub async fn test_notification(
-    State(state): State<Arc<ServerState>>,
-) -> Result<(StatusCode, String), (StatusCode, String)> {
-    let url = state.config.ntfy_url.as_ref().ok_or((
-        StatusCode::BAD_REQUEST,
-        "No notification URL configured".to_string(),
-    ))?;
-
-    if url.is_empty() {
-        return Err((
-            StatusCode::BAD_REQUEST,
-            "Notification URL is empty".to_string(),
-        ));
+    let mut restart_tx = state.daemon_restart_tx.write().await;
+    if let Some(sender) = restart_tx.take() {
+        sender.send(()).map_err(|_| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "couldn't send restart signal".to_string(),
+            )
+        })?;
+        Ok((
+            StatusCode::ACCEPTED,
+            "wrote config and triggered restart".to_string(),
+        ))
+    } else {
+        Ok((
+            StatusCode::ACCEPTED,
+            "wrote config but restart already triggered".to_string(),
+        ))
     }
-
-    let http_client = reqwest::Client::new();
-    let message = "Test notification from Rayhunter".to_string();
-
-    crate::notifications::send_notification(
-        &http_client,
-        url,
-        message,
-        DEFAULT_NOTIFICATION_TIMEOUT,
-    )
-    .await
-    .map(|()| {
-        (
-            StatusCode::OK,
-            "Test notification sent successfully".to_string(),
-        )
-    })
-    .map_err(|e| {
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Failed to send test notification: {e}"),
-        )
-    })
 }
 
-/// Response for GET /api/time
-#[derive(Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
-pub struct TimeResponse {
-    /// The raw system time (without clock offset)
-    #[cfg_attr(feature = "apidocs", schema(value_type = String))]
-    pub system_time: DateTime<Local>,
-    /// The adjusted time (system time + offset)
-    #[cfg_attr(feature = "apidocs", schema(value_type = String))]
-    pub adjusted_time: DateTime<Local>,
-    /// The current offset in seconds
-    pub offset_seconds: i64,
-}
-
-/// Request for POST /api/time-offset
-#[derive(Deserialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
-pub struct SetTimeOffsetRequest {
-    /// The offset to set, in seconds
-    pub offset_seconds: i64,
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/time",
-    tag = "Configuration",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = TimeResponse)
-    ),
-    summary = "Get time",
-    description = "Get the current time and offset (in seconds) of the device."
-))]
-pub async fn get_time() -> Json<TimeResponse> {
-    let system_time = Local::now();
-    let adjusted_time = rayhunter::clock::get_adjusted_now();
-    let offset_seconds = adjusted_time
-        .signed_duration_since(system_time)
-        .num_seconds();
-    Json(TimeResponse {
-        system_time,
-        adjusted_time,
-        offset_seconds,
-    })
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/time-offset",
-    tag = "Configuration",
-    request_body(
-        content = SetTimeOffsetRequest
-    ),
-    responses(
-        (status = StatusCode::OK, description = "Success", body = TimeResponse)
-    ),
-    summary = "Set time offset",
-    description = "Set the difference (in seconds) between the system time and the adjusted time for Rayhunter."
-))]
-pub async fn set_time_offset(Json(req): Json<SetTimeOffsetRequest>) -> StatusCode {
-    rayhunter::clock::set_offset(chrono::TimeDelta::seconds(req.offset_seconds));
-    StatusCode::OK
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/zip/{name}",
-    tag = "Recordings",
-    responses(
-        (status = StatusCode::OK, description = "ZIP download successful. It is possible that if the PCAP fails to convert, the same status will be returned, but the file will contain only the QMDL file.", content_type = "application/zip"),
-        (status = StatusCode::NOT_FOUND, description = "Could not find file {name}"),
-        (status = StatusCode::SERVICE_UNAVAILABLE, description = "QMDL file is empty, or error opening file")
-    ),
-    params(
-        ("name" = String, Path, description = "QMDL filename to convert and download")
-    ),
-    summary = "Download a ZIP file",
-    description = "Stream a ZIP file to the client which contains the QMDL file {name} and a PCAP generated from the same file."
-))]
 pub async fn get_zip(
     State(state): State<Arc<ServerState>>,
     Path(entry_name): Path<String>,
@@ -411,70 +244,6 @@ pub async fn get_zip(
     Ok((headers, body).into_response())
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/wifi-status",
-    tag = "Configuration",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = wifi_station::WifiStatus)
-    ),
-    summary = "Get wifi status",
-    description = "Show the status of the wifi client."
-))]
-pub async fn get_wifi_status(
-    State(state): State<Arc<ServerState>>,
-) -> Json<wifi_station::WifiStatus> {
-    let status = state.wifi_status.read().await;
-    Json(status.clone())
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/wifi-scan",
-    tag = "Configuration",
-    responses(
-        (status = StatusCode::OK, description = "Scan success", body = inline(Vec<wifi_station::WifiNetwork>), content_type = "application/json"),
-        (status = StatusCode::TOO_MANY_REQUESTS, description = "Scan already in progress"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Scan failed"),
-    ),
-    summary = "Wifi SSID scan",
-    description = "Poll for a list of available wifi networks. Returns an array of WifiNetwork objects."
-))]
-pub async fn scan_wifi(
-    State(state): State<Arc<ServerState>>,
-) -> Result<Json<Vec<wifi_station::WifiNetwork>>, (StatusCode, String)> {
-    let _guard = state.wifi_scan_lock.try_lock().map_err(|_| {
-        (
-            StatusCode::TOO_MANY_REQUESTS,
-            "WiFi scan already in progress".to_string(),
-        )
-    })?;
-    let networks = wifi_station::scan_wifi_networks(wifi_station::STA_IFACE)
-        .await
-        .map_err(|e| {
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("WiFi scan failed: {e}"),
-            )
-        })?;
-    Ok(Json(networks))
-}
-
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    post,
-    path = "/api/debug/display-state",
-    tag = "Configuration",
-    request_body(
-        content = DisplayState
-    ),
-    responses(
-        (status = StatusCode::OK, description = "Display state updated successfully"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Error sending update to the display"),
-        (status = StatusCode::SERVICE_UNAVAILABLE, description = "Display system not available")
-    ),
-    summary = "Set display state",
-    description = "Change the display state (color bar or otherwise) of the device for debugging purposes."
-))]
 pub async fn debug_set_display_state(
     State(state): State<Arc<ServerState>>,
     Json(display_state): Json<DisplayState>,
@@ -562,10 +331,8 @@ mod tests {
             diag_device_ctrl_sender: tx,
             analysis_status_lock: Arc::new(RwLock::new(analysis_status)),
             analysis_sender: analysis_tx,
-            daemon_restart_token: CancellationToken::new(),
+            daemon_restart_tx: Arc::new(RwLock::new(None)),
             ui_update_sender: None,
-            wifi_status: Arc::new(RwLock::new(wifi_station::WifiStatus::default())),
-            wifi_scan_lock: tokio::sync::Mutex::new(()),
         })
     }
 

daemon/src/stats.rs

@@ -1,4 +1,3 @@
-use std::ffi::CString;
 use std::sync::Arc;
 
 use crate::battery::get_battery_status;
@@ -14,9 +13,7 @@ use rayhunter::{Device, util::RuntimeMetadata};
 use serde::Serialize;
 use tokio::process::Command;
 
-/// Structure of device system statistics
 #[derive(Debug, Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct SystemStats {
     pub disk_stats: DiskStats,
     pub memory_stats: MemoryStats,
@@ -28,7 +25,7 @@ pub struct SystemStats {
 impl SystemStats {
     pub async fn new(qmdl_path: &str, device: &Device) -> Result<Self, String> {
         Ok(Self {
-            disk_stats: DiskStats::new(qmdl_path)?,
+            disk_stats: DiskStats::new(qmdl_path, device).await?,
             memory_stats: MemoryStats::new(device).await?,
             runtime_metadata: RuntimeMetadata::new(),
             battery_status: match get_battery_status(device).await {
@@ -43,72 +40,49 @@ impl SystemStats {
     }
 }
 
-/// Device storage information
 #[derive(Debug, Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct DiskStats {
-    /// The partition to which the daemon is installed
     partition: String,
-    /// The total disk size of the partition
     total_size: String,
-    /// Total used size of the partition
     used_size: String,
-    /// Remaining free space of the partition
     available_size: String,
-    /// Disk usage displayed as percentage
     used_percent: String,
-    /// The root folder to which the partition is mounted
     mounted_on: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub available_bytes: Option<u64>,
 }
 
 impl DiskStats {
-    #[allow(clippy::unnecessary_cast)] // c_ulong is u32 on ARM, u64 on macOS
-    pub fn new(qmdl_path: &str) -> Result<Self, String> {
-        let c_path =
-            CString::new(qmdl_path).map_err(|e| format!("invalid path {qmdl_path}: {e}"))?;
-        let mut stat: libc::statvfs = unsafe { std::mem::zeroed() };
-        if unsafe { libc::statvfs(c_path.as_ptr(), &mut stat) } != 0 {
-            return Err(format!(
-                "statvfs({qmdl_path}) failed: {}",
-                std::io::Error::last_os_error()
-            ));
+    // runs "df -h <qmdl_path>" to get storage statistics for the partition containing
+    // the QMDL file.
+    pub async fn new(qmdl_path: &str, device: &Device) -> Result<Self, String> {
+        // Uz801 needs to be told to use the busybox df specifically
+        let mut df_cmd: Command;
+        if matches!(device, Device::Uz801) {
+            df_cmd = Command::new("busybox");
+            df_cmd.arg("df");
+        } else {
+            df_cmd = Command::new("df");
         }
+        df_cmd.arg("-h");
+        df_cmd.arg(qmdl_path);
+        let stdout = get_cmd_output(df_cmd).await?;
 
-        let block_size = stat.f_frsize as u64;
-        let total_kb = (stat.f_blocks as u64 * block_size / 1024) as usize;
-        let free_kb = (stat.f_bfree as u64 * block_size / 1024) as usize;
-        let available_kb = (stat.f_bavail as u64 * block_size / 1024) as usize;
-        let used_kb = total_kb.saturating_sub(free_kb);
-        let used_percent = format!(
-            "{}%",
-            ((stat.f_blocks - stat.f_bfree) * 100)
-                .checked_div(stat.f_blocks)
-                .unwrap_or(0)
-        );
-
+        // Handle standard df -h format
+        let mut parts = stdout.split_whitespace().skip(7);
         Ok(Self {
-            partition: qmdl_path.to_string(),
-            total_size: humanize_kb(total_kb),
-            used_size: humanize_kb(used_kb),
-            available_size: humanize_kb(available_kb),
-            used_percent,
-            mounted_on: qmdl_path.to_string(),
-            available_bytes: Some(stat.f_bavail as u64 * block_size),
+            partition: parts.next().ok_or("error parsing df output")?.to_string(),
+            total_size: parts.next().ok_or("error parsing df output")?.to_string(),
+            used_size: parts.next().ok_or("error parsing df output")?.to_string(),
+            available_size: parts.next().ok_or("error parsing df output")?.to_string(),
+            used_percent: parts.next().ok_or("error parsing df output")?.to_string(),
+            mounted_on: parts.next().ok_or("error parsing df output")?.to_string(),
         })
     }
 }
 
-/// Device memory information
 #[derive(Debug, Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct MemoryStats {
-    /// The total memory available on the device
     total: String,
-    /// The currently used memory
     used: String,
-    /// Remaining free memory
     free: String,
 }
 
@@ -161,17 +135,6 @@ fn humanize_kb(kb: usize) -> String {
     format!("{:.1}M", kb as f64 / 1024.0)
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/system-stats",
-    tag = "Statistics",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = SystemStats),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Error collecting statistics")
-    ),
-    summary = "Get system info",
-    description = "Display system/device statistics."
-))]
 pub async fn get_system_stats(
     State(state): State<Arc<ServerState>>,
 ) -> Result<Json<SystemStats>, (StatusCode, String)> {
@@ -188,26 +151,12 @@ pub async fn get_system_stats(
     }
 }
 
-/// QMDL manifest information
 #[derive(Serialize)]
-#[cfg_attr(feature = "apidocs", derive(utoipa::ToSchema))]
 pub struct ManifestStats {
-    /// A vector containing the names of the QMDL files
     pub entries: Vec<ManifestEntry>,
-    /// The currently open QMDL file
     pub current_entry: Option<ManifestEntry>,
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/qmdl-manifest",
-    tag = "Statistics",
-    responses(
-        (status = StatusCode::OK, description = "Success", body = ManifestStats)
-    ),
-    summary = "QMDL Manifest",
-    description = "List QMDL files available on the device and some of their basic statistics."
-))]
 pub async fn get_qmdl_manifest(
     State(state): State<Arc<ServerState>>,
 ) -> Result<Json<ManifestStats>, (StatusCode, String)> {
@@ -220,17 +169,6 @@ pub async fn get_qmdl_manifest(
     }))
 }
 
-#[cfg_attr(feature = "apidocs", utoipa::path(
-    get,
-    path = "/api/log",
-    tag = "Statistics",
-    responses(
-        (status = StatusCode::OK, description = "Success", content_type = "text/plain"),
-        (status = StatusCode::INTERNAL_SERVER_ERROR, description = "Could not read /data/rayhunter/rayhunter.log file")
-    ),
-    summary = "Display log",
-    description = "Download the current device log in UTF-8 plaintext."
-))]
 pub async fn get_log() -> Result<String, (StatusCode, String)> {
     tokio::fs::read_to_string("/data/rayhunter/rayhunter.log")
         .await

daemon/src/webdav.rs

@@ -1,446 +0,0 @@
-use std::fmt::Display;
-use std::{sync::Arc, time::Duration};
-
-use chrono::TimeDelta;
-use log::{info, warn};
-use reqwest::header::{CONTENT_LENGTH, CONTENT_TYPE};
-use reqwest::{Body, Client, Response};
-use tokio::fs::File;
-use tokio::join;
-use tokio::{select, sync::RwLock, time};
-use tokio_util::io::ReaderStream;
-use tokio_util::{sync::CancellationToken, task::TaskTracker};
-
-use crate::config::WebdavConfig;
-use crate::qmdl_store::RecordingStore;
-
-pub struct WebdavUploadWorkerConfig {
-    poll_interval: Duration,
-    min_age: TimeDelta,
-    url: String,
-    username: Option<String>,
-    password: Option<String>,
-    timeout: Duration,
-    delete_on_upload: bool,
-}
-
-impl From<WebdavConfig> for WebdavUploadWorkerConfig {
-    fn from(value: WebdavConfig) -> Self {
-        WebdavUploadWorkerConfig {
-            poll_interval: Duration::from_secs(value.poll_interval_secs),
-            min_age: TimeDelta::seconds(value.min_age_secs),
-            url: value.url,
-            username: value.username,
-            password: value.password,
-            timeout: Duration::from_secs(value.upload_timeout_secs),
-            delete_on_upload: value.delete_on_upload,
-        }
-    }
-}
-
-enum FileKind {
-    Analysis,
-    Qmdl,
-}
-
-impl FileKind {
-    fn as_extension(&self) -> &'static str {
-        match self {
-            FileKind::Analysis => ".ndjson",
-            FileKind::Qmdl => ".qmdl",
-        }
-    }
-}
-
-impl Display for FileKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FileKind::Analysis => write!(f, "analysis"),
-            FileKind::Qmdl => write!(f, "QMDL"),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct WebDavClient {
-    client: Client,
-    url: String,
-    username: Option<String>,
-    password: Option<String>,
-}
-
-impl WebDavClient {
-    fn new(
-        mut url: String,
-        username: Option<String>,
-        password: Option<String>,
-        timeout: Duration,
-    ) -> Result<Self, reqwest::Error> {
-        if !url.ends_with('/') {
-            url.push('/');
-        }
-        Ok(Self {
-            client: reqwest::Client::builder().timeout(timeout).build()?,
-            url,
-            username,
-            password,
-        })
-    }
-
-    async fn try_upload_file(&self, file: File, name: &str) -> anyhow::Result<Response> {
-        let file_size = file.metadata().await?.len();
-
-        let stream = ReaderStream::new(file);
-        let body = Body::wrap_stream(stream);
-
-        let target = format!("{}{}", self.url, name);
-
-        let client = self
-            .client
-            .put(&target)
-            .header(CONTENT_TYPE, "application/octet-stream")
-            .header(CONTENT_LENGTH, file_size);
-
-        let client = match (&self.username, &self.password) {
-            (Some(username), Some(password)) => client.basic_auth(username, Some(password)),
-            (Some(username), None) => client.basic_auth(username, None::<&str>),
-            (None, None) => client,
-            (None, Some(_)) => {
-                warn!(
-                    "Got WebDAV auth setting with no username but with a password, skipping authentication"
-                );
-                client
-            }
-        };
-
-        let resp = client.body(body).send().await?.error_for_status();
-        Ok(resp?)
-    }
-}
-
-async fn try_upload_entry(
-    client: WebDavClient,
-    store: Arc<RwLock<RecordingStore>>,
-    entry_name: String,
-    file_kind: FileKind,
-    shutdown_token: CancellationToken,
-) -> Option<()> {
-    let read_lock = store.read().await;
-    let entry_idx = read_lock.entry_for_name(&entry_name)?.0;
-    let file = match file_kind {
-        FileKind::Analysis => read_lock.open_entry_analysis(entry_idx).await,
-        FileKind::Qmdl => read_lock.open_entry_qmdl(entry_idx).await,
-    };
-    drop(read_lock);
-
-    let Ok(file) = file.map_err(|err| {
-        warn!(
-            "Unable to open entry: {} {} file: {:?}",
-            entry_name, file_kind, err
-        )
-    }) else {
-        return None;
-    };
-
-    let file_name = format!("{}{}", entry_name, file_kind.as_extension());
-
-    let res = select! {
-        _ = shutdown_token.cancelled() => {
-            warn!(
-                "Cancelling upload for entry {} {} file: received shutdown signal",
-                entry_name, file_kind
-            );
-            return None;
-        },
-        res = client.try_upload_file(file, &file_name) => res,
-    };
-
-    match res {
-        Ok(_) => {
-            info!("Uploaded {} file for entry {}", file_kind, entry_name);
-            Some(())
-        }
-        Err(err) => {
-            warn!(
-                "Failed to upload {} file for entry {}: {:?}",
-                file_kind, entry_name, err
-            );
-            None
-        }
-    }
-}
-
-pub fn run_webdav_upload_worker(
-    task_tracker: &TaskTracker,
-    shutdown_token: CancellationToken,
-    qmdl_store_lock: Arc<RwLock<RecordingStore>>,
-    config: WebdavUploadWorkerConfig,
-) {
-    task_tracker.spawn(async move {
-        let mut interval = time::interval(config.poll_interval);
-        interval.set_missed_tick_behavior(time::MissedTickBehavior::Skip);
-
-        let webdav_client = match WebDavClient::new(
-            config.url,
-            config.username,
-            config.password,
-            config.timeout,
-        ) {
-            Ok(client) => client,
-            Err(err) => {
-                warn!("Unable to create WebDAV client: {:?}", err);
-                return;
-            }
-        };
-
-        loop {
-            select! {
-                _ = shutdown_token.cancelled() => break,
-                _ = interval.tick() => {
-                    loop {
-                        let Some(unuploaded_entry) = qmdl_store_lock
-                            .read()
-                            .await
-                            .get_next_unuploaded_entry(config.min_age) else {
-                                break;
-                            };
-
-                        let (Some(()), Some(())) = join!(
-                            try_upload_entry(
-                                webdav_client.clone(),
-                                qmdl_store_lock.clone(),
-                                unuploaded_entry.clone(),
-                                FileKind::Qmdl,
-                                shutdown_token.clone(),
-                            ),
-                            try_upload_entry(
-                                webdav_client.clone(),
-                                qmdl_store_lock.clone(),
-                                unuploaded_entry.clone(),
-                                FileKind::Analysis,
-                                shutdown_token.clone()
-                            ),
-                        ) else {
-                            break;
-                        };
-
-                        if config.delete_on_upload {
-                            match qmdl_store_lock.write().await.delete_entry(&unuploaded_entry).await {
-                                Ok(_) => info!("Successfully deleted entry: {} after upload to WebDAV", unuploaded_entry),
-                                Err(err) => warn!("Unable to delete entry: {} after upload to WebDAV: {}", unuploaded_entry, err),
-                            }
-                        } else {
-                            match qmdl_store_lock.write().await.mark_entry_as_uploaded(&unuploaded_entry, rayhunter::clock::get_adjusted_now()).await {
-                                Ok(_) => info!("Successfully marked entry: {} as uploaded", unuploaded_entry),
-                                Err(err) => warn!("Unable to mark entry: {} as uploaded: {}", unuploaded_entry, err),
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use axum::{
-        Router,
-        body::Bytes,
-        extract::{Path as AxumPath, State},
-        http::{HeaderMap, StatusCode},
-        routing::put,
-    };
-    use tempfile::Builder;
-    use tokio::io::AsyncWriteExt;
-    use tokio::net::TcpListener;
-    use tokio::sync::Mutex;
-
-    #[derive(Clone, Debug)]
-    struct RecordedPut {
-        path: String,
-        auth: Option<String>,
-        body: Vec<u8>,
-    }
-
-    async fn capture_put(
-        State(state): State<Arc<Mutex<Vec<RecordedPut>>>>,
-        AxumPath(path): AxumPath<String>,
-        headers: HeaderMap,
-        body: Bytes,
-    ) -> StatusCode {
-        let auth = headers
-            .get("authorization")
-            .and_then(|v| v.to_str().ok())
-            .map(String::from);
-        state.lock().await.push(RecordedPut {
-            path,
-            auth,
-            body: body.to_vec(),
-        });
-        StatusCode::CREATED
-    }
-
-    async fn setup_webdav_server() -> (Arc<Mutex<Vec<RecordedPut>>>, String) {
-        crate::crypto_provider::install_default();
-
-        let state = Arc::new(Mutex::new(Vec::new()));
-        let app = Router::new()
-            .route("/{*path}", put(capture_put))
-            .with_state(state.clone());
-
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-        let url = format!("http://{}/dav", addr);
-
-        tokio::spawn(async move {
-            axum::serve(listener, app).await.unwrap();
-        });
-
-        tokio::time::sleep(Duration::from_millis(100)).await;
-
-        (state, url)
-    }
-
-    async fn cleanup_worker(shutdown: CancellationToken, tracker: TaskTracker) {
-        shutdown.cancel();
-        tracker.close();
-        tracker.wait().await;
-    }
-
-    async fn make_store_with_closed_entry(
-        dir: &std::path::Path,
-    ) -> (Arc<RwLock<RecordingStore>>, String) {
-        let mut store = RecordingStore::create(dir).await.unwrap();
-        let (mut qmdl_file, mut analysis_file) = store.new_entry().await.unwrap();
-        qmdl_file.write_all(b"fake qmdl payload").await.unwrap();
-        qmdl_file.flush().await.unwrap();
-        analysis_file
-            .write_all(b"fake ndjson payload")
-            .await
-            .unwrap();
-        analysis_file.flush().await.unwrap();
-        let entry_index = store.current_entry.unwrap();
-        let name = store.manifest.entries[entry_index].name.clone();
-        store.update_entry_qmdl_size(entry_index, 17).await.unwrap();
-        store.close_current_entry().await.unwrap();
-        (Arc::new(RwLock::new(store)), name)
-    }
-
-    #[tokio::test]
-    async fn test_webdav_upload_worker_uploads_entry() {
-        let (captured, url) = setup_webdav_server().await;
-
-        let dir = Builder::new().prefix("webdav_test").tempdir().unwrap();
-        let (store, entry_name) = make_store_with_closed_entry(dir.path()).await;
-
-        let shutdown = CancellationToken::new();
-        let tracker = TaskTracker::new();
-        let config = WebdavUploadWorkerConfig {
-            poll_interval: Duration::from_millis(50),
-            min_age: TimeDelta::seconds(-1),
-            url,
-            username: Some("user".to_string()),
-            password: Some("password".to_string()),
-            timeout: Duration::from_secs(1),
-            delete_on_upload: false,
-        };
-
-        run_webdav_upload_worker(&tracker, shutdown.clone(), store.clone(), config);
-
-        tokio::time::sleep(Duration::from_millis(500)).await;
-        cleanup_worker(shutdown, tracker).await;
-
-        let recorded = captured.lock().await;
-        assert_eq!(recorded.len(), 2);
-        let paths: Vec<&str> = recorded.iter().map(|r| r.path.as_str()).collect();
-        let qmdl_path = format!("dav/{}.qmdl", entry_name);
-        let ndjson_path = format!("dav/{}.ndjson", entry_name);
-        assert!(paths.contains(&qmdl_path.as_str()));
-        assert!(paths.contains(&ndjson_path.as_str()));
-        for put in recorded.iter() {
-            assert_eq!(put.auth.as_deref(), Some("Basic dXNlcjpwYXNzd29yZA=="));
-        }
-        let qmdl_body = recorded
-            .iter()
-            .find(|r| r.path == qmdl_path)
-            .unwrap()
-            .body
-            .clone();
-        let ndjson_body = recorded
-            .iter()
-            .find(|r| r.path == ndjson_path)
-            .unwrap()
-            .body
-            .clone();
-        drop(recorded);
-        assert_eq!(qmdl_body, b"fake qmdl payload");
-        assert_eq!(ndjson_body, b"fake ndjson payload");
-
-        let store_read = store.read().await;
-        let (_, entry) = store_read.entry_for_name(&entry_name).unwrap();
-        assert!(entry.upload_time.is_some());
-    }
-
-    #[tokio::test]
-    async fn test_webdav_upload_worker_deletes_when_configured() {
-        let (captured, url) = setup_webdav_server().await;
-
-        let dir = Builder::new().prefix("webdav_test").tempdir().unwrap();
-        let (store, entry_name) = make_store_with_closed_entry(dir.path()).await;
-
-        let shutdown = CancellationToken::new();
-        let tracker = TaskTracker::new();
-        let config = WebdavUploadWorkerConfig {
-            poll_interval: Duration::from_millis(50),
-            min_age: TimeDelta::seconds(-1),
-            url,
-            username: None,
-            password: None,
-            timeout: Duration::from_secs(1),
-            delete_on_upload: true,
-        };
-
-        run_webdav_upload_worker(&tracker, shutdown.clone(), store.clone(), config);
-
-        tokio::time::sleep(Duration::from_millis(500)).await;
-        cleanup_worker(shutdown, tracker).await;
-
-        assert_eq!(captured.lock().await.len(), 2);
-
-        let store_read = store.read().await;
-        assert!(store_read.entry_for_name(&entry_name).is_none());
-    }
-
-    #[tokio::test]
-    async fn test_webdav_upload_worker_respects_min_age() {
-        let (captured, url) = setup_webdav_server().await;
-
-        let dir = Builder::new().prefix("webdav_test").tempdir().unwrap();
-        let (store, entry_name) = make_store_with_closed_entry(dir.path()).await;
-
-        let shutdown = CancellationToken::new();
-        let tracker = TaskTracker::new();
-        let config = WebdavUploadWorkerConfig {
-            poll_interval: Duration::from_millis(50),
-            min_age: TimeDelta::seconds(3600),
-            url,
-            username: None,
-            password: None,
-            timeout: Duration::from_secs(1),
-            delete_on_upload: false,
-        };
-
-        run_webdav_upload_worker(&tracker, shutdown.clone(), store.clone(), config);
-
-        tokio::time::sleep(Duration::from_millis(500)).await;
-        cleanup_worker(shutdown, tracker).await;
-
-        assert!(captured.lock().await.is_empty());
-
-        let store_read = store.read().await;
-        let (_, entry) = store_read.entry_for_name(&entry_name).unwrap();
-        assert!(entry.upload_time.is_none());
-    }
-}

daemon/web/.gitignore

@@ -19,3 +19,6 @@ Thumbs.db
 # Vite
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
+
+package-lock.json
+yarn.lock

daemon/web/eslint.config.js

@@ -22,7 +22,7 @@ export default ts.config(
         },
     },
     {
-        files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+        files: ['**/*.svelte'],
 
         languageOptions: {
             parserOptions: {
@@ -37,22 +37,6 @@ export default ts.config(
                 { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
             ],
             '@typescript-eslint/no-explicit-any': 'off',
-            '@typescript-eslint/naming-convention': [
-                'error',
-                {
-                    selector: 'function',
-                    format: ['snake_case'],
-                },
-                {
-                    selector: 'method',
-                    format: ['snake_case'],
-                },
-            ],
-            // these rules should eventually be enabled, just disabled them to
-            // make dependency upgrades easier.
-            'svelte/prefer-svelte-reactivity': 'off',
-            'svelte/require-each-key': 'off',
-            'svelte/no-navigation-without-resolve': 'off',
         },
     }
 );

daemon/web/package.json

@@ -15,26 +15,24 @@
         "fix": "eslint --fix ."
     },
     "devDependencies": {
-        "@eslint/js": "^10.0.1",
-        "@sveltejs/adapter-auto": "^7.0.1",
+        "@sveltejs/adapter-auto": "^3.0.0",
         "@sveltejs/adapter-static": "^3.0.5",
-        "@sveltejs/kit": "^2.58.0",
-        "@sveltejs/vite-plugin-svelte": "^7.0.0",
-        "@tailwindcss/vite": "^4.2.2",
+        "@sveltejs/kit": "^2.13.0",
+        "@sveltejs/vite-plugin-svelte": "^4.0.0",
         "@types/eslint": "^9.6.0",
-        "@types/node": "^25.6.0",
-        "eslint": "^10.2.1",
-        "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-svelte": "^3.17.1",
-        "globals": "^17.5.0",
-        "prettier": "^3.8.3",
-        "prettier-plugin-svelte": "^3.5.1",
-        "svelte": "^5.55.5",
-        "svelte-check": "^4.4.6",
-        "tailwindcss": "^4.2.2",
-        "typescript": "^6.0.3",
-        "typescript-eslint": "^8.59.0",
-        "vite": "^8.0.10",
-        "vitest": "^4.1.5"
+        "autoprefixer": "^10.4.20",
+        "eslint": "^9.7.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-svelte": "^2.36.0",
+        "globals": "^15.0.0",
+        "prettier": "^3.3.2",
+        "prettier-plugin-svelte": "^3.2.6",
+        "svelte": "^5.0.0",
+        "svelte-check": "^4.0.0",
+        "tailwindcss": "^3.4.9",
+        "typescript": "^5.0.0",
+        "typescript-eslint": "^8.0.0",
+        "vite": "^5.0.3",
+        "vitest": "^2.0.4"
     }
 }

daemon/web/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+    plugins: {
+        tailwindcss: {},
+        autoprefixer: {},
+    },
+};

daemon/web/src/app.css

@@ -1,16 +1,3 @@
-@import 'tailwindcss';
-
-@theme {
-    --color-rayhunter-blue: #4e4eb1;
-    --color-rayhunter-dark-blue: #3f3da0;
-    --color-rayhunter-green: #94ea18;
-}
-
-/* v4 dropped the v3 preflight rule that set `cursor: pointer` on buttons.
- * Restore it so enabled buttons get the pointer cursor. */
-@layer base {
-    button:not(:disabled),
-    [role='button']:not(:disabled) {
-        cursor: pointer;
-    }
-}
+@import 'tailwindcss/base';
+@import 'tailwindcss/components';
+@import 'tailwindcss/utilities';

daemon/web/src/lib/components/ActionErrors.svelte

@@ -20,7 +20,7 @@
 
 {#if action_errors.length > 0}
     <div
-        class="bg-red-100 border-red-100 drop-shadow-sm p-4 flex flex-col gap-2
+        class="bg-red-100 border-red-100 drop-shadow p-4 flex flex-col gap-2
         border rounded-md flex-1 justify-between fixed z-10 right-3 bottom-3 ml-3"
     >
         <div class="flex flex-row justify-between">

daemon/web/src/lib/components/AnalysisTable.svelte

@@ -11,7 +11,7 @@
         dateStyle: 'short',
     });
 
-    const analyzers = $derived(report.metadata.analyzers);
+    const analyzers = report.metadata.analyzers;
 
     const skipped_messages: Map<string, number> = $derived.by(() => {
         let map = new Map();
@@ -33,7 +33,7 @@
     {#if report.statistics.num_warnings === 0 && report.statistics.num_informational_logs === 0}
         <p>Nothing to show!</p>
     {:else}
-        <div class="overflow-x-auto">
+        <div class="overflow-x-scroll">
             <table class="table-auto text-left">
                 <thead class="p-2">
                     <tr class="bg-gray-300">
@@ -77,11 +77,10 @@
     <div>
         <p class="text-lg underline">Unparsed Messages</p>
         <p>
-            These are due to a limitation or bug in Rayhunter's parser, and aren't usually a
-            problem. We'll not accept bug reports about them unless something else is going wrong
-            (such as false-positives or definite false-negatives)
+            These are due to a limitation or bug in Rayhunter's parser, and aren't ususally a
+            problem.
         </p>
-        <div class="overflow-x-auto">
+        <div class="overflow-x-scroll">
             <table class="table-auto text-left">
                 <thead class="p-2">
                     <tr class="bg-gray-300">

daemon/web/src/lib/components/AnalysisView.svelte

@@ -22,26 +22,10 @@
         <p>Error getting analysis report: {entry.analysis_report}</p>
     {:else}
         {@const metadata: ReportMetadata = entry.analysis_report.metadata}
-        {@const numWarnings: number = entry.get_num_warnings() || 0}
         <div class="flex flex-col gap-2">
-            {#if !!numWarnings || !current}
-                <div class="flex flex-row justify-between items-center">
-                    {#if !!numWarnings}
-                        <div
-                            class="text-red-700 border-red-500 border rounded-lg text-blue-600 px-2 py-1 mr-12"
-                        >
-                            Your Rayhunter device raised {`${numWarnings}`} warning{`${
-                                numWarnings > 1 ? 's' : ''
-                            }`}!
-                            <a
-                                href="https://efforg.github.io/rayhunter/faq.html#red"
-                                class="text-blue-600 underline">Read the FAQ</a
-                            > to learn what you can do about it
-                        </div>
-                    {/if}
-                    {#if !current}
-                        <ReAnalyzeButton {entry} {manager} />
-                    {/if}
+            {#if !current}
+                <div class="flex flex-row justify-end items-center">
+                    <ReAnalyzeButton {entry} {manager} />
                 </div>
             {/if}
             {#if entry.analysis_report.rows.length > 0}

daemon/web/src/lib/components/ApiRequestButton.svelte

@@ -12,7 +12,6 @@
         onclick,
         ariaLabel,
         errorMessage,
-        jsonBody,
     }: {
         url: string;
         method?: string;
@@ -24,7 +23,6 @@
         onclick?: () => void | Promise<void>;
         ariaLabel?: string;
         errorMessage?: string;
-        jsonBody?: unknown;
     } = $props();
 
     let is_requesting = $state(false);
@@ -45,7 +43,7 @@
         },
     };
 
-    async function handle_click() {
+    async function handleClick() {
         if (is_disabled) return;
 
         is_requesting = true;
@@ -53,8 +51,7 @@
             await user_action_req(
                 method,
                 url,
-                errorMessage ? errorMessage : 'Error performing action',
-                jsonBody
+                errorMessage ? errorMessage : 'Error performing action'
             );
             if (onclick) {
                 await onclick();
@@ -74,7 +71,7 @@
 
 <button
     class="text-white font-bold py-2 px-2 sm:px-4 rounded-md flex flex-row items-center gap-1 {buttonClasses}"
-    onclick={handle_click}
+    onclick={handleClick}
     disabled={is_disabled}
     aria-label={ariaLabel || label}
 >

daemon/web/src/lib/components/ClockDriftAlert.svelte

@@ -1,121 +0,0 @@
-<script lang="ts">
-    import { get_daemon_time } from '$lib/utils.svelte';
-    import ApiRequestButton from './ApiRequestButton.svelte';
-
-    let show_alert = $state(false);
-    let device_system_time = $state('');
-    let device_adjusted_time = $state('');
-    let browser_time = $state('');
-    let has_offset = $state(false);
-    let computed_offset = $state(0);
-    let dismissed = $state(false);
-    let check_completed = $state(false);
-
-    const DRIFT_THRESHOLD_SECONDS = 30;
-
-    function format_time(date: Date): string {
-        return date.toLocaleString();
-    }
-
-    async function check_clock_drift() {
-        if (check_completed) return;
-
-        try {
-            const daemon_time_response = await get_daemon_time();
-            const browser_now = new Date();
-            const daemon_system_ms = new Date(daemon_time_response.system_time).getTime();
-            const device_adjusted_ms = new Date(daemon_time_response.adjusted_time).getTime();
-            const drift_seconds = Math.round((browser_now.getTime() - device_adjusted_ms) / 1000);
-
-            if (Math.abs(drift_seconds) > DRIFT_THRESHOLD_SECONDS && !dismissed) {
-                device_system_time = format_time(new Date(daemon_time_response.system_time));
-                device_adjusted_time = format_time(new Date(daemon_time_response.adjusted_time));
-                browser_time = format_time(browser_now);
-                has_offset = daemon_time_response.offset_seconds !== 0;
-                // Calculate offset needed: browser_time - daemon_system_time
-                computed_offset = Math.round((browser_now.getTime() - daemon_system_ms) / 1000);
-                show_alert = true;
-            }
-        } catch (err) {
-            console.error('Failed to check clock drift:', err);
-        }
-        check_completed = true;
-    }
-
-    function dismiss() {
-        show_alert = false;
-        dismissed = true;
-    }
-
-    // Check clock drift on component mount
-    $effect(() => {
-        check_clock_drift();
-    });
-</script>
-
-{#if show_alert}
-    <div
-        class="bg-yellow-100 border-yellow-400 drop-shadow-sm p-4 flex flex-col gap-2 border rounded-md"
-    >
-        <span class="text-xl font-bold flex flex-row items-center gap-2 text-yellow-700">
-            <svg
-                class="w-6 h-6 text-yellow-600"
-                aria-hidden="true"
-                xmlns="http://www.w3.org/2000/svg"
-                width="24"
-                height="24"
-                fill="currentColor"
-                viewBox="0 0 24 24"
-            >
-                <path
-                    fill-rule="evenodd"
-                    d="M2 12C2 6.477 6.477 2 12 2s10 4.477 10 10-4.477 10-10 10S2 17.523 2 12Zm11-4a1 1 0 1 0-2 0v4a1 1 0 0 0 .293.707l3 3a1 1 0 0 0 1.414-1.414L13 11.586V8Z"
-                    clip-rule="evenodd"
-                />
-            </svg>
-            Clock Mismatch Detected
-        </span>
-        <p>
-            Rayhunter's clock doesn't match your browser's, and may be incorrect. This can happen if
-            Rayhunter is unable to get the correct time from the internet. Consider synchronizing
-            your browser's clock with the button below, or using another SIM card for better
-            results.
-        </p>
-        <table class="w-fit">
-            <tbody>
-                <tr>
-                    <td class="pr-2">Rayhunter clock (system):</td>
-                    <td class="font-mono">{device_system_time}</td>
-                </tr>
-                {#if has_offset}
-                    <tr>
-                        <td class="pr-2">Rayhunter clock (adjusted):</td>
-                        <td class="font-mono">{device_adjusted_time}</td>
-                    </tr>
-                {/if}
-                <tr>
-                    <td class="pr-2">Browser clock:</td>
-                    <td class="font-mono">{browser_time}</td>
-                </tr>
-            </tbody>
-        </table>
-        <p>Copy browser clock to device?</p>
-        <div class="flex flex-row gap-2 justify-end">
-            <button
-                class="font-medium py-2 px-4 rounded-md border border-gray-400 hover:bg-yellow-200"
-                onclick={dismiss}
-            >
-                Dismiss
-            </button>
-            <ApiRequestButton
-                url="/api/time-offset"
-                label="Sync Clock"
-                loadingLabel="Syncing..."
-                variant="green"
-                jsonBody={{ offset_seconds: computed_offset }}
-                onclick={dismiss}
-                errorMessage="Error syncing clock"
-            />
-        </div>
-    </div>
-{/if}

daemon/web/src/lib/components/ConfigForm.svelte

@@ -1,40 +1,20 @@
 <script lang="ts">
-    import {
-        get_config,
-        set_config,
-        test_notification,
-        get_wifi_status,
-        scan_wifi_networks,
-        type Config,
-        type WifiStatus,
-        type WifiNetwork,
-    } from '../utils.svelte';
-    import Modal from './Modal.svelte';
+    import { get_config, set_config, type Config } from '../utils.svelte';
 
-    let { shown = $bindable() }: { shown: boolean } = $props();
     let config = $state<Config | null>(null);
 
     let loading = $state(false);
     let saving = $state(false);
-    let testingNotification = $state(false);
     let message = $state('');
     let messageType = $state<'success' | 'error' | null>(null);
-    let testMessage = $state('');
-    let testMessageType = $state<'success' | 'error' | null>(null);
-    let wifiStatus = $state<WifiStatus | null>(null);
-    let wifiStatusTimer = $state<ReturnType<typeof setInterval> | null>(null);
-    let scanning = $state(false);
-    let scanResults = $state<WifiNetwork[]>([]);
-    let dnsServersInput = $state('');
+    let showConfig = $state(false);
 
-    async function load_config() {
+    async function loadConfig() {
         try {
             loading = true;
             config = await get_config();
-            dnsServersInput = config.dns_servers ? config.dns_servers.join(', ') : '';
             message = '';
             messageType = null;
-            poll_wifi_status();
         } catch (error) {
             message = `Failed to load config: ${error}`;
             messageType = 'error';
@@ -43,18 +23,9 @@
         }
     }
 
-    async function save_config() {
+    async function saveConfig() {
         if (!config) return;
 
-        const trimmed = dnsServersInput.trim();
-        config.dns_servers =
-            trimmed.length > 0
-                ? trimmed
-                      .split(',')
-                      .map((s) => s.trim())
-                      .filter((s) => s.length > 0)
-                : null;
-
         try {
             saving = true;
             await set_config(config);
@@ -69,84 +40,32 @@
         }
     }
 
-    async function poll_wifi_status() {
-        if (wifiStatusTimer) clearInterval(wifiStatusTimer);
-        try {
-            wifiStatus = await get_wifi_status();
-        } catch {
-            wifiStatus = null;
-        }
-        wifiStatusTimer = setInterval(async () => {
-            try {
-                wifiStatus = await get_wifi_status();
-            } catch {
-                wifiStatus = null;
-            }
-        }, 5000);
-    }
-
-    let scanError = $state('');
-
-    async function do_scan() {
-        scanning = true;
-        scanError = '';
-        try {
-            scanResults = await scan_wifi_networks();
-        } catch (error) {
-            scanResults = [];
-            scanError = `Scan failed: ${error}`;
-        } finally {
-            scanning = false;
-        }
-    }
-
-    function select_network(network: WifiNetwork) {
-        if (config) {
-            config.wifi_ssid = network.ssid;
-            config.wifi_password = '';
-            config.wifi_security =
-                network.security === 'WPA3' || network.security === 'WPA3 (transition)'
-                    ? 'sae'
-                    : 'wpa_psk';
-            scanResults = [];
-        }
-    }
-
-    async function send_test_notification() {
-        try {
-            testingNotification = true;
-            testMessage = '';
-            testMessageType = null;
-            await test_notification();
-            testMessage = 'Test notification sent successfully!';
-            testMessageType = 'success';
-        } catch (error) {
-            testMessage = `${error}`;
-            testMessageType = 'error';
-        } finally {
-            testingNotification = false;
-        }
-    }
-
+    // Load config when first shown
     $effect(() => {
-        if (shown && !config) {
-            load_config();
+        if (showConfig && !config) {
+            loadConfig();
         }
-        if (!shown && wifiStatusTimer) {
-            clearInterval(wifiStatusTimer);
-            wifiStatusTimer = null;
-        }
-        return () => {
-            if (wifiStatusTimer) {
-                clearInterval(wifiStatusTimer);
-                wifiStatusTimer = null;
-            }
-        };
     });
 </script>
 
-<Modal bind:shown title="Configuration">
-    <div class="p-2">
+<div class="bg-white rounded-lg shadow-md p-6 m-4">
+    <button
+        class="w-full flex justify-between items-center text-xl font-bold mb-4 text-rayhunter-dark-blue hover:text-rayhunter-blue"
+        onclick={() => (showConfig = !showConfig)}
+    >
+        <span>Configuration</span>
+        <svg
+            class="w-6 h-6 transition-transform {showConfig ? 'rotate-180' : ''}"
+            fill="none"
+            stroke="currentColor"
+            viewBox="0 0 24 24"
+        >
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"
+            ></path>
+        </svg>
+    </button>
+
+    {#if showConfig}
         {#if loading}
             <div class="text-center py-4">Loading config...</div>
         {:else if config}
@@ -154,7 +73,7 @@
                 class="space-y-4"
                 onsubmit={(e) => {
                     e.preventDefault();
-                    save_config();
+                    saveConfig();
                 }}
             >
                 <div>
@@ -164,18 +83,13 @@
                     <select
                         id="ui_level"
                         bind:value={config.ui_level}
-                        class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
+                        class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
                     >
                         <option value={0}>0 - Invisible mode</option>
                         <option value={1}>1 - Subtle mode (colored line)</option>
                         <option value={2}>2 - Demo mode (orca gif)</option>
                         <option value={3}>3 - EFF logo</option>
-                        <option value={4}>4 - High visibility (full screen color)</option>
                     </select>
-                    <p class="text-xs text-gray-500 mt-1">
-                        Note: Rayhunter draws over the device's native UI, so some flickering is
-                        expected
-                    </p>
                 </div>
 
                 <div>
@@ -188,21 +102,34 @@
                     <select
                         id="key_input_mode"
                         bind:value={config.key_input_mode}
-                        class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
+                        class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
                     >
                         <option value={0}>0 - Disable button control</option>
-                        <option value={1}>1 - Double-tap power button to start new recording</option
+                        <option value={1}
+                            >1 - Double-tap power button to start/stop recording</option
                         >
                     </select>
                 </div>
 
+                <div>
+                    <label for="ntfy_url" class="block text-sm font-medium text-gray-700 mb-1">
+                        ntfy URL for Sending Notifications
+                    </label>
+                    <input
+                        id="ntfy_url"
+                        type="url"
+                        bind:value={config.ntfy_url}
+                        class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-rayhunter-blue"
+                    />
+                </div>
+
                 <div class="space-y-3">
                     <div class="flex items-center">
                         <input
                             id="colorblind_mode"
                             type="checkbox"
                             bind:checked={config.colorblind_mode}
-                            class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                            class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                         />
                         <label for="colorblind_mode" class="ml-2 block text-sm text-gray-700">
                             Colorblind Mode
@@ -210,354 +137,7 @@
                     </div>
                 </div>
 
-                <div class="border-t border-gray-200 pt-4 mt-6 space-y-3">
-                    <h3 class="text-lg font-semibold text-gray-800 mb-4">Notification Settings</h3>
-                    <div>
-                        <label for="ntfy_url" class="block text-sm font-medium text-gray-700 mb-1">
-                            ntfy URL for Sending Notifications (if unset you will not receive
-                            notifications)
-                        </label>
-                        <input
-                            id="ntfy_url"
-                            type="url"
-                            bind:value={config.ntfy_url}
-                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                        />
-                        <p class="text-xs text-gray-500 mt-1">
-                            Test button below uses the saved configuration URL, not the input above
-                        </p>
-                    </div>
-
-                    <div>
-                        <button
-                            type="button"
-                            onclick={send_test_notification}
-                            disabled={testingNotification}
-                            class="bg-rayhunter-blue hover:bg-rayhunter-dark-blue disabled:opacity-50 disabled:cursor-not-allowed text-white font-bold py-2 px-4 rounded-md flex flex-row gap-1 items-center"
-                        >
-                            {#if testingNotification}
-                                <div
-                                    class="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin"
-                                ></div>
-                                Sending...
-                            {:else}
-                                <svg
-                                    class="w-4 h-4"
-                                    fill="none"
-                                    stroke="currentColor"
-                                    viewBox="0 0 24 24"
-                                >
-                                    <path
-                                        stroke-linecap="round"
-                                        stroke-linejoin="round"
-                                        stroke-width="2"
-                                        d="M12 19l9 2-9-18-9 18 9-2zm0 0v-8"
-                                    ></path>
-                                </svg>
-                                Send Test Notification
-                            {/if}
-                        </button>
-                        {#if testMessage}
-                            <div
-                                class="mt-2 p-2 rounded-sm text-sm {testMessageType === 'error'
-                                    ? 'bg-red-100 text-red-700'
-                                    : 'bg-green-100 text-green-700'}"
-                            >
-                                {testMessage}
-                            </div>
-                        {/if}
-                    </div>
-
-                    <div class="space-y-2">
-                        <div class="block text-sm font-medium text-gray-700 mb-1">
-                            Enabled Notification Types
-                        </div>
-                        <div class="flex items-center">
-                            <input
-                                type="checkbox"
-                                id="enable_warning_notifications"
-                                value="Warning"
-                                bind:group={config.enabled_notifications}
-                            />
-                            <label
-                                for="enable_warning_notifications"
-                                class="ml-2 block text-sm text-gray-700"
-                            >
-                                Warnings
-                            </label>
-                        </div>
-                        <div class="flex items-center">
-                            <input
-                                type="checkbox"
-                                id="enable_lowbattery_notifications"
-                                value="LowBattery"
-                                bind:group={config.enabled_notifications}
-                            />
-                            <label
-                                for="enable_lowbattery_notifications"
-                                class="ml-2 block text-sm text-gray-700"
-                            >
-                                Low Battery
-                            </label>
-                        </div>
-                    </div>
-                </div>
-
-                <div class="border-t border-gray-200 pt-4 mt-6 space-y-3">
-                    <h3 class="text-lg font-semibold text-gray-800 mb-4">Storage Management</h3>
-
-                    <div>
-                        <label
-                            for="min_space_to_start_recording_mb"
-                            class="block text-sm font-medium text-gray-700 mb-1"
-                        >
-                            Minimum Space to Start Recording (MB)
-                        </label>
-                        <input
-                            id="min_space_to_start_recording_mb"
-                            type="number"
-                            min="1"
-                            bind:value={config.min_space_to_start_recording_mb}
-                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                        />
-                        <p class="text-xs text-gray-500 mt-1">
-                            Recording will not start if less than this amount of disk space is free
-                        </p>
-                    </div>
-
-                    <div>
-                        <label
-                            for="min_space_to_continue_recording_mb"
-                            class="block text-sm font-medium text-gray-700 mb-1"
-                        >
-                            Minimum Space to Continue Recording (MB)
-                        </label>
-                        <input
-                            id="min_space_to_continue_recording_mb"
-                            type="number"
-                            min="1"
-                            bind:value={config.min_space_to_continue_recording_mb}
-                            class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                        />
-                        <p class="text-xs text-gray-500 mt-1">
-                            Recording will stop automatically if disk space drops below this level
-                        </p>
-                    </div>
-                </div>
-
-                {#if config.device === 'orbic' || config.device === 'moxee' || config.device === 'tmobile' || config.device === 'wingtech'}
-                    <div class="border-t border-gray-200 pt-4 mt-6 space-y-3">
-                        <h3 class="text-lg font-semibold text-gray-800 mb-4">WiFi Client Mode</h3>
-                        <p class="text-xs text-gray-500">
-                            Connect the device to an existing WiFi network for internet access (e.g.
-                            notifications, remote access). The hotspot AP stays running alongside
-                            WiFi client mode.
-                        </p>
-
-                        <div class="flex items-center">
-                            <input
-                                id="wifi_enabled"
-                                type="checkbox"
-                                bind:checked={config.wifi_enabled}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
-                            />
-                            <label for="wifi_enabled" class="ml-2 block text-sm text-gray-700">
-                                Enable WiFi
-                            </label>
-                        </div>
-                        <p class="text-xs text-gray-500">
-                            Unchecking stops WiFi without clearing saved credentials.
-                        </p>
-
-                        {#if wifiStatus && config.wifi_enabled}
-                            {#if wifiStatus.state === 'connected'}
-                                <p class="text-xs text-green-600">
-                                    Connected to "{wifiStatus.ssid}" ({wifiStatus.ip})
-                                </p>
-                            {:else if wifiStatus.state === 'connecting'}
-                                <p class="text-xs text-amber-600">Connecting...</p>
-                            {:else if wifiStatus.state === 'recovering'}
-                                <p class="text-xs text-amber-600">Recovering connection...</p>
-                            {:else if wifiStatus.state === 'dataPathDead'}
-                                <p class="text-xs text-amber-600">
-                                    Data path stalled, attempting recovery...
-                                </p>
-                            {:else if wifiStatus.state === 'failed'}
-                                <p class="text-xs text-red-600">
-                                    Failed: {wifiStatus.error}
-                                </p>
-                            {/if}
-                        {/if}
-
-                        <div>
-                            <label
-                                for="wifi_ssid"
-                                class="block text-sm font-medium text-gray-700 mb-1"
-                            >
-                                WiFi Network Name (SSID)
-                            </label>
-                            <div class="flex gap-2">
-                                <input
-                                    id="wifi_ssid"
-                                    type="text"
-                                    bind:value={config.wifi_ssid}
-                                    placeholder="MyWiFiNetwork"
-                                    class="flex-1 px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                                />
-                                <button
-                                    type="button"
-                                    onclick={do_scan}
-                                    disabled={scanning}
-                                    class="px-3 py-2 text-sm bg-gray-100 hover:bg-gray-200 disabled:opacity-50 border border-gray-300 rounded-md"
-                                >
-                                    {scanning ? 'Scanning...' : 'Scan'}
-                                </button>
-                            </div>
-                        </div>
-
-                        {#if scanError}
-                            <p class="text-xs text-red-600">{scanError}</p>
-                        {/if}
-
-                        {#if scanResults.length > 0}
-                            <div
-                                class="border border-gray-200 rounded-md max-h-40 overflow-y-auto divide-y divide-gray-200"
-                            >
-                                {#each scanResults as network}
-                                    <button
-                                        type="button"
-                                        class="w-full px-3 py-2 text-left text-sm hover:bg-gray-50 flex justify-between"
-                                        onclick={() => select_network(network)}
-                                    >
-                                        <span>{network.ssid}</span>
-                                        <span class="text-gray-400"
-                                            >{network.signal_dbm} dBm &middot; {network.security}</span
-                                        >
-                                    </button>
-                                {/each}
-                            </div>
-                        {/if}
-
-                        {#if config.wifi_ssid}
-                            <div>
-                                <label
-                                    for="wifi_security"
-                                    class="block text-sm font-medium text-gray-700 mb-1"
-                                >
-                                    Security Type
-                                </label>
-                                <select
-                                    id="wifi_security"
-                                    bind:value={config.wifi_security}
-                                    class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                                >
-                                    <option value="wpa_psk">WPA2 (WPA-PSK)</option>
-                                    <option value="sae">WPA3 (SAE)</option>
-                                </select>
-                            </div>
-                        {/if}
-
-                        <div>
-                            <label
-                                for="wifi_password"
-                                class="block text-sm font-medium text-gray-700 mb-1"
-                            >
-                                WiFi Password
-                            </label>
-                            <input
-                                id="wifi_password"
-                                type="password"
-                                bind:value={config.wifi_password}
-                                placeholder="Enter password"
-                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                            />
-                            <p class="text-xs text-gray-500 mt-1">
-                                Changing the network requires re-entering the password.
-                            </p>
-                        </div>
-
-                        {#if config.wifi_ssid}
-                            <div>
-                                <label
-                                    for="dns_servers"
-                                    class="block text-sm font-medium text-gray-700 mb-1"
-                                >
-                                    DNS Servers
-                                </label>
-                                <input
-                                    id="dns_servers"
-                                    type="text"
-                                    bind:value={dnsServersInput}
-                                    placeholder="9.9.9.9, 149.112.112.112"
-                                    class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                                />
-                                <p class="text-xs text-gray-500 mt-1">
-                                    Comma-separated. Used when WiFi is active. Defaults to 9.9.9.9,
-                                    149.112.112.112 (Quad9).
-                                </p>
-                            </div>
-                        {/if}
-                    </div>
-                {/if}
-
-                <div class="border-t border-gray-200 pt-4 mt-6 space-y-3">
-                    <h3 class="text-lg font-semibold text-gray-800 mb-4">Device Security</h3>
-
-                    <div class="flex items-center">
-                        <input
-                            id="firewall_restrict_outbound"
-                            type="checkbox"
-                            bind:checked={config.firewall_restrict_outbound}
-                            class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
-                        />
-                        <label
-                            for="firewall_restrict_outbound"
-                            class="ml-2 block text-sm text-gray-700"
-                        >
-                            Restrict outbound traffic
-                        </label>
-                    </div>
-                    <p class="text-xs text-gray-500">
-                        Only allows DNS, DHCP, and HTTPS (port 443) outbound. Blocks all other
-                        outbound connections on every interface (WiFi and cellular). Loopback and
-                        hotspot traffic are always allowed. Changes take effect immediately.
-                    </p>
-
-                    {#if config.firewall_restrict_outbound}
-                        <div>
-                            <label
-                                for="firewall_allowed_ports"
-                                class="block text-sm font-medium text-gray-700 mb-1"
-                            >
-                                Additional Allowed Ports
-                            </label>
-                            <input
-                                id="firewall_allowed_ports"
-                                type="text"
-                                value={config.firewall_allowed_ports
-                                    ? config.firewall_allowed_ports.join(', ')
-                                    : ''}
-                                oninput={(e) => {
-                                    const val = (e.target as HTMLInputElement).value.trim();
-                                    config!.firewall_allowed_ports =
-                                        val.length > 0
-                                            ? val
-                                                  .split(',')
-                                                  .map((s) => parseInt(s.trim()))
-                                                  .filter((n) => !isNaN(n) && n >= 1 && n <= 65535)
-                                            : null;
-                                }}
-                                placeholder="22, 80"
-                                class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                            />
-                            <p class="text-xs text-gray-500 mt-1">
-                                Comma-separated TCP ports, e.g. 22, 80
-                            </p>
-                        </div>
-                    {/if}
-                </div>
-
-                <div class="border-t border-gray-200 pt-4 mt-6">
+                <div class="border-t pt-4 mt-6">
                     <h3 class="text-lg font-semibold text-gray-800 mb-4">
                         Analyzer Heuristic Settings
                     </h3>
@@ -567,7 +147,7 @@
                                 id="imsi_requested"
                                 type="checkbox"
                                 bind:checked={config.analyzers.imsi_requested}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label for="imsi_requested" class="ml-2 block text-sm text-gray-700">
                                 IMSI Requested Heuristic
@@ -579,7 +159,7 @@
                                 id="connection_redirect_2g_downgrade"
                                 type="checkbox"
                                 bind:checked={config.analyzers.connection_redirect_2g_downgrade}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label
                                 for="connection_redirect_2g_downgrade"
@@ -594,7 +174,7 @@
                                 id="lte_sib6_and_7_downgrade"
                                 type="checkbox"
                                 bind:checked={config.analyzers.lte_sib6_and_7_downgrade}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label
                                 for="lte_sib6_and_7_downgrade"
@@ -609,7 +189,7 @@
                                 id="null_cipher"
                                 type="checkbox"
                                 bind:checked={config.analyzers.null_cipher}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label for="null_cipher" class="ml-2 block text-sm text-gray-700">
                                 Null Cipher Heuristic
@@ -621,7 +201,7 @@
                                 id="nas_null_cipher"
                                 type="checkbox"
                                 bind:checked={config.analyzers.nas_null_cipher}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label for="nas_null_cipher" class="ml-2 block text-sm text-gray-700">
                                 NAS Null Cipher Heuristic
@@ -633,7 +213,7 @@
                                 id="incomplete_sib"
                                 type="checkbox"
                                 bind:checked={config.analyzers.incomplete_sib}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label for="incomplete_sib" class="ml-2 block text-sm text-gray-700">
                                 Incomplete SIB Heuristic
@@ -645,24 +225,10 @@
                                 id="test_analyzer"
                                 type="checkbox"
                                 bind:checked={config.analyzers.test_analyzer}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
+                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded"
                             />
                             <label for="test_analyzer" class="ml-2 block text-sm text-gray-700">
-                                Test Heuristic (noisy!)
-                            </label>
-                        </div>
-                        <div class="flex items-center">
-                            <input
-                                id="diagnostic_analyzer"
-                                type="checkbox"
-                                bind:checked={config.analyzers.diagnostic_analyzer}
-                                class="h-4 w-4 text-rayhunter-blue focus:ring-rayhunter-blue border-gray-300 rounded-sm"
-                            />
-                            <label
-                                for="diagnostic_analyzer"
-                                class="ml-2 block text-sm text-gray-700"
-                            >
-                                Diagnostic Analyzer
+                                Test Heuristic (noisey!)
                             </label>
                         </div>
                     </div>
@@ -700,7 +266,7 @@
             </form>
             {#if message}
                 <div
-                    class="mt-4 p-3 rounded-sm {messageType === 'error'
+                    class="mt-4 p-3 rounded {messageType === 'error'
                         ? 'bg-red-100 text-red-700'
                         : 'bg-green-100 text-green-700'}"
                 >
@@ -712,5 +278,5 @@
                 Failed to load configuration. Please try reloading the page.
             </div>
         {/if}
-    </div>
-</Modal>
+    {/if}
+</div>

daemon/web/src/lib/components/DeleteAllButton.svelte

@@ -5,8 +5,8 @@
 <div class="flex flex-row justify-end gap-2">
     <DeleteButton
         text="Delete ALL Recordings"
-        prompt="Are you sure you want to delete ALL recordings?"
-        url="/api/delete-all-recordings"
+        prompt={`Are you sure you want to delete ALL recordings?`}
+        url={`/api/delete-all-recordings`}
         name="all recodings"
     />
 </div>

daemon/web/src/lib/components/DeleteButton.svelte

@@ -12,7 +12,7 @@
         name: string;
     } = $props();
 
-    function confirm_delete() {
+    function confirmDelete() {
         if (window.confirm(prompt)) {
             user_action_req('POST', url, 'Unable to delete recording ' + name);
         }
@@ -21,7 +21,7 @@
 
 <button
     class="bg-red-500 hover:bg-red-700 text-white font-bold py-2 px-2 sm:px-4 rounded-md flex flex-row"
-    onclick={confirm_delete}
+    onclick={confirmDelete}
     aria-label="delete"
 >
     <p>{text}</p>

daemon/web/src/lib/components/LogView.svelte

@@ -1,13 +1,34 @@
 <script lang="ts">
     import { get_logs } from '$lib/utils.svelte';
-    import Modal from './Modal.svelte';
+    import { onMount } from 'svelte';
 
     let { shown = $bindable() }: { shown: boolean } = $props();
     let content: string | undefined = $state(undefined);
 
+    onMount(() => {
+        // Used by LogView modal
+        window.addEventListener('scroll', () => {
+            document.documentElement.style.setProperty('--scroll-y', `${window.scrollY}px`);
+        });
+    });
+
     $effect(() => {
+        if (shown) {
+            const scrollY = document.documentElement.style.getPropertyValue('--scroll-y');
+            const body = document.body;
+            body.style.position = 'fixed';
+            body.style.top = `-${scrollY}`;
+        } else {
+            const body = document.body;
+            const scrollY = body.style.top;
+            body.style.position = '';
+            body.style.top = '';
+            window.scrollTo(0, parseInt(scrollY || '0') * -1);
+        }
+
         const interval = setInterval(async () => {
             try {
+                // Don't update UI if browser tab isn't visible
                 if (content !== undefined && (document.hidden || !shown)) {
                     return;
                 }
@@ -21,8 +42,33 @@
     });
 </script>
 
-<Modal bind:shown title="Logs">
-    <div class="bg-gray-100 border border-gray-100 rounded-md overflow-scroll">
-        <pre class="m-2">{content}</pre>
+{#if shown}
+    <div
+        class="fixed left-5 right-5 top-5 bottom-5 z-50 bg-white border border-white rounded-md
+		flex flex-col p-2 drop-shadow"
+    >
+        <div class="flex h-20 justify-between items-center p-1">
+            <span class="text-2xl mb-2">Log</span>
+            <button onclick={() => (shown = false)} aria-label="close">
+                <svg
+                    xmlns="http://www.w3.org/2000/svg"
+                    aria-hidden="true"
+                    width="24"
+                    height="24"
+                    fill="currentColor"
+                    viewBox="0 0 24 24"
+                >
+                    <path
+                        fill-rule="evenodd"
+                        clip-rule="evenodd"
+                        d="M5.29289 5.29289C5.68342 4.90237 6.31658 4.90237 6.70711 5.29289L12 10.5858L17.2929 5.29289C17.6834 4.90237 18.3166 4.90237 18.7071 5.29289C19.0976 5.68342 19.0976 6.31658 18.7071 6.70711L13.4142 12L18.7071 17.2929C19.0976 17.6834 19.0976 18.3166 18.7071 18.7071C18.3166 19.0976 17.6834 19.0976 17.2929 18.7071L12 13.4142L6.70711 18.7071C6.31658 19.0976 5.68342 19.0976 5.29289 18.7071C4.90237 18.3166 4.90237 17.6834 5.29289 17.2929L10.5858 12L5.29289 6.70711C4.90237 6.31658 4.90237 5.68342 5.29289 5.29289Z"
+                        fill="#0F1729"
+                    />
+                </svg>
+            </button>
+        </div>
+        <div class="bg-gray-100 border border-gray-100 rounded-md overflow-scroll">
+            <pre class="m-2">{content}</pre>
+        </div>
     </div>
-</Modal>
+{/if}

daemon/web/src/lib/components/ManifestCard.svelte

@@ -44,7 +44,7 @@
 </script>
 
 <div
-    class="{status_row_color} {status_border_color} drop-shadow-sm p-4 flex flex-col gap-2 border rounded-md flex-1 overflow-x-auto overflow-y-hidden"
+    class="{status_row_color} {status_border_color} drop-shadow p-4 flex flex-col gap-2 border rounded-md flex-1 overflow-x-scroll overflow-y-hidden"
 >
     {#if current}
         <div class="flex flex-row justify-between gap-2">
@@ -81,12 +81,7 @@
                 'N/A'}</span
         >
     </div>
-    {#if entry.stop_reason}
-        <div class="bg-yellow-50 border border-yellow-300 rounded-sm p-2 text-yellow-800 text-sm">
-            {entry.stop_reason}
-        </div>
-    {/if}
-    <div class="flex flex-row justify-between lg:justify-end gap-1 mt-2 overflow-x-auto">
+    <div class="flex flex-row justify-between lg:justify-end gap-1 mt-2 overflow-x-scroll">
         <DownloadLink url={entry.get_pcap_url()} text="pcap" full_button />
         <DownloadLink url={entry.get_qmdl_url()} text="qmdl" full_button />
         <DownloadLink url={entry.get_zip_url()} text="zip" full_button />
@@ -100,7 +95,7 @@
             />
         {/if}
     </div>
-    <div class="border-b border-gray-200 {analysis_visible ? '' : 'hidden'}">
+    <div class="border-b {analysis_visible ? '' : 'hidden'}">
         <AnalysisView {entry} {manager} {current} />
     </div>
 </div>

daemon/web/src/lib/components/ManifestTable.svelte

@@ -1,7 +1,6 @@
 <script lang="ts">
     import { ManifestEntry } from '$lib/manifest.svelte';
     import { AnalysisManager } from '$lib/analysisManager.svelte';
-    import { screenIsLgUp } from '$lib/stores/breakpoint';
     import TableRow from './ManifestTableRow.svelte';
     import Card from './ManifestCard.svelte';
     interface Props {
@@ -13,30 +12,27 @@
 </script>
 
 <!--For larger screens we use a table-->
-{#if $screenIsLgUp}
-    <table class="table-auto text-left table">
-        <thead>
-            <tr class="bg-gray-100 drop-shadow-sm">
-                <th class="p-2" scope="col">ID</th>
-                <th class="p-2" scope="col">Started</th>
-                <th class="p-2" scope="col">Last Message</th>
-                <th class="p-2" scope="col">Size</th>
-                <th class="p-2" scope="col">Download</th>
-                <th class="p-2" scope="col">Analysis</th>
-                <th class="p-2" scope="col"></th>
-            </tr>
-        </thead>
-        <tbody>
-            {#each entries as entry, i}
-                <TableRow {entry} current={false} {i} {manager} />
-            {/each}
-        </tbody>
-    </table>
-{:else}
-    <!--For smaller screens we use cards-->
-    <div class="flex flex-col gap-4">
-        {#each entries as entry}
-            <Card {entry} current={false} {server_is_recording} {manager} />
+<table class="hidden table-auto text-left lg:table">
+    <thead>
+        <tr class="bg-gray-100 drop-shadow">
+            <th class="p-2" scope="col">ID</th>
+            <th class="p-2" scope="col">Started</th>
+            <th class="p-2" scope="col">Last Message</th>
+            <th class="p-2" scope="col">Size</th>
+            <th class="p-2" scope="col">Download</th>
+            <th class="p-2" scope="col">Analysis</th>
+            <th class="p-2" scope="col"></th>
+        </tr>
+    </thead>
+    <tbody>
+        {#each entries as entry, i}
+            <TableRow {entry} current={false} {i} {manager} />
         {/each}
-    </div>
-{/if}
+    </tbody>
+</table>
+<!--For smaller screens we use cards-->
+<div class="lg:hidden flex flex-col gap-4">
+    {#each entries as entry}
+        <Card {entry} current={false} {server_is_recording} {manager} />
+    {/each}
+</div>

daemon/web/src/lib/components/ManifestTableRow.svelte

@@ -36,7 +36,7 @@
     }
 </script>
 
-<tr class="{status_row_color} drop-shadow-sm">
+<tr class="{status_row_color} drop-shadow">
     <td class="p-2">{entry.name}</td>
     <td class="p-2">{date_formatter.format(entry.start_time)}</td>
     <td class="p-2"
@@ -65,8 +65,8 @@
         </td>
     {/if}
 </tr>
-<tr class="{alternating_row_color} border-b border-gray-200 {analysis_visible ? '' : 'hidden'}">
-    <td class="border-t border-gray-200 border-dashed p-2" colspan="9">
+<tr class="{alternating_row_color} border-b {analysis_visible ? '' : 'hidden'}">
+    <td class="border-t border-dashed p-2" colspan="9">
         <AnalysisView {entry} {manager} {current} />
     </td>
 </tr>

daemon/web/src/lib/components/Modal.svelte

@@ -1,64 +0,0 @@
-<script lang="ts">
-    import type { Snippet } from 'svelte';
-    import { onMount } from 'svelte';
-
-    let {
-        shown = $bindable(),
-        title,
-        children,
-    }: { shown: boolean; title: string; children: Snippet } = $props();
-
-    onMount(() => {
-        const handler = () => {
-            document.documentElement.style.setProperty('--scroll-y', `${window.scrollY}px`);
-        };
-        window.addEventListener('scroll', handler);
-        return () => window.removeEventListener('scroll', handler);
-    });
-
-    $effect(() => {
-        if (shown) {
-            const scrollY = document.documentElement.style.getPropertyValue('--scroll-y');
-            const body = document.body;
-            body.style.position = 'fixed';
-            body.style.top = `-${scrollY}`;
-        } else {
-            const body = document.body;
-            const scrollY = body.style.top;
-            body.style.position = '';
-            body.style.top = '';
-            window.scrollTo(0, parseInt(scrollY || '0') * -1);
-        }
-    });
-</script>
-
-{#if shown}
-    <div
-        class="fixed left-5 right-5 top-5 bottom-5 z-50 bg-white border border-white rounded-md
-		flex flex-col p-2 drop-shadow-sm"
-    >
-        <div class="flex justify-between items-center p-1">
-            <span class="text-2xl">{title}</span>
-            <button onclick={() => (shown = false)} aria-label="close">
-                <svg
-                    xmlns="http://www.w3.org/2000/svg"
-                    aria-hidden="true"
-                    width="24"
-                    height="24"
-                    fill="currentColor"
-                    viewBox="0 0 24 24"
-                >
-                    <path
-                        fill-rule="evenodd"
-                        clip-rule="evenodd"
-                        d="M5.29289 5.29289C5.68342 4.90237 6.31658 4.90237 6.70711 5.29289L12 10.5858L17.2929 5.29289C17.6834 4.90237 18.3166 4.90237 18.7071 5.29289C19.0976 5.68342 19.0976 6.31658 18.7071 6.70711L13.4142 12L18.7071 17.2929C19.0976 17.6834 19.0976 18.3166 18.7071 18.7071C18.3166 19.0976 17.6834 19.0976 17.2929 18.7071L12 13.4142L6.70711 18.7071C6.31658 19.0976 5.68342 19.0976 5.29289 18.7071C4.90237 18.3166 4.90237 17.6834 5.29289 17.2929L10.5858 12L5.29289 6.70711C4.90237 6.31658 4.90237 5.68342 5.29289 5.29289Z"
-                        fill="#0F1729"
-                    />
-                </svg>
-            </button>
-        </div>
-        <div class="overflow-y-auto flex-1">
-            {@render children()}
-        </div>
-    </div>
-{/if}

daemon/web/src/lib/components/ReAnalyzeButton.svelte

@@ -19,7 +19,7 @@
         analysis_status === AnalysisStatus.Queued || analysis_status === AnalysisStatus.Running
     );
 
-    async function handle_re_analyze() {
+    async function handleReAnalyze() {
         // Update the entry directly for immediate UI feedback
         entry.analysis_status = AnalysisStatus.Queued;
         entry.analysis_report = undefined;
@@ -33,7 +33,7 @@
     loadingLabel="Analyzing..."
     disabled={is_processing}
     variant="blue"
-    onclick={handle_re_analyze}
+    onclick={handleReAnalyze}
     ariaLabel="re-analyze"
     errorMessage="Error re-analyzing recoding"
 >

daemon/web/src/lib/components/SystemStatsTable.svelte

@@ -6,7 +6,7 @@
         stats: SystemStats;
     } = $props();
 
-    const table_cell_classes = 'border border-gray-200 p-1 lg:p-2';
+    const table_cell_classes = 'border p-1 lg:p-2';
 
     let battery_level = $derived(stats.battery_status ? stats.battery_status.level : 0);
     let bar_color = $derived.by(() => {
@@ -36,29 +36,29 @@
 </script>
 
 <div
-    class="flex-1 drop-shadow-sm p-4 flex flex-col gap-2 border rounded-md bg-gray-100 border-gray-100"
+    class="flex-1 drop-shadow p-4 flex flex-col gap-2 border rounded-md bg-gray-100 border-gray-100"
 >
     <p class="text-xl mb-2">System Information</p>
-    <table class="table-auto border border-gray-200">
+    <table class="table-auto border">
         <tbody>
-            <tr class="border border-gray-200">
+            <tr class="border">
                 <th class={table_cell_classes}> Rayhunter Version </th>
                 <td class={table_cell_classes}>{stats.runtime_metadata.rayhunter_version}</td>
             </tr>
-            <tr class="border border-gray-200">
+            <tr class="border">
                 <th class={table_cell_classes}> Storage </th>
                 <td class={table_cell_classes}>
                     {stats.disk_stats.used_percent} used ({stats.disk_stats.used_size} used / {stats
                         .disk_stats.available_size} available)
                 </td>
             </tr>
-            <tr class="border-b border-gray-200">
+            <tr class="border-b">
                 <th class={table_cell_classes}> Memory (RAM) </th>
                 <td class={table_cell_classes}>
                     Free: {stats.memory_stats.free}, Used: {stats.memory_stats.used}
                 </td>
             </tr>
-            <tr class="border-b border-gray-200">
+            <tr class="border-b">
                 <th class={table_cell_classes}> Battery </th>
                 <td class={table_cell_classes}>
                     <svg

daemon/web/src/lib/manifest.svelte.ts

@@ -11,7 +11,6 @@ interface JsonManifestEntry {
     start_time: string;
     last_message_time: string;
     qmdl_size_bytes: number;
-    stop_reason: string | null;
 }
 
 export class Manifest {
@@ -58,7 +57,6 @@ export class ManifestEntry {
     public analysis_size_bytes = $state(0);
     public analysis_status: AnalysisStatus | undefined = $state(undefined);
     public analysis_report: AnalysisReport | string | undefined = $state(undefined);
-    public stop_reason: string | undefined = $state(undefined);
 
     constructor(json: JsonManifestEntry) {
         this.name = json.name;
@@ -67,9 +65,6 @@ export class ManifestEntry {
         if (json.last_message_time) {
             this.last_message_time = new Date(json.last_message_time);
         }
-        if (json.stop_reason) {
-            this.stop_reason = json.stop_reason;
-        }
     }
 
     get_readable_qmdl_size(): string {

daemon/web/src/lib/ndjson.ts

@@ -19,9 +19,7 @@ export function parse_ndjson(input: string): NewlineDeliminatedJson {
             // however, if we've reached the end of the input, that means we
             // were given invalid nd-json
             if (lines.length === 0) {
-                throw new Error(`unable to parse invalid nd-json: ${e}, "${current_line}"`, {
-                    cause: e,
-                });
+                throw new Error(`unable to parse invalid nd-json: ${e}, "${current_line}"`);
             }
         }
     }

daemon/web/src/lib/stores/breakpoint.ts

@@ -1,29 +0,0 @@
-// stores/breakpoint.ts
-import { readable, type Readable } from 'svelte/store';
-import { breakpoints } from '../../theme';
-
-type Breakpoint = keyof typeof breakpoints;
-
-// Store that tracks if a specific breakpoint matches
-export function create_breakpoint_store(breakpoint: Breakpoint): Readable<boolean> {
-    return readable<boolean>(false, (set) => {
-        const width = breakpoints[breakpoint];
-        const mediaQuery = window.matchMedia(`(min-width: ${width})`);
-
-        // Set initial value
-        set(mediaQuery.matches);
-
-        // Update on change
-        const handler = (e: MediaQueryListEvent) => set(e.matches);
-        mediaQuery.addEventListener('change', handler);
-
-        // Cleanup
-        return () => mediaQuery.removeEventListener('change', handler);
-    });
-}
-
-// Create stores for each breakpoint
-export const screenIsSmUp: Readable<boolean> = create_breakpoint_store('sm');
-export const screenIsMdUp: Readable<boolean> = create_breakpoint_store('md');
-export const screenIsLgUp: Readable<boolean> = create_breakpoint_store('lg');
-export const screenIsXlUp: Readable<boolean> = create_breakpoint_store('xl');

daemon/web/src/lib/systemStats.ts

@@ -18,7 +18,6 @@ export interface DiskStats {
     available_size: string;
     used_percent: string;
     mounted_on: string;
-    available_bytes?: number;
 }
 
 export interface MemoryStats {

daemon/web/src/lib/utils.svelte.ts

@@ -10,66 +10,25 @@ export interface AnalyzerConfig {
     nas_null_cipher: boolean;
     incomplete_sib: boolean;
     test_analyzer: boolean;
-    diagnostic_analyzer: boolean;
-}
-
-export enum enabled_notifications {
-    Warning = 'Warning',
-    LowBattery = 'LowBattery',
 }
 
 export interface Config {
-    device: string;
     ui_level: number;
     colorblind_mode: boolean;
     key_input_mode: number;
     ntfy_url: string;
-    enabled_notifications: enabled_notifications[];
     analyzers: AnalyzerConfig;
-    min_space_to_start_recording_mb: number;
-    min_space_to_continue_recording_mb: number;
-    wifi_ssid: string | null;
-    wifi_password: string | null;
-    wifi_security: 'wpa_psk' | 'sae' | null;
-    wifi_enabled: boolean;
-    dns_servers: string[] | null;
-    firewall_restrict_outbound: boolean;
-    firewall_allowed_ports: number[] | null;
 }
 
-export interface WifiStatus {
-    state: string;
-    ssid?: string;
-    ip?: string;
-    error?: string;
-}
-
-export interface WifiNetwork {
-    ssid: string;
-    signal_dbm: number;
-    security: string;
-}
-
-export async function get_wifi_status(): Promise<WifiStatus> {
-    return JSON.parse(await req('GET', '/api/wifi-status'));
-}
-
-export async function scan_wifi_networks(): Promise<WifiNetwork[]> {
-    return JSON.parse(await req('POST', '/api/wifi-scan'));
-}
-
-export async function req(method: string, url: string, json_body?: unknown): Promise<string> {
-    const options: RequestInit = { method };
-    if (json_body !== undefined) {
-        options.body = JSON.stringify(json_body);
-        options.headers = { 'Content-Type': 'application/json' };
-    }
-    const response = await fetch(url, options);
-    const responseBody = await response.text();
+export async function req(method: string, url: string): Promise<string> {
+    const response = await fetch(url, {
+        method: method,
+    });
+    const body = await response.text();
     if (response.status >= 200 && response.status < 300) {
-        return responseBody;
+        return body;
     } else {
-        throw new Error(responseBody);
+        throw new Error(body);
     }
 }
 
@@ -77,13 +36,13 @@ export async function req(method: string, url: string, json_body?: unknown): Pro
 export async function user_action_req(
     method: string,
     url: string,
-    error_msg: string,
-    json_body?: unknown
+    error_msg: string
 ): Promise<string | undefined> {
     try {
-        return await req(method, url, json_body);
+        return await req(method, url);
     } catch (error) {
         if (error instanceof Error) {
+            console.log('beeeo');
             add_error(error, error_msg);
         }
         return undefined;
@@ -121,24 +80,3 @@ export async function set_config(config: Config): Promise<void> {
         throw new Error(error);
     }
 }
-
-export async function test_notification(): Promise<void> {
-    const response = await fetch('/api/test-notification', {
-        method: 'POST',
-    });
-
-    if (!response.ok) {
-        const error = await response.text();
-        throw new Error(error);
-    }
-}
-
-export interface TimeResponse {
-    system_time: string;
-    adjusted_time: string;
-    offset_seconds: number;
-}
-
-export async function get_daemon_time(): Promise<TimeResponse> {
-    return JSON.parse(await req('GET', '/api/time'));
-}

daemon/web/src/routes/+page.svelte

@@ -10,18 +10,15 @@
     import RecordingControls from '$lib/components/RecordingControls.svelte';
     import ConfigForm from '$lib/components/ConfigForm.svelte';
     import ActionErrors from '$lib/components/ActionErrors.svelte';
-    import ClockDriftAlert from '$lib/components/ClockDriftAlert.svelte';
     import LogView from '$lib/components/LogView.svelte';
 
     let manager: AnalysisManager = new AnalysisManager();
     let loaded = $state(false);
-    let filter_threshold: boolean = $state(false);
     let entries: ManifestEntry[] = $state([]);
     let current_entry: ManifestEntry | undefined = $state(undefined);
     let system_stats: SystemStats | undefined = $state(undefined);
     let update_error: string | undefined = $state(undefined);
     let logview_shown: boolean = $state(false);
-    let config_shown: boolean = $state(false);
     $effect(() => {
         const interval = setInterval(async () => {
             try {
@@ -33,10 +30,7 @@
                 await manager.update();
                 let new_manifest = await get_manifest();
                 await new_manifest.set_analysis_status(manager);
-                entries = filter_threshold
-                    ? new_manifest.entries.filter((e) => e.get_num_warnings())
-                    : new_manifest.entries;
-
+                entries = new_manifest.entries;
                 current_entry = new_manifest.current_entry;
 
                 system_stats = await get_system_stats();
@@ -56,10 +50,7 @@
 </script>
 
 <LogView bind:shown={logview_shown} />
-<ConfigForm bind:shown={config_shown} />
-<div
-    class="p-4 xl:px-8 bg-rayhunter-blue drop-shadow-sm flex flex-row justify-between items-center"
->
+<div class="p-4 xl:px-8 bg-rayhunter-blue drop-shadow flex flex-row justify-between items-center">
     <!-- https://www.w3.org/WAI/tutorials/images/decorative/ -->
     <img src="/rayhunter_text.png" alt="" class="h-10 xl:h-12" />
     <div class="flex flex-row gap-4">
@@ -107,34 +98,6 @@
                 />
             </svg>
         </button>
-        <button onclick={() => (config_shown = true)} class="flex flex-row gap-1 group">
-            <span class="hidden text-white group-hover:text-gray-400 lg:flex">Config</span>
-            <svg
-                class="w-6 h-6 text-white group-hover:text-gray-400"
-                aria-hidden="true"
-                xmlns="http://www.w3.org/2000/svg"
-                width="24"
-                height="24"
-                fill="none"
-                viewBox="0 0 24 24"
-            >
-                <path
-                    stroke="currentColor"
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    stroke-width="2"
-                    d="M21 13v-2a1 1 0 0 0-1-1h-.757l-.707-1.707.535-.536a1 1 0 0 0 0-1.414l-1.414-1.414a1 1 0 0 0-1.414 0l-.536.535L14 5.757V5a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v.757L8.293 6.464l-.536-.535a1 1 0 0 0-1.414 0L4.929 7.343a1 1 0 0 0 0 1.414l.535.536L4.757 11H4a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h.757l.707 1.707-.535.536a1 1 0 0 0 0 1.414l1.414 1.414a1 1 0 0 0 1.414 0l.536-.535L10 18.243V19a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-.757l1.707-.707.536.535a1 1 0 0 0 1.414 0l1.414-1.414a1 1 0 0 0 0-1.414l-.535-.536.707-1.707H20a1 1 0 0 0 1-1Z"
-                />
-                <path
-                    stroke="currentColor"
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    stroke-width="2"
-                    d="M12 15a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z"
-                />
-            </svg>
-        </button>
-        <div class="w-px bg-white/30 self-stretch"></div>
         <a
             class="flex flex-row gap-1 group"
             href="https://github.com/EFForg/rayhunter/issues"
@@ -181,32 +144,12 @@
                 />
             </svg>
         </a>
-        <a
-            class="flex flex-row gap-1 group"
-            href="https://supporters.eff.org/donate"
-            target="_blank"
-        >
-            <span class="hidden text-white group-hover:text-gray-400 lg:flex">Donate</span>
-            <svg
-                class="w-6 h-6 text-white group-hover:text-gray-400"
-                aria-hidden="true"
-                xmlns="http://www.w3.org/2000/svg"
-                width="24"
-                height="24"
-                fill="currentColor"
-                viewBox="0 0 24 24"
-            >
-                <path
-                    d="m12.75 20.66 6.184-7.098c2.677-2.884 2.559-6.506.754-8.705-.898-1.095-2.206-1.816-3.72-1.855-1.293-.034-2.652.43-3.963 1.537-1.31-1.108-2.67-1.571-3.962-1.537-1.515.04-2.823.76-3.72 1.855-1.806 2.2-1.924 5.821.753 8.705l6.184 7.098.245.281a.75.75 0 0 0 1.09 0l.246-.281Z"
-                />
-            </svg>
-        </a>
     </div>
 </div>
 <div class="m-4 xl:mx-8 flex flex-col gap-4">
     {#if update_error !== undefined}
         <div
-            class="bg-red-100 border-red-100 drop-shadow-sm p-4 flex flex-col gap-2 border rounded-md flex-1 justify-between"
+            class="bg-red-100 border-red-100 drop-shadow p-4 flex flex-col gap-2 border rounded-md flex-1 justify-between"
         >
             <span class="text-2xl font-bold mb-2 flex flex-row items-center gap-2 text-red-600">
                 <svg
@@ -228,7 +171,7 @@
             </span>
             <span
                 >This webpage is not currently receiving updates from your Rayhunter device. This
-                could be due to loss of connection or some issue with your device.</span
+                could be do loss of connection or some issue with your device.</span
             >
             {#if update_error}
                 <details>
@@ -239,7 +182,6 @@
         </div>
     {/if}
     <ActionErrors />
-    <ClockDriftAlert />
     {#if loaded}
         <div class="flex flex-col lg:flex-row gap-4">
             {#if current_entry}
@@ -251,7 +193,7 @@
                 />
             {:else}
                 <div
-                    class="bg-red-100 border-red-100 drop-shadow-sm p-4 flex flex-col gap-2 border rounded-md flex-1 justify-between"
+                    class="bg-red-100 border-red-100 drop-shadow p-4 flex flex-col gap-2 border rounded-md flex-1 justify-between"
                 >
                     <span
                         class="text-2xl font-bold mb-2 flex flex-row items-center gap-2 text-red-600"
@@ -284,26 +226,11 @@
             <SystemStatsTable stats={system_stats!} />
         </div>
         <div class="flex flex-col gap-2">
-            <div class="flex flex-row gap-2">
-                <div class="text-xl flex-1">History</div>
-                <div class="flex flex-row items-center gap-2 px-3">
-                    <label
-                        for="filter_threshold"
-                        class="block text-md font-medium text-gray-700 mb-1"
-                    >
-                        Filter for Warnings
-                    </label>
-                    <input
-                        type="checkbox"
-                        id="filter_threshold"
-                        bind:checked={filter_threshold}
-                        class="px-3 py-2 border border-gray-300 rounded-md focus:outline-hidden focus:ring-2 focus:ring-rayhunter-blue"
-                    />
-                </div>
-            </div>
+            <span class="text-xl">History</span>
             <ManifestTable {entries} server_is_recording={!!current_entry} {manager} />
         </div>
         <DeleteAllButton />
+        <ConfigForm />
     {:else}
         <div class="flex flex-col justify-center items-center">
             <!-- https://www.w3.org/WAI/tutorials/images/decorative/ -->

daemon/web/src/theme.ts

@@ -1,11 +0,0 @@
-/** These are the default Tailwind CSS breakpoints.
- * We're defining them here so they can be referenced
- * programmatically in other parts of the application.
- */
-export const breakpoints = {
-    sm: '640px',
-    md: '768px',
-    lg: '1024px',
-    xl: '1280px',
-    '2xl': '1536px',
-} as const;

daemon/web/tailwind.config.ts

@@ -0,0 +1,17 @@
+import type { Config } from 'tailwindcss';
+
+export default {
+    content: ['./src/**/*.{html,js,svelte,ts}'],
+
+    theme: {
+        extend: {
+            colors: {
+                'rayhunter-blue': '#4e4eb1',
+                'rayhunter-dark-blue': '#3f3da0',
+                'rayhunter-green': '#94ea18',
+            },
+        },
+    },
+
+    plugins: [],
+} as Config;

daemon/web/vite.config.ts

@@ -1,12 +1,11 @@
 import { defineConfig } from 'vitest/config';
 import { sveltekit } from '@sveltejs/kit/vite';
-import tailwindcss from '@tailwindcss/vite';
 
 export default defineConfig({
     server: {
         proxy: {
             '/api': {
-                target: process.env.API_TARGET || 'http://localhost:8080',
+                target: 'http://localhost:8080',
                 changeOrigin: true,
                 secure: false,
                 configure: (proxy, _options) => {
@@ -27,7 +26,7 @@ export default defineConfig({
             },
         },
     },
-    plugins: [tailwindcss(), sveltekit()],
+    plugins: [sveltekit()],
     build: {
         // Force everything into one HTML file. SvelteKit will still generate
         // a lot of JS files but they are deadweight and will not be included

dist/config.toml.in

@@ -12,7 +12,6 @@ colorblind_mode = false
 # 1 = Subtle mode, display a colored line at the top of the screen when rayhunter is running (green=running, white=paused, red=warnings)
 # 2 = Demo Mode, display a fun orca gif
 # 3 = display the EFF logo
-# 4 = High Visibility mode, fill the entire screen with the status color (green=running, white=paused, red=warnings)
 #
 # TP-Link with one-bit display:
 # 0 = invisible mode
@@ -20,65 +19,11 @@ colorblind_mode = false
 ui_level = 1
 
 # 0 = rayhunter does not read button presses
-# 1 = double-tapping the power button starts new recording
+# 1 = double-tapping the power button starts/stops recordings
 key_input_mode = 0
 
 # If set, attempts to send a notification to the url when a new warning is triggered
-# ntfy_url = "https://ntfy.sh/your-topic"
-# What notification types to enable. Does nothing if the above ntfy_url is not set.
-enabled_notifications = ["Warning", "LowBattery"]
-
-# Disk Space Management
-# Minimum free space (MB) required to start recording
-min_space_to_start_recording_mb = 1
-# Minimum free space (MB) to continue recording (stops if below this)
-min_space_to_continue_recording_mb = 1
-
-# WiFi Client Mode
-# Toggle wifi_enabled to connect the device to an existing WiFi network.
-# Credentials are stored separately in wpa_sta.conf and managed via the web UI.
-wifi_enabled = false
-
-# DNS servers to use when WiFi client mode is active.
-# Defaults to ["9.9.9.9", "149.112.112.112"] (Quad9) if not specified.
-# dns_servers = ["9.9.9.9", "149.112.112.112"]
-
-# Device Security
-# Restrict outbound traffic to essential services only (DHCP, DNS,
-# HTTPS, and replies to inbound connections). Applies to all outbound
-# interfaces (WiFi and cellular). Loopback and hotspot bridge traffic
-# are always allowed. Defaults to true (recommended).
-firewall_restrict_outbound = true
-
-# Additional TCP ports to allow outbound when the firewall is active.
-# DHCP (67-68), DNS (53), and HTTPS (443) are always allowed.
-# Example: allow HTTP (80) and SSH (22).
-# firewall_allowed_ports = [80, 22]
-
-# WebDAV Upload
-# If a [webdav] section is present, finished recordings (both the raw .qmdl file
-# and its .ndjson analysis output) are uploaded in the background to a WebDAV
-# server once they've been closed for at least min_age_secs. After a successful
-# upload the entry is either marked as uploaded in the manifest, or deleted
-# locally if delete_on_upload = true. With no [webdav] section, no upload
-# worker runs.
-#
-# [webdav]
-# host = "https://dav.example.com"
-# remote_path = "/rayhunter"
-# # HTTP Basic auth. Both fields are optional; a password without a username is
-# # rejected and the request is sent unauthenticated.
-# username = "user"
-# password = "pass"
-# # Timeout in seconds for each upload request (default 300).
-# upload_timeout_secs = 300
-# # How often the worker scans for eligible entries (default 3600).
-# poll_interval_secs = 3600
-# # Minimum age in seconds before an entry becomes eligible for upload
-# # (default 86400 = 1 day).
-# min_age_secs = 86400
-# # Delete the entry locally after a successful upload (default false).
-# delete_on_upload = false
+# ntfy_url =
 
 # Analyzer Configuration
 # Enable/disable specific IMSI catcher detection heuristics
@@ -90,5 +35,4 @@ lte_sib6_and_7_downgrade = true
 null_cipher = true
 nas_null_cipher = true
 incomplete_sib = true
-test_analyzer = false
-diagnostic_analyzer = true
+test_analyzer = false

dist/scripts/S01iptables

@@ -1,24 +0,0 @@
-#!/bin/sh
-CONFIG="/data/rayhunter/config.toml"
-
-case "$1" in
-  start)
-    if grep -q '^firewall_restrict_outbound = true' "$CONFIG" 2>/dev/null; then
-        iptables -F OUTPUT
-        iptables -A OUTPUT -o lo -j ACCEPT
-        for br in bridge0 br0; do
-            [ -d "/sys/class/net/$br" ] && iptables -A OUTPUT -o "$br" -j ACCEPT
-        done
-        iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
-        iptables -A OUTPUT -p udp --dport 67:68 -j ACCEPT
-        iptables -A OUTPUT -p udp --dport 53 -j ACCEPT
-        iptables -A OUTPUT -p tcp --dport 53 -j ACCEPT
-        iptables -A OUTPUT -j DROP
-        echo 0 > /proc/sys/net/bridge/bridge-nf-call-iptables 2>/dev/null
-    fi
-    ;;
-  stop)
-    iptables -F OUTPUT
-    iptables -P OUTPUT ACCEPT
-    ;;
-esac

doc/SUMMARY.md

@@ -1,10 +1,9 @@
 # Summary
 
-- [Introduction](./introduction.md)
-- [Support, feedback, and community](./support-feedback-community.md)
-- [Frequently Asked Questions](./faq.md)
+[Introduction](./introduction.md)
 - [Installation](./installation.md)
   - [Installing from the latest release](./installing-from-release.md)
+    - [Installing from the latest release (Windows)](./installing-from-release-windows.md)
   - [Installing from source](./installing-from-source.md)
   - [Updating Rayhunter](./updating-rayhunter.md)
 - [Configuration](./configuration.md)
@@ -14,7 +13,6 @@
   - [Re-analyzing recordings](./reanalyzing.md)
   - [How we analyze a capture](./analyzing-a-capture.md)
 - [Supported devices](./supported-devices.md)
-  - [Porting to new devices](./porting.md)
   - [Orbic/Kajeet RC400L](./orbic.md)
   - [TP-Link M7350](./tplink-m7350.md)
   - [TP-Link M7310](./tplink-m7310.md)
@@ -23,4 +21,5 @@
   - [Wingtech CT2MHS01](./wingtech-ct2mhs01.md)
   - [PinePhone and PinePhone Pro](./pinephone.md)
   - [Moxee Hotspot](./moxee.md)
-- [REST API Documentation](./api-docs.md)
+- [Support, feedback, and community](./support-feedback-community.md)
+  - [Frequently Asked Questions](./faq.md)

doc/analyzing-a-capture.md

@@ -1,3 +1,3 @@
 # How we analyze a capture
 
-Teams of highly trained squirrels. Video coming soon!
+Teams of highly trained squirrles. Video coming soon!

doc/api-docs.md

@@ -1,5 +0,0 @@
-# REST API Documentation
-
-The rayhunter daemon has [REST API documentation](./api-docs/) available in the interactive swagger-ui.
-
->**Note:** API endpoints are subject to change as needs arise, though we will try to keep them as stable as possible and notify about breaking changes in the changelogs for new versions.

doc/configuration.md

@@ -7,87 +7,14 @@ Rayhunter can be configured through web user interface or by editing `/data/rayh
 Through web UI you can set:
 - **Device UI Level**, which defines what Rayhunter shows on device's built-in screen. *Device UI Level* could be:
   - *Invisible mode*: Rayhunter does not show anything on the built-in screen
-  - *Subtle mode (colored line)*: Rayhunter shows green line if there are no warnings, red line if there are warnings (warnings could be checked through web UI) and white line if Rayhunter is not recording.
-  - *Demo mode (orca gif)*, which shows image of orcas *and* colored line.
-  - *EFF logo*, which shows EFF logo *and* colored line.
-  - *High visibility (full screen color)*: fills the entire screen with the status color (green for recording, red for warnings, white for paused).
-- **Device Input Mode**, which defines behavior of built-in power button of the device. *Device Input Mode* could be:
-  - *Disable button control*: built-in power button of the device is not used by Rayhunter.
-  - *Double-tap power button to start new recording*: double clicking on a built-in power button of the device stops and immediately restarts the recording. This could be useful if Rayhunter's heuristics is triggered and you get the red line, and you want to "reset" the past warnings. Normally you can do that through web UI, but sometimes it is easier to double tap on power button.
+  - *Subtle mode (colored line)*: Rayhunter shows green line if there are no warnings, red line if there are warnings (warnings could be checked through web UI) and white line if Rayhunter is not recording
+  - *Demo mode (orca gif)*, which shows image of orca fish *and* colored line
+  - *EFF logo*, which shows EFF logo and *and* colored line.
+- **Device Input Mode**, which defines behaviour of built-in power button of the device. *Device Input Mode* could be:
+  - *Disable button control*: built-in power button of the device is not used by Rayhunter;
+  - *Double-tap power button to start/stop recording*: double clicking on a built-in power button of the device stops and immediatelly restarts the recording. This could be useful if Rayhunter's heuristichs is triggered and you get the red line, and you want to "reset" the past warnings. Normally you can do that through web UI, but sometimes it is easier to double tap on power button.
+- **ntfy URL for Sending Notifications**, which allows setting a [ntfy](https://ntfy.sh/) URL to which notifications of new detections will be sent. The topic should be unique to your device, e.g., `https://ntfy.sh/rayhunter_notifications_ba9di7ie` or `https://myserver.example.com/rayhunter_notifications_ba9di7ie`. The ntfy Android and iOS apps can then be used to receive notifications. More information can be found in the [ntfy docs](https://docs.ntfy.sh/).
 - **Colorblind Mode** enables color blind mode (blue line is shown instead of green line, red line remains red). Please note that this does not cover all types of color blindness, but switching green to blue should be about enough to differentiate the color change for most types of color blindness.
-- **ntfy URL**, which allows setting a [ntfy](https://ntfy.sh/) URL to which notifications of new detections will be sent. The topic should be unique to your device, e.g., `https://ntfy.sh/rayhunter_notifications_ba9di7ie` or `https://myserver.example.com/rayhunter_notifications_ba9di7ie`. The ntfy Android and iOS apps can then be used to receive notifications. More information can be found in the [ntfy docs](https://docs.ntfy.sh/).
-- **Enabled Notification Types** allows enabling or disabling the following types of notifications:
-  - *Warnings*, which will alert when a heuristic is triggered. Alerts will be sent at most once every five minutes.
-  - *Low Battery*, which will alert when the device's battery is low. Notifications may not be supported for all devices—you can check if your device is supported by looking at whether the battery level indicator is functioning on the System Information section of the Rayhunter UI.
-- With **Analyzer Heuristic Settings** you can switch on or off built-in [Rayhunter heuristics](heuristics.md). Some heuristics are experimental or can trigger a lot of false positive warnings in some networks (our tests have shown that some heuristics have different behavior in US or European networks). In that case you can decide whether you would like to have the heuristics that trigger a lot of false positives on or off. Please note that we are constantly improving and adding new heuristics, so a new release may reduce false positives in existing heuristics as well.
+- With **Analyzer Heuristic Settings** you can switch on or off built-in [Rayhunter heuristics](heuristics.md). Some heuristics are experimental or can trigger a lot of false positive warnings in some networks (our tests have shown that some heuristics have different behaviour in US or European networks). In that case you can decide whether you would like to have the heuristics that trigger a lot of false positives on or off. Please note that we are constantly improving and adding new heuristics, so new release may reduce false positives in existing heuristics as well.
 
-## WiFi Client Mode
-
-On the **Orbic**, **Moxee**, **UZ801**, **TMOHS1**, and **Wingtech**, Rayhunter can connect the device to an existing WiFi network while keeping the hotspot running. This gives the device internet access for [notifications](https://docs.ntfy.sh/) and lets you reach the web UI from any device on that network.
-
-- **Enable WiFi** turns WiFi client mode on or off. Disabling it does not erase saved credentials.
-- **Scan** searches for nearby networks. Select one from the dropdown, or type an SSID manually.
-- **Password** is required for WPA/WPA2 networks. The password is stored separately from `config.toml` (in `wpa_sta.conf` on the device) and is never exposed through the API.
-- **DNS Servers** lets you override the DNS servers used when connected. Defaults to `9.9.9.9` and `149.112.112.112` (Quad9) if not set.
-
-After saving, the connection status will show **connecting**, **connected** (with the assigned IP address), or **failed** (with an error message). If the connection fails, check that the SSID and password are correct and that the network is in range.
-
-### Crash Recovery
-
-The WiFi kernel module (`wlan.ko`) can occasionally crash or unload, taking both the hotspot and client interfaces down with it. Rayhunter includes a watchdog that detects this and automatically reloads the module, restarts the hotspot, and reconnects to the configured network. During recovery the WiFi status will show **recovering**.
-
-On the first detection of a crash, a diagnostic snapshot is saved to `/data/rayhunter/crash-logs/` on the device. You can pull these logs with `adb pull /data/rayhunter/crash-logs/` and inspect them to understand what went wrong. Each log contains:
-
-- **dmesg** output (kernel messages). Look for backtraces, `BUG:`/`Oops:` lines, or `wlan`/`wcnss` errors. The kernel ring buffer is small and gets overwritten quickly, so crash details may already be gone if the crash happened well before detection.
-- **/proc/modules** snapshot. If `wlan` is absent, the module fully unloaded. If present but interfaces are gone, the driver is stuck.
-- **ip addr** output confirming which network interfaces existed at snapshot time.
-- **ps** output showing which WiFi-related processes (`hostapd`, `wpa_supplicant`, `wland`) were still running.
-
-If recovery fails after 5 attempts, the status will change to **failed**. A reboot of the device will reset WiFi.
-
-You can also configure WiFi during installation:
-
-```sh
-./installer orbic --admin-password 'mypassword' --wifi-ssid 'MyNetwork' --wifi-password 'networkpass'
-```
-
-## Device Security
-
-- **Restrict outbound traffic** limits what the device can send over the network. When enabled, only DNS, DHCP, and HTTPS traffic is allowed; everything else is blocked. This is enabled by default and prevents the device from phoning home to the carrier over cellular. If you need to allow additional ports (for example, port 80 for HTTP or port 22 for SSH), add them to the **Additional allowed ports** list.
-
-## WebDAV Upload
-
-Rayhunter can automatically upload finished recordings to a WebDAV server. When a `[webdav]` section is present in `config.toml`, a background worker periodically scans the recording store and uploads any closed entry that is older than `min_age_secs`. Each eligible entry uploads two files: the raw `.qmdl` capture and its `.ndjson` analysis output. After a successful upload the entry is either marked as uploaded in the manifest (and skipped on subsequent polls), or deleted locally if `delete_on_upload = true`. With no `[webdav]` section, no upload worker runs.
-
-WebDAV upload is currently configurable only by editing `config.toml` — there is no web UI control for it yet.
-
-| Key | Required | Default | Description |
-| --- | --- | --- | --- |
-| `url` | yes | — | WebDAV server base URL, e.g. `https://example.com/remote.php/files/user/rayhunter/` |
-| `username` | no | — | HTTP Basic auth username |
-| `password` | no | — | HTTP Basic auth password |
-| `upload_timeout_secs` | no | `300` | Timeout (seconds) for each upload request |
-| `poll_interval_secs` | no | `3600` | How often (seconds) the worker scans for eligible entries |
-| `min_age_secs` | no | `86400` | Minimum age (seconds) an entry must have before it becomes eligible for upload |
-| `delete_on_upload` | no | `false` | Delete the entry locally after a successful upload |
-
-Example:
-
-```toml
-[webdav]
-url = "https://dav.example.com/rayhunter/"
-username = "user"
-password = "pass"
-upload_timeout_secs = 300
-poll_interval_secs = 3600
-min_age_secs = 86400
-delete_on_upload = false
-```
-
-A few notes on behavior:
-
-- **Auth:** HTTP Basic. Supplying a `password` without a `username` is rejected — the request is sent unauthenticated and a warning is logged.
-- **Retries and overwrites:** each entry's two files (`.qmdl` and `.ndjson`) must both upload successfully before the entry is marked as uploaded in the manifest. If one upload fails, the entry stays unmarked and both files are retried on the next poll — the one that previously succeeded will be overwritten on the server. Once an entry is marked as uploaded, Rayhunter will not upload it again.
-- **Currently-recording entry:** the active recording is never uploaded; only closed entries are eligible.
-
-If you prefer editing `config.toml` file, you need to obtain a shell on your [Orbic](./orbic.md#obtaining-a-shell) or [TP-Link](./tplink-m7350.md#obtaining-a-shell) device and edit the file manually. You can view the [default configuration file on GitHub](https://github.com/EFForg/rayhunter/blob/main/dist/config.toml.in).
+If you prefer editing `config.toml` file, you need to obtain a shell on your [Orbic](./orbic.md#obtaining-a-shell) or [TP-Link](./tplink-m7350.md#obtaining-a-shell) device and edit the file manually. You can view the [default configuration file on a GitHub](https://github.com/EFForg/rayhunter/blob/main/dist/config.toml.in).

doc/custom.css

@@ -1,6 +0,0 @@
-.warning-box {
-    padding: 0.75em 1em;
-    border-left: 4px solid #e33;
-    border-radius: 4px;
-    background-color: color-mix(in srgb, currentColor 10%, transparent);
-}

doc/faq.md

@@ -5,7 +5,7 @@
 **It Depends**. Operation of Rayhunter does require the insertion of a SIM card into the device, but that sim card does not have to be actively registered with a service plan. If you want to use the device as a hotspot in addition to a research device, or get [notifications](./configuration.md), an active plan would of course be necessary.
 
 ### How can I test that my device is working?
-You can enable the `Test Heuristic` under `Analyzer Heuristic Settings` in the config section on your web dashboard. This will cause an alert to trigger every time your device sees a cell tower, you might need to reboot your device or move around a bit to get this one to trigger, but it will be very noisy once it does. People have also tested it by building IMSI catchers at home, but we don't recommend that, since it violates FCC regulations and will probably upset your neighbors.
+You can enable the `Test Heuristic` under `Analyzer Heuristic Settings` in the config section on your web dashboard. This will cause an alert to trigger every time your device sees a cell tower, you might need to reboot your device or move around a bit to get this one to trigger, but it will be very noisey once it does. People have also tested it by building IMSI catchers at home, but we don't reccomend that, since it violates FCC regulations and will probably upset your neighbors.
 
 <a name="red"></a>
 
@@ -22,60 +22,37 @@ Please note that this file may contain sensitive information such as your IMSI a
 
 If you want to use a non-Verizon SIM card you will probably need an unlocked device. But it's not clear which devices are locked nor how to unlock them, we welcome any experimentation and information regarding the use of unlocked devices. So far most verizon branded orbic devices we have encountered are actually unlocked.
 
-### I can't reach my Rayhunter's web UI after leaving it alone for a while
-
-Some hotspots (notably the T-Mobile TMOHS1 and Wingtech CT2MHS01) shut down their Wi-Fi access point after about 10 minutes with no connected clients to save battery. Rayhunter is still recording in the background, but you won't be able to reach the web UI until you power cycle the device or reconnect a client while Wi-Fi is still up.
-
-To avoid this, set Wi-Fi Standby to "Always on" in the hotspot's native admin UI. See [TMOHS1](./tmobile-tmohs1.md#wi-fi-auto-shutdown) or [CT2MHS01](./wingtech-ct2mhs01.md#wi-fi-auto-shutdown) for step-by-step instructions.
-
 ### How do I re-enable USB tethering after installing Rayhunter?
 
-If you have installed with `./installer orbic-usb`, you might find that USB
-tethering is now disabled. If you have run `./installer orbic`, this section is not
-relevant as it does not use or touch USB.
-
-[First obtain a shell](./orbic.md#shell), then:
-
+Make sure USB tethering is also enabled in the Orbic's UI, and then run the following commands:
 
 ```sh
-# inside of Orbic's shell:
-echo 9 > /usrdata/mode.cfg
-reboot
+./installer util shell "echo 9 > /usrdata/mode.cfg"
+./installer util shell reboot
 ```
 
-Make sure USB tethering is also enabled in the Orbic's UI.
-
 To disable tethering again:
 
 ```sh
-# inside of Orbic's shell:
-echo 3 > /usrdata/mode.cfg
-reboot
+./installer util shell "echo 3 > /usrdata/mode.cfg"
+./installer util shell reboot
 ```
 
 See `/data/usb/boot_hsusb_composition` for a list of USB modes and Android USB gadget settings.
 
 
-### How do I connect my device to an existing WiFi network?
-
-The Orbic, Moxee, UZ801, and TMOHS1 can connect to a nearby WiFi network while still running their own hotspot. This gives the device internet access for ntfy notifications and lets you reach the web UI from your home network. See [WiFi Client Mode](./configuration.md#wifi-client-mode) in the configuration guide for setup instructions.
-
-### WiFi client mode is connected but I can't reach the internet
-
-Check that the **DNS Servers** field in the config has valid entries (the default is `9.9.9.9` and `149.112.112.112`). If your home network and the device hotspot use the same subnet (for example, both are on `192.168.1.x`), try restarting the daemon by saving the config again from the web UI.
-
 ### How do I disable the WiFi hotspot on the Orbic RC400L?
 
-To disable both WiFi bands, [first obtain a shell](./orbic.md#shell), then:
+To disable both WiFi bands:
 
 ```sh
-# inside of Orbic's shell:
-sed -i 's/<wlan><Feature><state>1<\/state>/<wlan><Feature><state>0<\/state>/g' /usrdata/data/usr/wlan/wlan_conf_6174.xml && reboot
+adb shell
+/bin/rootshell -c "sed -i 's/<wlan><Feature><state>1<\/state>/<wlan><Feature><state>0<\/state>/g' /usrdata/data/usr/wlan/wlan_conf_6174.xml && reboot"
 ```
 
 To re-enable WiFi:
 
 ```sh
-# inside of Orbic's shell:
-sed -i 's/<wlan><Feature><state>0<\/state>/<wlan><Feature><state>1<\/state>/g' /usrdata/data/usr/wlan/wlan_conf_6174.xml && reboot
+adb shell
+/bin/rootshell -c "sed -i 's/<wlan><Feature><state>0<\/state>/<wlan><Feature><state>1<\/state>/g' /usrdata/data/usr/wlan/wlan_conf_6174.xml && reboot"
 ```

doc/heuristics.md

@@ -6,7 +6,7 @@ Rayhunter includes several analyzers to detect potential IMSI catcher activity.
 
 ### IMSI Requested (v3)
 
-This analyzer tests whether the eNodeB sends an IMSI or IMEI Identity Request NAS message under suspicious .
+This analyser tests whether the eNodeB sends an IMSI or IMEI Identity Request NAS message under suspicous .
 
 Mobile networks primarily request IMSI or IMEI from a mobile device during initial network attachment or when the network cannot identify the mobile device by its temporary identification (TMSI - *Temporary Mobile Subscriber Identity* or GUTI - *Globally Unique Temporary Identifier* in 4G/5G terminology).
 
@@ -21,9 +21,9 @@ What we consider suspicious is the following chain of events:
 * Phone connects to a new tower. 
 * Tower asks for phones identity (IMEI or IMSI.)
 * Authentication does *NOT* happen. 
-* Tower requests phone to disconnect. 
+* Tower requests phoen to disconnect. 
 
-Looking for this chain of events is much less prone to false positives than naively looking for any time the IMSI/IMEI is sent. We do still sometimes get false positives when users are in an airplane that is coming in for a landing however. This is likely due to having been disconnected for a while and then being over towers that are not able to route to your home network, but we are still researching.
+Looking for this chain of events is much less prone to false positives than naively looking for any time the IMSI/IMEI is sent. We do still sometimes get false positives when users are in an airplane that is coming in for a landing however. This is likely do to having been disconnected for a while and then being over towers that are not able to route to your home network, but we are still researching.
 
 This is the attack used by commercial IMSI catchers used by law enforcement. 
 
@@ -36,46 +36,43 @@ This heuristic will also issue a notification every time your identity is sent t
 
 ### Connection Release/Redirected Carrier 2G Downgrade
 
-This analyzer tests if a base station releases your device's connection and redirects your device to a 2G base station. This heuristic is useful, because some IMSI catchers may operate in a such way that they downgrade connection to 2G where they can intercept the communication (by performing man-in-the-middle attack).
+This analyser tests if a base station releases your device's connection and redirects your device to a 2G base station. This heuristic is useful, because some IMSI catchers may operate in a such way that they downgrade connection to 2G where they can intercept the communication (by performing man-in-the-middle attack).
 
 
-### LTE SIB6/7 Downgrade (v2)
+### LTE SIB6/7 Downgrade
 
-This analyzer tests if LTE base station is broadcasting a SIB type 6 and 7 messages which include 2G/3G frequencies with higher priorities.
+This analyser tests if LTE base station is broadcasting a SIB type 6 and 7 messages which include 2G/3G frequencies with higher priorities.
 
 SIB (*System Information Block*) Type 6 and 7 are specific types of broadcast messages sent by the base station (eNodeB in 4G networks) to mobile devices. They contain essential radio-related configuration parameters to help mobile device perform cell reselection.
 
 This attack exploits the fact that SIB broadcast messages are not encrypted or authenticated. This allows them to pretend to be a legitimate cell by broadcasting fake system information in order to force mobile devices to downgrade from more secure 4G (LTE) to less secure 2G (GSM) network and then steal IMSI and/or perform man-in-the-middle attack. That is why this is also called a downgrade attack.
 
-SIB6 is used for cell reselection to CDMA2000 systems which are not supported by many modern mobile phones, and SIB7 Provides the mobile device with information to perform cell reselection to GSM/EDGE networks. Therefore SIB6 messages are quite rare, while malformed SIB7 messages are much more frequent in practice. 
+SIB6 is used for cell reselecion to CDMA2000 systems which are not supported by many modern mobile phones, and SIB7 Provides the mobile device with information to perform cell reselection to GSM/EDGE networks. Therefore SIB6 messages are quite rare, while malformed SIB7 messages are much more frequent in practice. 
 
-This heuristic is useful even in countries where 2g is still prevalent. A well behaved tower should always advertise its other 4g neighbors at a higher priority than 2g/3g neighbors. (Older versions of this heuristic were prone to false positives.)
+This heuristic is the most useful in the United States or other countries where there are no more operating 2G base stations. See [Wikipedia page on past 2G networks](https://en.wikipedia.org/wiki/2G#Past_2G_networks) for information about your country. In countries where 2G is still in service (such as most of EU), this heuristics may trigger false positives. In that case you should consider disabling it. However this heuristics has been vastly improved to reduce false positive warnings and new tests in European networks show that false positives are vastly reduced.
 
 ### Null Cipher
 
-This analyzer tests whether the cell suggests using a null cipher (EEA0) in the RRC layer. That means that encryption between your mobile device and base station is turned off.
+This analyser tests whether the cell suggests using a null cipher (EEA0) in the RRC layer. That means that encryption between your mobile device and base station is turned off.
 
 Normally this should never happen, because null cipher is used almost exclusively for testing and debugging in labs or in controlled environments. Sometimes null cipher is used if encryption negotiation fails or isn’t supported (however in most networks this should not be the case). Also, some regulations allow unencrypted communications in **specific** emergency cases.
 
-The general rule is that null cipher should never be used in commercial deployments, except in very controlled conditions (e.g., test labs) or in a very specific regulatory-approved use cases.
+The general rule is, that null cipher should never be used in commercial deployments, except in very controlled conditions (e.g., test labs) or in a very specific regulatory-approved use cases.
 
 On the other hand, IMSI catchers often use null cipher to avoid setting up secure contexts (because they lack valid keys) and/or to trick mobile device into using unencrypted links (which makes eavesdropping easier).
 
 ### NAS Null Cipher
 
-This analyzer tests whether the security mode command at the NAS layer suggests using a null cipher (EEA0). This would usually only happen after a mobile device has successfully authenticated with the MME (*Mobility Management Entity* - core network component that handles signaling and control) but still it shouldn't happen at all. This could be indicative of an attack though using SS7 (*Signaling System 7* - a set of telecommunication protocols used to set up and manage calls and other services) to get key material from the HLR (*Home Location Register* - a database in mobile telecommunications networks that stores subscriber information) of the mobile phone for a successful authentication.
+This analyser tests whether the security mode command at the NAS layer suggests using a null cipher (EEA0). This would usually only happen after a mobile device has successfully authenticated with the MME (*Mobility Management Entity* - core network component that handles signaling and control) but still it shouldn't happen at all. This could be indicative of an attack though using SS7 (*Signaling System 7* - a set of telecommunication protocols used to set up and manage calls and other services) to get key material from the HLR (*Home Location Register* - a database in mobile telecommunications networks that stores subscriber information) of the mobile phone for a successful authentication.
 
 It could also indicate an IMSI catcher which is connected to the mobile network MME and HLR through cooperation between government and telecom provider. Or it could be a false positive if the telecom provider is intending to use null ciphers (if encryption is illegal in some country, or they have some misconfiguration of the network), however this should be very rare case.
 
 ### Incomplete SIB
 
-This analyzer tests whether the SIB1 message contains a complete SIB chain (SIB3, SIB5, etc.). A legitimate SIB1 message should contain timing information for at least 2 additional SIBs (SIB3, 4, and 5 being the most common) but a fake base station will often not bother to send additional SIBs beyond 1 and 2 (i. e. some IMSI catchers send just SIB1 and *one additional* SIB).
+This analyser tests whether the SIB1 message contains a complete SIB chain (SIB3, SIB5, etc.). A legitimate SIB1 message should contain timing information for at least 2 additional SIBs (SIB3, 4, and 5 being the most common) but a fake base station will often not bother to send additional SIBs beyond 1 and 2 (i. e. some IMSI catchers send just SIB1 and *one additional* SIB).
 
 On its own this might just be a misconfigured base station (though we have only seen it in the wild under suspicious circumstances) but combined with other heuristics such as **IMSI Requested** detection it should be considered as a strong indicator of malicious activity.
 
-### Diagnostic Information 
-This analyzer displays some diagnostic information about when your device connects and disconnects from certain towers. It is helpful for analysis of suspicious PCAPs. The informational warnings in here can safely be ignored until there is a low, medium, or high severity warning. 
-
 ### Test Analyzer
 
-This analyzer is great for testing if your Rayhunter installation works. It will alert every time a new tower is seen (specifically every time a tower broadcasts a SIB1 message.) It is designed to be very noisy so we do not recommend leaving it on but if this alerts it means your Rayhunter device is working! 
+This analyzer is great for testing if your Rayhunter installation works. It will alert every time a new tower is seen (specifically every time a tower broadcasts a SIB1 message.) It is designed to be very noisey so we do not reccomend leaving it on but if this alerts it means your Rayhunter device is working! 

doc/installation.md

@@ -3,8 +3,5 @@
 So, you've got one of the [supported devices](./supported-devices.md), and are ready to start catching IMSI catchers. You have two options for installing Rayhunter:
 
 * [installing from a release (recommended)](./installing-from-release.md)
+  * [installing from a release on Windows](./installing-from-release-windows.md)
 * [installing from source](./installing-from-source.md)
-
-Already have Rayhunter installed but looking to update?
-
-* [Updating Rayhunter](./updating-rayhunter.md)

doc/installing-from-release-windows.md

@@ -0,0 +1,39 @@
+# Installing from the latest release (Windows)
+
+Windows support in Rayhunter's installer is a work-in-progress. Depending on the device, the installation instructions differ.
+
+## TP-Link
+
+1. Insert a FAT-formatted SD card. This will be used to store all recordings.
+2. Connect the device via WiFi or USB Tethering -- you should be able to view the TP-Link admin page on <http://192.168.0.1>.
+3. Download the latest release (must be at least 0.3.0) for windows-x86_64, and unpack the zipfile.
+4. Open PowerShell or CMD in that extracted folder, the installer: `./installer tplink`
+5. Follow the instructions on the screen, if there are any.
+
+## Orbic
+
+<div class=warning><strong>
+
+[The Windows USB installer is known to be buggy](https://github.com/EFForg/rayhunter/issues/366). We strongly reccomend using the [Network-based installer](./orbic.md#the-network-installer).
+
+</strong></div>
+
+1. Connect the device to your computer using the provided USB cable.
+1. Install the [Zadig WinUSB driver installer](https://zadig.akeo.ie/).
+1. Open Zadig, click options->show all devices 
+
+    ![Zadig](./zadig2.png)
+
+1. Select 'RNDIS (Interface 0)'
+
+    ![Zadig](./zadig.png)
+
+1. Click 'install driver' and wait for it to finish. 
+2. Download the latest `rayhunter-vX.X.X-windows-x86_64.zip` from the [Rayhunter releases page](https://github.com/EFForg/rayhunter/releases). The version you download will have numbers instead of X
+3. Unzip `rayhunter-vX.X.X-windows-x86_64` .
+1. Open a powershell terminal by pressing Win+R and typing `powershell` and hitting enter. 
+5. Type `cd ~\Downloads\rayhunter-v<x.x.x>-windows-x86_64` (**Replace <x.x.x> with the Rayhunter version you just unzipped**) and hit enter.
+5. Run the install script: `.\installer.exe orbic` and hit enter.
+    - The device will restart multiple times over the next few minutes.
+    - You will know it is done when you see terminal output that says `checking for rayhunter server...success!`
+6. Rayhunter should now be running! You can verify this by following the instructions below to [view the web UI](./using-rayhunter.md#the-web-ui). You should also see a green line flash along the top of top the display on the device.

doc/installing-from-release.md

@@ -2,7 +2,7 @@
 
 Make sure you've got one of Rayhunter's [supported devices](./supported-devices.md). These instructions have only been tested on macOS and Ubuntu 24.04. If they fail, you will need to [install Rayhunter from source](./installing-from-source.md).
 
-1. **For the TP-Link only,** insert a FAT-formatted SD card. This will be used to store all recordings.
+1. For the TP-Link only, insert a FAT-formatted SD card. This will be used to store all recordings.
 2. Download the latest `rayhunter-vX.X.X-PLATFORM.zip` from the [Rayhunter releases page](https://github.com/EFForg/rayhunter/releases) for your platform:
     - for Linux on x64 architecture: `linux-x64`
     - for Linux on ARM64 architecture: `linux-aarch64`
@@ -18,62 +18,32 @@ Make sure you've got one of Rayhunter's [supported devices](./supported-devices.
     cd ~/Downloads/rayhunter-vX.X.X-PLATFORM
     ```
 
-   On Windows you can decompress using the file browser, then navigate to the
-   folder that contains `installer.exe`, **hold Shift**, Right-Click inside the
-   folder, then click "Open in PowerShell".
+4. Turn on your device by holding the power button on the front.
 
-4. **Connect to your device.**
+   * For the Orbic, connect the device using a USB-C cable.
+     * Or connect to the network if using the network based installer, this is especially reccomended on Windows.
+   * For TP-Link, connect to its network using either WiFi or USB Tethering.
 
-   First turn on your device by holding the power button on the front.
+5. Run the installer:
 
-   Then connect to the device using either WiFi or USB tethering.
+    ```bash
+    # On MacOS, you must first remove the quarantine bit
+    xattr -d com.apple.quarantine installer
+    ```
+    Then run the installer:
+    ```bash
+    ./installer orbic
+    # or: ./installer [orbic-network|tplink|tmobile|uz801|pinephone|wingtech]
+    ```
 
-   You know you are in the right network when you can access
-   <http://192.168.1.1> (Orbic) or <http://192.168.0.1> (TP-Link) and see the
-   hardware's own admin menu.
+    The device will restart multiple times over the next few minutes.
 
-5. **On MacOS only**, you have to run `xattr -d
-   com.apple.quarantine installer` to allow execution of
-   the binary.
+    You will know it is done when you see terminal output that says `Testing Rayhunter... done`
 
-6. **Run the installer.**
-
-   ```bash
-   # For Orbic:
-   ./installer orbic --admin-password 'mypassword'
-   # Note: the arguments --admin-username 'myusername' and --admin-ip 'mydeviceip'
-   #       may be required if different from the default.
-
-   # Optionally configure WiFi client mode during install (Orbic and Moxee only):
-   ./installer orbic --admin-password 'mypassword' --wifi-ssid 'MyNetwork' --wifi-password 'networkpass'
-
-   # Or install over USB if you want ADB and a root shell (not recommended for most users)
-   ./installer orbic-usb
-
-   # For TP-Link:
-   ./installer tplink
-   ```
-
-   * On Verizon Orbic, the password is the one used to login to the device's admin menu, and the default is the WiFi password.
-     * ***Note:*** If you have changed the device username, password, or IP address from their default values, these must be provided as arguments to the installer command above.
-   * On Kajeet/Smartspot devices, the default password is `$m@rt$p0tc0nf!g`
-   * On Moxee-brand devices, check under the battery for the password.
-   * You can reset the password by pressing the button under the back case until the unit restarts.
-
-   TP-Link does not require an `--admin-password` parameter.
-
-   For other devices, check `./installer --help` or the
-   respective page in the sidebar under "Supported
-   Devices."
-
-7. The installer will eventually tell you it's done, and the device will reboot.
-
-8. Rayhunter should now be running! You can verify this by [viewing Rayhunter's web UI](./using-rayhunter.md). You should also see a green line flash along the top of top the display on the device.
+6. Rayhunter should now be running! You can verify this by [viewing Rayhunter's web UI](./using-rayhunter.md). You should also see a green line flash along the top of top the display on the device.
 
 ## Troubleshooting
 
-* If you are having trouble installing Rayhunter and you're connecting to your device over USB, try using a different USB cable to connect the device to your computer. If you are using a USB hub, try using a different one or directly connecting the device to a USB port on your computer. A faulty USB connection can cause the Rayhunter installer to fail.
-
 * You can test your device by enabling the test heuristic. This will be very noisy and fire an alert every time you see a new tower. Be sure to turn it off when you are done testing.  
 
 * On MacOS if you encounter an error that says "No Orbic device found," it may because you have the "Allow accessories to connect" security setting set to "Ask for approval." You may need to temporarily change it to "Always" for the script to run. Make sure to change it back to a more secure setting when you're done.

doc/installing-from-source.md

@@ -1,94 +1,56 @@
 # Installing from source
 
-Building Rayhunter from source, either for development or otherwise, involves a
-number of external dependencies. Unless you need to do this, we recommend you
-use our [compiled builds](https://github.com/EFForg/rayhunter/releases).
+Building Rayhunter from source, either for development or because the install script doesn't work on your system, involves a number of external dependencies. Unless you need to do this, we recommend you use our [compiled builds](https://github.com/EFForg/rayhunter/releases).
 
-At a high level, we have:
+* Install [nodejs/npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm), which is required to build Rayhunter's web UI
+  * Make sure to build the site with `pushd daemon/web && npm install && npm run build && popd` before building Rayhunter. If you're working directly on the frontend, `npm run dev` will allow you to test a local frontend with hot-reloading (use `http://localhost:5173` instead of `http://localhost:8080`).
+* Install ADB on your computer using the instructions above, and make sure it's in your terminal's PATH
+  * You can verify if ADB is in your PATH by running `which adb` in a terminal. If it prints the filepath to where ADB is installed, you're set! Otherwise, try following one of these guides:
+    * [linux](https://askubuntu.com/questions/652936/adding-android-sdk-platform-tools-to-path-downloaded-from-umake)
+    * [macOS](https://www.repeato.app/setting-up-adb-on-macos-a-step-by-step-guide/)
+    * [Windows](https://medium.com/@yadav-ajay/a-step-by-step-guide-to-setting-up-adb-path-on-windows-0b833faebf18)
+* Install `curl` on your computer to run the install scripts. It is not needed to build binaries.
 
-* A JS frontend written in SvelteKit (`./daemon/web/`)
-* A Rust binary `rayhunter-daemon` (`./daemon/`) that runs on the device, and bundles the frontend.
-* A Rust binary `installer` (`./installer`) that runs on the computer and bundles `rayhunter-daemon`.
+### Install Rust targets
 
-It's recommended to work either on Mac/Linux, or WSL on Windows.
-
-## Building frontend and backend
-
-First, install dependencies:
-
-- [Rust](https://www.rust-lang.org/tools/install)
-- [Node.js/npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
-- C compiler tools (`apt install build-essential` on Linux, `xcode-select --install` on Mac)
-
-Then you can build everything with:
+[Install Rust the usual way](https://www.rust-lang.org/tools/install). Then,
 
+- install the cross-compilation target for the device Rayhunter will run on:
 ```sh
-./scripts/build-dev.sh
-./scripts/install-dev.sh orbic  # replace 'orbic' with your device type
+rustup target add armv7-unknown-linux-musleabihf
 ```
 
-## Hot-reloading the frontend
-
-If you are working on the frontend, you normally have to repeat all of the above steps everytime to see a change.
-
-You can instead run the frontend separately on your PC while the Rust parts
-continue running on your target device:
-
+- install the statically compiled target for your host machine to build the binary installer `serial`.
 ```sh
-cd daemon/web
-
-# Assumes rayhunter-daemon is listening on localhost:8080
-npm run dev
-
-# Use a custom target IP:port where the backend runs
-API_TARGET=http://192.168.1.1:8080 npm run dev
+# check which toolchain you have installed by default with
+rustup show
+# now install the correct variant for your host platform, one of:
+rustup target add aarch64-unknown-linux-musl
+rustup target add armv7-unknown-linux-musleabi
+rustup target add x86_64-unknown-linux-musl
+rustup target add aarch64-apple-darwin
+rustup target add x86_64-apple-darwin
+rustup target add x86_64-pc-windows-gnu
 ```
 
-The UI will listen on `localhost:5173` and instantly show any frontend changes
-you make. Backend changes require building everything from the top (daemon and installer).
-
-## Installer utils, getting a shell
-
-Check `./scripts/install-dev.sh util --help`
-for useful utilities for transferring files, opening shells. The exact tools
-available wildly depend on the device you're working on, and they are
-usually documented the relevant device's page under [Supported
-Devices](./supported-devices.md).
-
-A lot of devices run a trimmed down version of Android and have ADB (Android
-Debug Bridge) support. The USB-based installers (`orbic-usb`, `pinephone`,
-`uz801`) use ADB to perform the installation.
-
-You might want to install and use actual ADB to connect to the device, push
-files and generally poke around. The installer contains some tools to enable ADB:
+Now you can root your device and install Rayhunter by running:
 
 ```sh
-adb kill-server
+# Profile can be changed to 'firmware-devel' when building for development.
+# Build time will decrease at the expense of binary size.
+cargo build --bin rayhunter-daemon --target armv7-unknown-linux-musleabihf --profile firmware
 
-# Enables ADB on either of these devices
-./scripts/install-dev.sh util tmobile-start-adb
-./scripts/install-dev.sh orbic-usb
+cargo build --bin rootshell --target armv7-unknown-linux-musleabihf --profile firmware
 
-adb shell
+# Replace 'orbic' with your device type if different.
+# A list possible values can be found with 'cargo run --bin installer help'.
+cargo run --bin installer orbic
 ```
 
-Note though that we can't assist with any issues setting ADB up, _especially
-not_ on Windows. There have been too many driver issues to make this the
-"golden path" for most users or contributors. There have been instances where
-people managed to brick their orbic devices using ADB on Windows.
+### If you're on Windows or can't run the install scripts
 
-## Troubleshooting
-
-You may need to turn off your VPN in order to load the frontend succesfully - even with local network sharing enabled, VPNs can interfere with the connection to the backend.
-
-Specifically for WSL users:
-
-- The HyperV firewall also tends to interfere with the connection between frontend and backend. You can turn it off in your WSL settings.
-
-- WSL2 has a known compatibility issue which may prevent vite from detecting file system changes and therefore affects HMR (hot module replacement).
-If your hot reloading does not work, some have success using polling to detect changes. To do so, specify the following setting in vite.config.ts:
-```ts
-server: {
-    watch: { usePolling: true }
-}
-```
+* Root your device on Windows using the instructions here: <https://xdaforums.com/t/resetting-verizon-orbic-speed-rc400l-firmware-flash-kajeet.4334899/#post-87855183>
+* Build the web UI using `cd bin/web && npm install && npm run build`
+* Push the scripts in `scripts/` to `/etc/init.d` on device and make a directory called `/data/rayhunter` using `adb shell` (and sshell for your root shell if you followed the steps above)
+* You also need to copy `config.toml.in` to `/data/rayhunter/config.toml`. Uncomment the `device` line and set the value to your device type if necessary.
+* Then run `./make.sh`, which will build the binary, push it over adb, and restart the device. Once it's restarted, Rayhunter should be running!

doc/moxee.md

@@ -5,8 +5,6 @@ Supported in Rayhunter since version 0.6.0.
 The Moxee Hotspot is a device very similar to the Orbic RC400L. It seems to be
 primarily for the US market.
 
-**These devices have relatively little storage. The Orbic is usually a better alternative, though might be more expensive.**
-
 - [KonnectONE product page](https://www.konnectone.com/specs-hotspot)
 - [Moxee product page](https://www.moxee.com/hotspot)
 
@@ -32,16 +30,14 @@ According to [FCC ID 2APQU-K779HSDL](https://fcc.report/FCC-ID/2APQU-K779HSDL),
 Connect to the hotspot's network using WiFi or USB tethering and run:
 
 ```sh
-./installer moxee --admin-password 'mypassword'
+./installer orbic-network
 ```
 
-The password (in place of `mypassword`) is under the battery.
-
-`./installer moxee` is almost the same as `./installer orbic`, it just comes
-with slightly better defaults that will give you more space for recordings.
+The installation will ask you to log into the admin UI using a custom URL. The
+password for that is under the battery.
 
 ## Obtaining a shell
 
 ```sh
-./installer util orbic-shell
+./installer util orbic-start-telnet
 ```

doc/orbic.md

@@ -6,8 +6,7 @@ It is also sometimes sold under the brand Kajeet RC400L. This is the exact same
 
 You can buy an Orbic [using bezos
 bucks](https://www.amazon.com/Orbic-Verizon-Hotspot-Connect-Enabled/dp/B08N3CHC4Y),
-or on [eBay](https://www.ebay.com/sch/i.html?_nkw=orbic+rc400l). You should not
-pay more than 30 USD for such a device (without shipping).
+or on [eBay](https://www.ebay.com/sch/i.html?_nkw=orbic+rc400l).
 
 [Please check whether the Orbic works in your country](https://www.frequencycheck.com/countries/), and whether the Orbic RC400L supports the right frequency bands for your purpose before buying.
 
@@ -22,32 +21,27 @@ pay more than 30 USD for such a device (without shipping).
 | Wifi 5Ghz | a/ac/ax |
 | Wifi 6 | 🮱 |
 
-## WiFi client mode
+## The Network Installer
 
-The Orbic's QCA6174 radio supports running the hotspot and connecting to an external WiFi network at the same time. See [WiFi Client Mode](./configuration.md#wifi-client-mode) for setup.
+Since Rayhunter 0.6.0 there is an alternative, experimental installation
+procedure at `./installer orbic-network` that is supposed to eventually replace
+`./installer orbic`. It does not require any USB driver installation and works
+identically on Windows, Mac and Linux. From our testing it works much more
+reliably on Windows than `./installer orbic` does.
 
-## Two kinds of installers
+The drawback is that the device's admin password is required. 
 
-The orbic's installation routine underwent many different changes:
+1. Connect to the Orbic's network via WiFi or USB tethering
+2. Run `./installer orbic-network`
+3. The installer will ask you to log into the admin UI on `localhost:4000`. The password for that is the same as the WiFi password.
+4. As soon as you're logged in, the installer will continue and reboot the device.
 
-1. The ADB-based shellscript prior to version 0.3.0
-2. The Rust-based, ADB-based installer since version 0.3.0
-3. Then, starting with 0.6.0, an alternative installer `./installer
-   orbic-network` that is supposed to work more reliably, can run over the
-   Orbic's WiFi connection and without the need to manually install USB drivers
-   on Windows.
-4. Starting with 0.8.0, `orbic-network` has been renamed to `orbic`, and the
-   old `./installer orbic` is now called `./installer orbic-usb`.
-   
-It's possible that many tutorials out there still refer to some of the old
-installation routines.
+*note*: On Kajeet devices the default admin password is `$m@rt$p0tc0nf!g`, on most other orbic devices the default admin password is the same as the wifi password. If the password has been changed you can reset it by pressing the button under the back case until the unit restarts. 
 
-<a name=shell></a>
 ## Obtaining a shell
 
-After running the installer, there will not be a rootshell and ADB will not be
-enabled. Instead you can use `./installer util orbic-shell`.
+After running through the installation procedure, you can obtain a root shell
+by running `adb shell` or `./installer util shell`. Then, inside of that shell
+you can run `/bin/rootshell` to obtain "fakeroot."
 
-If you are using an installer prior to 0.7.0 or `orbic-usb` explicitly, you can
-obtain a root shell by running `adb shell` or `./installer util shell`. Then,
-inside of that shell you can run `/bin/rootshell` to obtain "fakeroot."
+If you are using the network installer, there will not be a rootshell and ADB will not be enabled by the installer. Instead you can use `./installer util orbic-start-telnet` and connect to the hotspot using `nc 192.168.1.1 23`. On Windows you might not have `nc` and will have to use WSL for that.

doc/porting.md

@@ -1,88 +0,0 @@
-# Porting to new devices
-
-## When will we consider new devices?
-
-Rayhunter is already officially supported on [several devices](./supported-devices.md), and people are often interested in adding support for hardware they already own. Here's a non-exhaustive list of situations where we'd consider adding a new Tier 2 device:
-
-* The device is significantly cheaper or more available in a specific region than any device we already support.
-* The device supports 5G and costs less than 100 USD.
-* You're willing to commit to supporting this device and handling bug reports.
-* The device has support for all cellular bands and can work in any country.
-
-We want to avoid a situation where the list of supported devices keeps growing but the number of recurring contributors and maintainers stays the same.
-
-That said, you can always maintain a fork, or install Rayhunter manually without writing an installer. You can promote this work in the [GitHub discussions](https://github.com/EFForg/rayhunter/discussions) area, where most new hardware investigations happen.
-
-Please don't open issues about supporting a new device, use GitHub discussions instead. Most hardware investigations end up being abandoned, and the amount of issues we'd have to triage would be too much.
-
-## Prerequisites: root shell, and /dev/diag
-
-Rayhunter is a Linux binary that reads traffic from the Qualcomm diagnostic interface, which requires root. If either of those isn't available, Rayhunter can't work. Everything else (displays, buttons) is secondary, and we can deal with it later.
-
-In the devices we currently support `/dev/diag` is the interface for Qualcomm diagnostics and devices with this will be easiest to support. Newer Qualcomm modems expose the diagnostic interface over a USB gadget which is something we are working on support for, but do not currently have. Thus devices with the former diagnostic interface will be easier to port Rayhunter to.
-
-You can check ahead of purchase whether `/dev/diag` is available by ensuring the device has a Qualcomm MDM* chip. Other Qualcomm LTE chips might work but we haven't encountered one yet. Typically you will be able to get this information from [fcc.report](https://fcc.report), where either the chip is written down in some PDF or at least plainly visible in one of the teardown photos. Sometimes this information can also be found through teardown videos on YouTube. If you find that chip, there's a good chance (but no guarantee) `/dev/diag` is available.
-
-Any vendor other than Qualcomm (Mediatek, Rockchip, ...) is unlikely to work. Quectel sometimes repackages Qualcomm chips into larger systems and might work. Huawei devices won't work, as they use their own chips.
-
-Getting a root shell varies from device to device. Check the [GitHub discussions](https://github.com/EFForg/rayhunter/discussions) for prior art, and look through the installer source in `installer/src/` for inspiration. These approaches are common:
-
-* Connecting with `adb shell`.
-* If `adb shell` doesn't work, sending a special USB serial command might enable it.
-* Sometimes there's an unpatched CVE that can be used to launch `telnetd` as root (search "device name CVE", the website [opencve.io](https://opencve.io) is particularly easy to use).
-
-Once you have a root shell, check that `/dev/diag` exists.
-
-## Installing Rayhunter manually
-
-The Rayhunter installation consists of just two components: the `rayhunter-daemon` binary, and the config file (`config.toml`).
-
-Typically the layout on the filesystem will look like this:
-
-```text
-/data/rayhunter/rayhunter-daemon
-/data/rayhunter/config.toml
-/data/rayhunter/qmdl/
-```
-
-Then, `./rayhunter-daemon config.toml` can be started manually.
-
-You can refer to [Installing from source](./installing-from-source.md) for how to obtain the `rayhunter-daemon` binary.
-
-We're assuming that your device is ARMv7, i.e. 32-bit ARM (`armv7-unknown-linux-musleabihf`). If that's not the case, you can still build the daemon but you'll need to figure out the correct target triple on your own.
-
-You can copy the daemon and config files to the device using `netcat` or `adb push`. They don't have to be in `/data/rayhunter/`, this is just convention. If you use a different path, be sure to update the `qmdl_store_path` setting in `config.toml`.
-
-The `device` setting in `config.toml` must match one of the lowercase variant names from the `Device` enum (e.g. `"orbic"`, `"tplink"`). This controls which display driver is used.
-
-Setting `debug_mode = true` in `config.toml` runs the daemon without `/dev/diag`, so you can test the display and web UI without the hardware.
-
-### Autostart
-
-To make Rayhunter start on boot, you'll need an init script. The existing installers use the template at `dist/scripts/rayhunter_daemon`, which has a `#RAYHUNTER-PRESTART` placeholder that gets replaced with device-specific setup commands (e.g. killing a vendor UI process, mounting an SD card). Look at how the existing installers handle this in their `install()` functions.
-
-## Display support
-
-The `device` setting [mentioned above](#installing-rayhunter-manually) also controls which display driver is loaded (see [`Device` enum in `lib/src/lib.rs`](https://github.com/EFForg/rayhunter/blob/main/lib/src/lib.rs)). Unless your device is a variant of an existing device, you'll want to add a new variant to the `Device` enum and write a corresponding display module in `daemon/src/display/`.
-
-You can play around with the existing values of the `device` setting to see which one ends up rendering on your device's display. Most likely your device has a display similar enough to an existing one, and the display module for that device (e.g. `daemon/src/display/orbic.rs`, `daemon/src/display/tplink.rs`) can be used as a starting point.
-
-If your device has LEDs instead of a display, take a look at `daemon/src/display/uz801.rs` which controls LEDs via sysfs.
-
-## Button support
-
-Rayhunter can use the power button to restart recordings via a double-tap gesture. The implementation is in [`daemon/src/key_input.rs`](https://github.com/EFForg/rayhunter/blob/main/daemon/src/key_input.rs). It currently has no structure for device-specific implementations, as all devices we support expose the same input event interface.
-
-The `key_input_mode` setting in `config.toml` controls this feature (`0` = disabled, `1` = double-tap power button to start/stop recordings).
-
-## Writing the installer, and contributing official support
-
-At this point you'll want to have figured out how to automate the entire installation in principle, and how to make it as repeatable as possible. A proof-of-concept of this in bash or another language is also a welcome contribution (to be posted on [GitHub discussions](https://github.com/EFForg/rayhunter/discussions), not as a PR).
-
-Writing the installer means adding a new variant to the `Command` enum in [`installer/src/lib.rs`](https://github.com/EFForg/rayhunter/blob/main/installer/src/lib.rs) and implementing the install logic in a new module under `installer/src/`. Each subcommand maps to a device-specific entry point function (e.g. `tplink::main_tplink`, `orbic_network::install`).
-
-The installer gets the daemon binary path from `env!("FILE_RAYHUNTER_DAEMON")`, which is set at build time. Config installation is handled by the shared `install_config()` helper in the `connection` module, which writes the config file with the correct device name.
-
-You must also add a shell utility subcommand under `installer util` (the `UtilSubCommand` enum in `installer/src/lib.rs`), e.g. `installer util tplink-shell`, `installer util orbic-shell`. This is required -- without it, users and developers have no way to interactively debug the device. Depending on connectivity, this might be a telnet session, an ADB shell, or a serial connection. Other utilities (file transfer helpers, etc.) are optional but encouraged. See the existing `UtilSubCommand` variants for examples.
-
-Please reuse existing utilities wherever possible. Take a look at [`installer/src/tplink.rs`](https://github.com/EFForg/rayhunter/blob/main/installer/src/tplink.rs) and [`installer/src/orbic_network.rs`](https://github.com/EFForg/rayhunter/blob/main/installer/src/orbic_network.rs) for inspiration. But the structures there are still evolving, and we'll happily guide you during code review.

doc/reanalyzing.md

@@ -16,7 +16,7 @@ using the `rayhunter-check` CLI tool. That tool contains the same heuristics as
 Rayhunter and will also work on traffic data captured with other tools, such as
 QCSuper.
 
-Since 0.6.1, `rayhunter-check` is included in the release zipfile.
+Since, 0.6.1, `rayhunter-check` is included in the release zipfile.
 
 You can build `rayhunter-check` from source with the following command:
 `cargo build --bin rayhunter-check` 
@@ -42,4 +42,4 @@ Options:
 
 `rayhunter-check -p ~/Downloads #Check all files in downloads`
 
-`rayhunter-check -d -p ~/Downloads/myfile.qmdl #run in debug mode`
+`rayhunter-check -d -p ~/Downloads/myfile.qmdl #run in debug mode`

doc/support-feedback-community.md

@@ -2,15 +2,7 @@
 
 If you're using Rayhunter (or trying to), we'd love to hear from you! Check out one of the following forums for contacting the Rayhunter developers and community:
 
-* If you've received a Rayhunter warning, please send your Rayhunter data captures (the ZIP file) to us at our [Signal](https://signal.org/) username [**ElectronicFrontierFoundation.90**](https://signal.me/#eu/HZbPPED5LyMkbTxJsG2PtWc2TXxPUR1OxBMcJGLOPeeCDGPuaTpOi5cfGRY6RrGf) with the following information: capture date, capture location, device, device model, and Rayhunter version. 
-
-  Note that the recording files are sensitive data and contain location
-  information, so we strongly recommend against posting them to publicly.
-
-  If you're unfamiliar with Signal, feel free to check out our [Security Self
-  Defense guide on it](https://ssd.eff.org/module/how-to-use-signal).
-
-* If you're having issues installing or using Rayhunter, consider checking the [Frequently Asked Questions](./faq.md) page for answers to common questions.
-* If your question isn't answered there, please [open an issue](https://github.com/EFForg/rayhunter/issues) on our Github repo.
+* If you've received a Rayhunter warning and would like to help us with our research, please send your Rayhunter data captures (QMDL and PCAP logs) to us at our [Signal](https://signal.org/) username [**ElectronicFrontierFoundation.90**](https://signal.me/#eu/HZbPPED5LyMkbTxJsG2PtWc2TXxPUR1OxBMcJGLOPeeCDGPuaTpOi5cfGRY6RrGf) with the following information: capture date, capture location, device, device model, and Rayhunter version. If you're unfamiliar with Signal, feel free to check out our [Security Self Defense guide on it](https://ssd.eff.org/module/how-to-use-signal).
+* If you're having issues installing or using Rayhunter, please [open an issue](https://github.com/EFForg/rayhunter/issues) on our Github repo.
 * If you'd like to propose a feature, heuristic, or device for Rayhunter, [start a discussion](https://github.com/EFForg/rayhunter/discussions) in our Github repo
 * For anything else, join us in the `#rayhunter` or `#rayhunter-developers` channel of [EFF's Mattermost](https://opensource.eff.org/signup_user_complete/?id=r1b6cnta9bysxk6im3kuabiu1y&md=link&sbr=su) instance to chat!

doc/supported-devices.md

@@ -30,4 +30,4 @@ Rayhunter is confirmed to work on these devices.
 ## Adding new devices
 Rayhunter was built and tested primarily on the Orbic RC400L mobile hotspot, but the community has been working hard at adding support for other devices. Theoretically, if a device runs a Qualcomm modem and exposes a `/dev/diag` interface, Rayhunter may work on it.
 
-If you have a device in mind which you'd like Rayhunter to support, please read the [porting guide](./porting.md) and [open a discussion on our Github](https://github.com/EFForg/rayhunter/discussions)!
+If you have a device in mind which you'd like Rayhunter to support, please [open a discussion on our Github](https://github.com/EFForg/rayhunter/discussions)!