Merge pull request #477 from EFForg/release-0.5.0

Bump version to 0.5.0

.cargo/config.toml

@@ -15,6 +15,10 @@ rustflags = ["-C", "target-feature=+crt-static"]
 linker = "rust-lld"
 rustflags = ["-C", "target-feature=+crt-static"]
 
+[target.armv7-unknown-linux-musleabi]
+linker = "rust-lld"
+rustflags = ["-C", "target-feature=+crt-static"]
+
 # Disable rust-lld for x86 macOS because the linker crashers when compiling
 # the installer in release mode with debug info on.
 # [target.x86_64-apple-darwin]
@@ -25,17 +29,17 @@ rustflags = ["-C", "target-feature=+crt-static"]
 linker = "rust-lld"
 rustflags = ["-C", "target-feature=+crt-static"]
 
-# keep line numbers in stack traces for non-firmware binaries
 [profile.release]
+# keep line numbers in stack traces for non-firmware binaries
 debug = "limited"
+lto = "fat"
+opt-level = "z"
+strip = "debuginfo"
 
 # optimizations to reduce the binary size of firmware binaries
 [profile.firmware]
 inherits = "release"
 strip = true
-opt-level = "z"
-lto = true
 codegen-units = 1
 panic = "abort"
 debug = false
-

.git-blame-ignore-revs

@@ -1 +1,2 @@
-c5bbaabe15d4ccfee97b9997a13569fbfea13c45
+9fe75ac961c57e508bf7488ce51d596750fa8d37
+76ffdf6bada515c9a5f63a600e6f1502288c147a

.github/ISSUE_TEMPLATE/bug.yaml

@@ -1,59 +1,19 @@
 name: Bug Report
 description: File a bug report.
-title: "[Bug]: "
+labels: ["bug"]
 body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this bug report!
-  - type: input
-    attributes:
-      label: Rayhunter Version
-      description: |
-        Which version did you install?
-      placeholder:  "v0.2.6"
-  - type: input
-    attributes:
-      label: Capture Date
-      description: |
-        YYYY-MM-DD
-      placeholder: "2025-05-01"
-    validations:
-      required: true
-  - type: input
-    attributes:
-      label: Capture Location
-      description: |
-        (If comfortable disclosing) What region or country were you in? 
-      placeholder: Washington State
-  - type: input
-    attributes:
-      label: Device and Model
-      description: |
-        Device you installed Rayhunter on to.
-      placeholder: Orbic RC400L 
-    validations:
-      required: true
   - type: textarea
-    id: what-happened
     attributes:
-      label: What happened?
+      label: Bug Report Details
       description: |
-        What steps did you take to get to your issue?
+        Please provide the following information, if applicable:
-      placeholder: "Tell us what you see!"
+      placeholder: |
+        • **Rayhunter Version**: (e.g., v0.2.6)
+        • **Capture Date**: (YYYY-MM-DD, e.g., 2025-05-01)
+        • **Capture Location**: (If comfortable disclosing, what region or country were you in? e.g., Washington State)
+        • **Device and Model**: (Device you installed Rayhunter on, e.g., Orbic RC400L)
+        • **What happened?**: (What steps did you take to get to your issue? Tell us what you see!)
+        • **Expected behavior**: (Rayhunter's behavior differed from what I expected because...)
+        • **Relevant log output**: (Rayhunter data captures - QMDL and PCAP logs - or error codes)
     validations:
       required: true
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected behavior
-      description: Rayhunter's behavior differed from what I expected because.
-      placeholder: "What was expected?"
-    validations:
-      required: true
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: Rayhunter data captures (QMDL and PCAP logs) or error codes
-      render: shell

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
   - name: Rayhunter Mattermost
     url: https://opensource.eff.org/signup_user_complete/?id=6iqur37ucfrctfswrs14iscobw&md=link&sbr=su

.github/ISSUE_TEMPLATE/feature.yaml

@@ -1,6 +1,5 @@
 name: Feature Request
 description: Suggest a new feature or improvement to Rayhunter
-title: "[Feature Request]: "
 labels: ["enhancement"]
 body:
   - type: textarea

.github/workflows/build-release.yml

@@ -1,162 +0,0 @@
-name: Build Release
-
-on:
-  push:
-    branches: [main, "release-*"]
-  pull_request:
-    branches: ["main"]
-
-env:
-  CARGO_TERM_COLOR: always
-  FILE_ROOTSHELL: ../../rootshell/rootshell
-  FILE_RAYHUNTER_DAEMON_ORBIC: ../../rayhunter-daemon-orbic/rayhunter-daemon
-  FILE_RAYHUNTER_DAEMON_TPLINK: ../../rayhunter-daemon-tplink/rayhunter-daemon
-
-jobs:
-  build_rayhunter_check:
-    strategy:
-      matrix:
-        platform:
-          - name: ubuntu-24
-            os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-          - name: ubuntu-24-aarch64
-            os: ubuntu-24.04-arm
-            target: aarch64-unknown-linux-musl
-          - name: macos-arm
-            os: macos-latest
-            target: aarch64-apple-darwin
-          - name: macos-intel
-            os: macos-13
-            target: x86_64-apple-darwin
-          - name: windows-x86_64
-            os: windows-latest
-            target: x86_64-pc-windows-gnu
-    runs-on: ${{ matrix.platform.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build rayhunter-check
-        run: cargo build --bin rayhunter-check --release
-      - uses: actions/upload-artifact@v4
-        with:
-          name: rayhunter-check-${{ matrix.platform.name }}
-          path: target/release/rayhunter-check${{ matrix.platform.os == 'windows-latest' && '.exe' || '' }}
-          if-no-files-found: error
-  build_rootshell:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: armv7-unknown-linux-musleabihf
-      - name: Build rootshell (arm32)
-        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_rayhunter:
-    strategy:
-      matrix:
-        device:
-          - name: tplink
-          - name: orbic
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: armv7-unknown-linux-musleabihf
-      - name: Build rayhunter-daemon (arm32)
-        run: |
-          pushd bin/web
-          npm install
-          npm run build
-          popd
-          # 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 --no-default-features --features ${{ matrix.device.name }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: rayhunter-daemon-${{ matrix.device.name }}
-          path: target/armv7-unknown-linux-musleabihf/firmware/rayhunter-daemon
-          if-no-files-found: error
-  build_rust_installer:
-    needs:
-      - build_rayhunter
-    strategy:
-      matrix:
-        platform:
-          - name: ubuntu-24
-            os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-          - name: ubuntu-24-aarch64
-            os: ubuntu-24.04-arm
-            target: aarch64-unknown-linux-musl
-          - name: macos-arm
-            os: macos-latest
-            target: aarch64-apple-darwin
-          - name: macos-intel
-            os: macos-13
-            target: x86_64-apple-darwin
-          - name: windows-x86_64
-            os: windows-latest
-            target: x86_64-pc-windows-gnu
-    runs-on: ${{ matrix.platform.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.platform.target }}
-      - run: cargo build --bin installer --release --target ${{ matrix.platform.target }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: installer-${{ matrix.platform.name }}
-          path: target/${{ matrix.platform.target }}/release/installer${{ matrix.platform.os == 'windows-latest' && '.exe' || '' }}
-          if-no-files-found: error
-
-  build_release_zip:
-    needs:
-      - build_rayhunter_check
-      - build_rootshell
-      - build_rayhunter
-      - build_rust_installer
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-      - name: Fix executable permissions on binaries
-        run: chmod +x installer-*/installer rayhunter-check-*/rayhunter-check rayhunter-daemon-*/rayhunter-daemon
-      - name: Get Rayhunter version
-        id: get_version
-        run: echo "VERSION=$(grep '^version' bin/Cargo.toml | head -n 1 | cut -d'"' -f2)" >> $GITHUB_ENV
-      - name: Setup versioned release directory
-        run: |
-          VERSIONED_DIR="rayhunter-v${{ env.VERSION }}"
-          mkdir "$VERSIONED_DIR"
-          mv rayhunter-daemon-* rootshell/rootshell installer-* dist/* installer/install.ps1 "$VERSIONED_DIR"/
-      - name: Archive release directory as zip
-        run: |
-          VERSIONED_DIR="rayhunter-v${{ env.VERSION }}"
-          zip -r "$VERSIONED_DIR.zip" "$VERSIONED_DIR"
-      - name: Compute SHA256 of zip
-        run: |
-          VERSIONED_DIR="rayhunter-v${{ env.VERSION }}"
-          sha256sum "$VERSIONED_DIR.zip" > "$VERSIONED_DIR.zip.sha256"
-      # TODO: have this create a release directly
-      - name: Upload zip release and sha256
-        uses: actions/upload-artifact@v4
-        with:
-          name: rayhunter-v${{ env.VERSION }}
-          path: |
-            rayhunter-v${{ env.VERSION }}.zip
-            rayhunter-v${{ env.VERSION }}.zip.sha256
-          if-no-files-found: error

.github/workflows/check-and-test.yml

@@ -1,54 +0,0 @@
-name: Check and Test
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  CARGO_TERM_COLOR: always
-  NO_FIRMWARE_BIN: true
-
-jobs:
-  check_and_test:
-    strategy:
-      matrix:
-        device:
-          - name: tplink
-          - name: orbic
-
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - name: Check
-      run: |
-        pushd bin/web
-        npm install
-        npm run build
-        popd
-        cargo check --verbose --no-default-features --features=${{ matrix.device.name }}
-    - name: Run tests
-      run: |
-        pushd bin/web
-        npm install
-        npm run build
-        popd
-        cargo test --verbose --no-default-features --features=${{ matrix.device.name }}
-    - name: Run clippy
-      run: cargo clippy --verbose --no-default-features --features=${{ matrix.device.name }}
-
-  windows_installer_check_and_test:
-    runs-on: windows-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: cargo check
-        shell: bash
-        run: |
-          cd installer
-          cargo check --verbose
-      - name: cargo test
-        shell: bash
-        run: |
-          cd installer
-          cargo test --verbose --no-default-features --features=${{ matrix.device.name }}

.github/workflows/main.yml

@@ -0,0 +1,352 @@
+name: main
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  workflow_call:  # required to call this workflow from another workflow like release.yml
+
+env:
+  CARGO_TERM_COLOR: always
+  FILE_ROOTSHELL: ../../rootshell/rootshell
+  FILE_RAYHUNTER_DAEMON: ../../rayhunter-daemon/rayhunter-daemon
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  files_changed:
+    name: Detect file changes
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      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
+      - name: detect file changes
+        id: files_changed
+        run: |
+          lcommit=${{ github.event.pull_request.base.sha || 'origin/main' }}
+
+          # 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_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"
+          fi
+
+  mdbook_test:
+    name: Test mdBook Documentation builds
+    needs: files_changed
+    if: needs.files_changed.outputs.docs_changed != '0'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install mdBook
+        run: |
+          cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
+      - name: Test mdBook
+        run: mdbook test
+
+  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
+      - name: Install mdBook
+        run: |
+          cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
+
+      - name: Build mdBook
+        run: mdbook build
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          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 != '0'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+    - uses: actions/checkout@v4
+    - uses: Swatinem/rust-cache@v2
+    - name: Check formatting
+      run: cargo fmt --all --check
+    - name: Check
+      run: |
+        pushd daemon/web
+        npm install
+        npm run build
+        popd
+        NO_FIRMWARE_BIN=true cargo check --verbose
+    - name: Run tests
+      run: |
+        NO_FIRMWARE_BIN=true cargo test --verbose
+    - name: Run clippy
+      run: |
+        NO_FIRMWARE_BIN=true cargo clippy --verbose
+
+  test_web_frontend:
+    needs: files_changed
+    if: needs.files_changed.outputs.web_changed != '0'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    defaults:
+      run:
+        working-directory: daemon/web
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm install
+      - run: npm run lint
+      - run: npm run check
+      - run: npm run test
+
+  windows_installer_check_and_test:
+    needs: files_changed
+    if: needs.files_changed.outputs.installer_changed != '0'
+    runs-on: windows-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+      - name: cargo check
+        shell: bash
+        run: |
+          cd installer
+          NO_FIRMWARE_BIN=true cargo check --verbose
+      - name: cargo test
+        shell: bash
+        run: |
+          cd installer
+          NO_FIRMWARE_BIN=true cargo test --verbose --no-default-features
+
+  build_rayhunter_check:
+    if: needs.files_changed.outputs.daemon_changed != '0'
+    needs:
+      - check_and_test
+      - files_changed
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        platform:
+          - name: linux-x64
+            os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+          - name: linux-armv7
+            os: ubuntu-latest
+            target: armv7-unknown-linux-musleabi
+          - name: linux-aarch64
+            os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-musl
+          - name: macos-arm
+            os: macos-latest
+            target: aarch64-apple-darwin
+          - name: macos-intel
+            os: macos-13
+            target: x86_64-apple-darwin
+          - name: windows-x86_64
+            os: windows-latest
+            target: x86_64-pc-windows-gnu
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Build rayhunter-check
+        run: cargo build --bin rayhunter-check --release --target ${{ matrix.platform.target }}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rayhunter-check-${{ matrix.platform.name }}
+          path: target/${{ matrix.platform.target }}/release/rayhunter-check${{ matrix.platform.os == 'windows-latest' && '.exe' || '' }}
+          if-no-files-found: error
+
+  build_rootshell:
+    if: needs.files_changed.outputs.rootshell_changed != '0'
+    needs:
+      - check_and_test
+      - files_changed
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: armv7-unknown-linux-musleabihf
+      - uses: Swatinem/rust-cache@v2
+      - name: Build rootshell (armv7)
+        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_rayhunter:
+    if: needs.files_changed.outputs.daemon_changed != '0'
+    needs:
+      - check_and_test
+      - files_changed
+    permissions:
+      contents: read
+      packages: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          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
+          # 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
+          path: target/armv7-unknown-linux-musleabihf/firmware/rayhunter-daemon
+          if-no-files-found: error
+
+  build_rust_installer:
+    if: needs.files_changed.outputs.installer_changed != '0'
+    permissions:
+      contents: read
+      packages: write
+    needs:
+      - build_rayhunter
+      - build_rootshell
+      - files_changed
+      - windows_installer_check_and_test
+    strategy:
+      matrix:
+        platform:
+          - name: linux-x64
+            os: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+          - name: linux-armv7
+            os: ubuntu-latest
+            target: armv7-unknown-linux-musleabi
+          - name: linux-aarch64
+            os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-musl
+          - name: macos-arm
+            os: macos-latest
+            target: aarch64-apple-darwin
+          - name: macos-intel
+            os: macos-13
+            target: x86_64-apple-darwin
+          - name: windows-x86_64
+            os: windows-latest
+            target: x86_64-pc-windows-gnu
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform.target }}
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo build --package installer --bin installer --release --target ${{ matrix.platform.target }}
+      - uses: actions/upload-artifact@v4
+        with:
+          name: installer-${{ matrix.platform.name }}
+          path: target/${{ matrix.platform.target }}/release/installer${{ matrix.platform.os == 'windows-latest' && '.exe' || '' }}
+          if-no-files-found: error
+
+  build_release_zip:
+    permissions:
+      contents: read
+      packages: write
+    needs:
+      - build_rayhunter_check
+      - build_rootshell
+      - build_rayhunter
+      - build_rust_installer
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - linux-x64
+          - linux-aarch64
+          - linux-armv7
+          - macos-intel
+          - macos-arm
+          - windows-x86_64
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+      - name: Fix executable permissions on binaries
+        run: chmod +x installer-*/installer rayhunter-check-*/rayhunter-check rayhunter-daemon/rayhunter-daemon
+      - name: Get Rayhunter version
+        id: get_version
+        run: echo "VERSION=$(grep '^version' daemon/Cargo.toml | head -n 1 | cut -d'"' -f2)" >> $GITHUB_ENV
+      - name: Setup versioned release directory
+        run: |
+          platform="${{ matrix.platform }}"
+          dest="rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}"
+          mkdir "$dest"
+          mv installer-$platform/installer* "$dest"/installer
+          cp -r rayhunter-daemon rootshell/rootshell dist/* installer/install.ps1 "$dest"/
+          zip -r "$dest.zip" "$dest"
+          sha256sum "$dest.zip" > "$dest.zip.sha256"
+
+      - name: Upload zip release and sha256
+        uses: actions/upload-artifact@v4
+        with:
+          name: rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}
+          path: |
+            rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}.zip
+            rayhunter-v${{ env.VERSION }}-${{ matrix.platform }}.zip.sha256
+          if-no-files-found: error

.github/workflows/mdbook.yaml

@@ -1,47 +0,0 @@
-# On Repository Settings > Pages > Build and deployment
-# Set "Source" to GitHub Actions.
-name: Documentation
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-
-jobs:
-  mdbook_test:
-    name: Test mdBook Documentation builds
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install mdBook
-        run: |
-          cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
-      - name: Test mdBook
-        run: mdbook test
-
-  mdbook_publish:
-    if: ${{ github.event_name != 'pull_request' }}
-    needs: mdbook_test
-    permissions:
-      pages: write
-      contents: write
-      id-token: write
-    name: Publish mdBook to Github Pages
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install mdBook
-        run: |
-          cargo install mdbook --no-default-features --features search --vers "^0.4" --locked
-
-      - name: Build mdBook
-        run: mdbook build
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v4
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: book
-      - name: Deploy to Github Pages
-        uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -0,0 +1,48 @@
+# To use: navigate on Github to Actions, select "Release rayhunter" on the left, click "Run workflow" > "Run workflow" on the right.
+# https://github.com/EFForg/rayhunter/actions/workflows/release.yml
+name: Release rayhunter
+on:
+  workflow_dispatch:
+
+env:
+  GH_TOKEN: ${{ github.token }}
+
+jobs:
+  check_version_same:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Ensure all Cargo.toml files have the same version defined.
+        run: |
+          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
+            echo "all Cargo.toml files must have the same version defined"
+            exit 1
+          fi
+
+  main:
+    needs: check_version_same
+    permissions:
+      contents: write
+      id-token: write
+      packages: write
+      pages: write
+    uses: ./.github/workflows/main.yml
+
+  release:
+    runs-on: ubuntu-latest
+    needs: main
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+      - name: Create release
+        run: |
+          version=$(grep ^version lib/Cargo.toml | cut -d' ' -f3 | tr -d '"')
+          gh release create --generate-notes -t "Rayhunter v$version" "v$version" rayhunter-v${version}-*/rayhunter-v${version}*.zi*

Cargo.lock

@@ -5,7 +5,7 @@ version = 4
 [[package]]
 name = "adb_client"
 version = "2.1.11"
-source = "git+https://github.com/gaykitty/adb_client.git?rev=e732fc178a0eb237138e4091059ff5ffa241385a#e732fc178a0eb237138e4091059ff5ffa241385a"
+source = "git+https://github.com/EFForg/adb_client.git?rev=e511662394e4fa32865c154c40f81a3d846f700c#e511662394e4fa32865c154c40f81a3d846f700c"
 dependencies = [
  "async-io",
  "base64",
@@ -46,6 +46,17 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -157,9 +168,9 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "asn1-codecs"
-version = "0.6.1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e4ed1fe0647213e739f7ea78f50d3d0f6f9bef7285f6d8672aaca8365decfc3"
+checksum = "3eb148e3886345ed6c20c984393359bfda8220c82114ac5d12fcd54c0f393e91"
 dependencies = [
  "bitvec",
  "log",
@@ -169,10 +180,11 @@ dependencies = [
 
 [[package]]
 name = "asn1-compiler"
-version = "0.6.1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d056f38f3e98ffe9808e6a482d1527e4ded46e72b3dbe77305f5508e76c5f6"
+checksum = "7a0ab1fb91f80ed8e751a8cb3d38dc822031dbfb769731e9d4a8bc184a39a230"
 dependencies = [
+ "anyhow",
  "bitvec",
  "clap",
  "env_logger 0.10.2",
@@ -187,9 +199,9 @@ dependencies = [
 
 [[package]]
 name = "asn1_codecs_derive"
-version = "0.6.1"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "394acf8791d3d345ed71e2e820355c9f8ad4202a99b97e59fb7b6595b18f28cd"
+checksum = "129a9f02b40e743766102dbbb93464b5868fb5e264a02a10d87fb45c472dd4b7"
 dependencies = [
  "asn1-codecs",
  "bitvec",
@@ -240,6 +252,20 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "async_zip"
+version = "0.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b9f7252833d5ed4b00aa9604b563529dd5e11de9c23615de2dcdf91eb87b52"
+dependencies = [
+ "crc32fast",
+ "futures-lite",
+ "pin-project",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-util",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -283,7 +309,6 @@ checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5"
 dependencies = [
  "axum-core",
  "bytes",
- "form_urlencoded",
  "futures-util",
  "http",
  "http-body",
@@ -300,13 +325,11 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_path_to_error",
- "serde_urlencoded",
  "sync_wrapper",
  "tokio",
  "tower",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
@@ -326,7 +349,6 @@ dependencies = [
  "sync_wrapper",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
@@ -350,6 +372,12 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "base64_light"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c6aca08f76b8485947a20a1b3096e5a8cd6edbcecc6d2a8932df9b41d36aadf"
+
 [[package]]
 name = "base64ct"
 version = "1.7.3"
@@ -411,6 +439,15 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "built"
 version = "0.7.7"
@@ -504,6 +541,16 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clap"
 version = "4.5.38"
@@ -1431,19 +1478,32 @@ dependencies = [
  "hashbrown",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "installer"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
  "adb_client",
+ "aes",
  "anyhow",
  "axum",
+ "base64_light",
+ "block-padding",
  "bytes",
  "clap",
  "env_logger 0.11.8",
  "hyper",
  "hyper-util",
- "md5",
+ "md5 0.7.0",
+ "md5crypt",
  "nusb",
  "reqwest",
  "serde",
@@ -1685,6 +1745,21 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
+[[package]]
+name = "md5"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae960838283323069879657ca3de837e9f7bbb4c7bf6ea7f1b290d5e9476d2e0"
+
+[[package]]
+name = "md5crypt"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8db1a978f99f584f2e72601860f68bb2cea9c09f4408f5e83f805db3434fb0"
+dependencies = [
+ "md5 0.8.0",
+]
+
 [[package]]
 name = "mdns-sd"
 version = "0.13.9"
@@ -1711,16 +1786,6 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
-[[package]]
-name = "mime_guess"
-version = "2.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
-dependencies = [
- "mime",
- "unicase",
-]
-
 [[package]]
 name = "minimal-lexical"
 version = "0.2.1"
@@ -1878,6 +1943,28 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "num_enum"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "num_threads"
 version = "0.1.7"
@@ -1927,29 +2014,6 @@ version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
-[[package]]
-name = "parking_lot"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "paste"
 version = "1.0.15"
@@ -2160,6 +2224,19 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "pycrate-rs"
+version = "0.1.0"
+source = "git+https://github.com/EFForg/pycrate-rs#9e72e40bee9c3c09205ad871cf681628b443de7c"
+dependencies = [
+ "clap",
+ "deku",
+ "env_logger 0.11.8",
+ "log",
+ "serde",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "qoi"
 version = "0.4.1"
@@ -2307,7 +2384,7 @@ dependencies = [
 
 [[package]]
 name = "rayhunter"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
  "bytes",
  "chrono",
@@ -2317,7 +2394,9 @@ dependencies = [
  "libc",
  "log",
  "nix",
+ "num_enum",
  "pcap-file-tokio",
+ "pycrate-rs",
  "serde",
  "telcom-parser",
  "thiserror 1.0.69",
@@ -2325,12 +2404,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "rayhunter-daemon"
+name = "rayhunter-check"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
+ "clap",
+ "futures",
+ "log",
+ "pcap-file-tokio",
+ "rayhunter",
+ "simple_logger",
+ "tokio",
+ "walkdir",
+]
+
+[[package]]
+name = "rayhunter-daemon"
+version = "0.5.0"
+dependencies = [
+ "anyhow",
+ "async_zip",
  "axum",
  "chrono",
- "clap",
  "env_logger 0.11.8",
  "futures",
  "futures-macro",
@@ -2338,11 +2432,9 @@ dependencies = [
  "include_dir",
  "libc",
  "log",
- "mime_guess",
  "rayhunter",
  "serde",
  "serde_json",
- "simple_logger",
  "tempfile",
  "thiserror 1.0.69",
  "tokio",
@@ -2371,15 +2463,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "redox_syscall"
-version = "0.5.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
-dependencies = [
- "bitflags 2.9.1",
-]
-
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -2453,7 +2536,7 @@ checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"
 
 [[package]]
 name = "rootshell"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
  "nix",
 ]
@@ -2541,6 +2624,15 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -2826,7 +2918,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "telcom-parser"
-version = "0.3.3"
+version = "0.5.0"
 dependencies = [
  "asn1-codecs",
  "asn1-compiler",
@@ -2963,7 +3055,6 @@ dependencies = [
  "bytes",
  "libc",
  "mio",
- "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
@@ -3021,6 +3112,7 @@ checksum = "66a539a9ad6d5d281510d5bd368c973d636c02dbf8a67300bfb6b950696ad7df"
 dependencies = [
  "bytes",
  "futures-core",
+ "futures-io",
  "futures-sink",
  "futures-util",
  "hashbrown",
@@ -3088,7 +3180,6 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
- "tracing",
 ]
 
 [[package]]
@@ -3109,7 +3200,6 @@ version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
- "log",
  "pin-project-lite",
  "tracing-core",
 ]
@@ -3135,12 +3225,6 @@ version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
 
-[[package]]
-name = "unicase"
-version = "2.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
@@ -3199,6 +3283,16 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "want"
 version = "0.3.1"

Cargo.toml

@@ -2,7 +2,8 @@
 
 members = [
     "lib",
-    "bin",
+    "daemon",
+    "check",
     "rootshell",
     "telcom-parser",
     "installer",

README.md

@@ -2,6 +2,6 @@
 
 # Rayhunter
 
-![Tests](https://github.com/EFForg/rayhunter/actions/workflows/check-and-test.yml/badge.svg)
+![Tests](https://github.com/EFForg/rayhunter/actions/workflows/main.yml/badge.svg)
 
 Rayhunter is an IMSI Catcher Catcher for the Orbic mobile hotspot. To learn more, check out the [Rayhunter Book](https://efforg.github.io/rayhunter/).

bin/src/check.rs

@@ -1,176 +0,0 @@
-use clap::Parser;
-use futures::TryStreamExt;
-use log::{info, warn};
-use rayhunter::{
-    analysis::analyzer::{EventType, Harness},
-    diag::DataType,
-    gsmtap_parser,
-    pcap::GsmtapPcapWriter,
-    qmdl::QmdlReader,
-};
-use std::{collections::HashMap, future, path::PathBuf, pin::pin};
-use tokio::fs::{metadata, read_dir, File};
-
-mod dummy_analyzer;
-
-#[derive(Parser, Debug)]
-#[command(version, about)]
-struct Args {
-    #[arg(short = 'p', long)]
-    qmdl_path: PathBuf,
-
-    #[arg(short = 'c', long)]
-    pcapify: bool,
-
-    #[arg(long)]
-    show_skipped: bool,
-
-    #[arg(long)]
-    enable_dummy_analyzer: bool,
-
-    #[arg(short, long)]
-    verbose: bool,
-}
-
-async fn analyze_file(enable_dummy_analyzer: bool, qmdl_path: &str, show_skipped: bool) {
-    let mut harness = Harness::new_with_all_analyzers();
-    if enable_dummy_analyzer {
-        harness.add_analyzer(Box::new(dummy_analyzer::TestAnalyzer { count: 0 }));
-    }
-    let qmdl_file = &mut File::open(&qmdl_path).await.expect("failed to open file");
-    let file_size = qmdl_file
-        .metadata()
-        .await
-        .expect("failed to get QMDL file metadata")
-        .len();
-    let mut qmdl_reader = QmdlReader::new(qmdl_file, Some(file_size as usize));
-    let mut qmdl_stream = pin!(qmdl_reader
-        .as_stream()
-        .try_filter(|container| future::ready(container.data_type == DataType::UserSpace)));
-    let mut skipped_reasons: HashMap<String, i32> = HashMap::new();
-    let mut total_messages = 0;
-    let mut warnings = 0;
-    let mut skipped = 0;
-    while let Some(container) = qmdl_stream
-        .try_next()
-        .await
-        .expect("failed getting QMDL container")
-    {
-        let row = harness.analyze_qmdl_messages(container);
-        total_messages += 1;
-        for reason in row.skipped_message_reasons {
-            *skipped_reasons.entry(reason).or_insert(0) += 1;
-            skipped += 1;
-        }
-        for analysis in row.analysis {
-            for maybe_event in analysis.events {
-                let Some(event) = maybe_event else { continue };
-                match event.event_type {
-                    EventType::Informational => {
-                        info!(
-                            "{}: INFO - {} {}",
-                            qmdl_path, analysis.timestamp, event.message,
-                        );
-                    }
-                    EventType::QualitativeWarning { severity } => {
-                        warn!(
-                            "{}: WARNING (Severity: {:?}) - {} {}",
-                            qmdl_path, severity, analysis.timestamp, event.message,
-                        );
-                        warnings += 1;
-                    }
-                }
-            }
-        }
-    }
-    if show_skipped && skipped > 0 {
-        info!("{}: messages skipped:", qmdl_path);
-        for (reason, count) in skipped_reasons.iter() {
-            info!("    - {}: \"{}\"", count, reason);
-        }
-    }
-    info!(
-        "{}: {} messages analyzed, {} warnings, {} messages skipped",
-        qmdl_path, total_messages, warnings, skipped
-    );
-}
-
-async fn pcapify(qmdl_path: &PathBuf) {
-    let qmdl_file = &mut File::open(&qmdl_path)
-        .await
-        .expect("failed to open qmdl file");
-    let qmdl_file_size = qmdl_file.metadata().await.unwrap().len();
-    let mut qmdl_reader = QmdlReader::new(qmdl_file, Some(qmdl_file_size as usize));
-    let mut pcap_path = qmdl_path.clone();
-    pcap_path.set_extension("pcap");
-    let pcap_file = &mut File::create(&pcap_path)
-        .await
-        .expect("failed to open pcap file");
-    let mut pcap_writer = GsmtapPcapWriter::new(pcap_file).await.unwrap();
-    pcap_writer.write_iface_header().await.unwrap();
-    while let Some(container) = qmdl_reader
-        .get_next_messages_container()
-        .await
-        .expect("failed to get container")
-    {
-        for msg in container.into_messages().into_iter().flatten() {
-            if let Ok(Some((timestamp, parsed))) = gsmtap_parser::parse(msg) {
-                pcap_writer
-                    .write_gsmtap_message(parsed, timestamp)
-                    .await
-                    .expect("failed to write");
-            }
-        }
-    }
-    info!("wrote pcap to {:?}", &pcap_path);
-}
-
-#[tokio::main]
-async fn main() {
-    let args = Args::parse();
-    let level = if args.verbose {
-        log::LevelFilter::Trace
-    } else {
-        log::LevelFilter::Warn
-    };
-    simple_logger::SimpleLogger::new()
-        .with_colors(true)
-        .without_timestamps()
-        .with_level(level)
-        .init()
-        .unwrap();
-    info!("Analyzers:");
-
-    let mut harness = Harness::new_with_all_analyzers();
-    if args.enable_dummy_analyzer {
-        harness.add_analyzer(Box::new(dummy_analyzer::TestAnalyzer { count: 0 }));
-    }
-    for analyzer in harness.get_metadata().analyzers {
-        info!("    - {}: {}", analyzer.name, analyzer.description);
-    }
-
-    let metadata = metadata(&args.qmdl_path)
-        .await
-        .expect("failed to get metadata");
-    if metadata.is_dir() {
-        let mut dir = read_dir(&args.qmdl_path).await.expect("failed to read dir");
-        while let Some(entry) = dir.next_entry().await.expect("failed to get entry") {
-            let name = entry.file_name();
-            let name_str = name.to_str().unwrap();
-            if name_str.ends_with(".qmdl") {
-                let path = entry.path();
-                let path_str = path.to_str().unwrap();
-                analyze_file(args.enable_dummy_analyzer, path_str, args.show_skipped).await;
-                if args.pcapify {
-                    pcapify(&path).await;
-                }
-            }
-        }
-    } else {
-        let path = args.qmdl_path.to_str().unwrap();
-        analyze_file(args.enable_dummy_analyzer, path, args.show_skipped).await;
-        if args.pcapify {
-            pcapify(&args.qmdl_path).await;
-        }
-    }
-}

bin/src/display/mod.rs

@@ -1,28 +0,0 @@
-mod generic_framebuffer;
-
-#[cfg(feature = "tplink")]
-mod tplink;
-#[cfg(feature = "tplink")]
-mod tplink_framebuffer;
-#[cfg(feature = "tplink")]
-mod tplink_onebit;
-
-#[cfg(feature = "tplink")]
-pub use tplink::update_ui;
-
-#[cfg(feature = "orbic")]
-mod orbic;
-#[cfg(feature = "orbic")]
-pub use orbic::update_ui;
-
-pub enum DisplayState {
-    Recording,
-    Paused,
-    WarningDetected,
-}
-
-#[cfg(all(feature = "orbic", feature = "tplink"))]
-compile_error!("cannot compile for many devices at once");
-
-#[cfg(not(any(feature = "orbic", feature = "tplink")))]
-compile_error!("cannot compile for no device at all");

bin/src/dummy_analyzer.rs

@@ -1,51 +0,0 @@
-use std::borrow::Cow;
-
-use rayhunter::telcom_parser::lte_rrc::{PCCH_MessageType, PCCH_MessageType_c1, PagingUE_Identity};
-
-use rayhunter::analysis::analyzer::{Analyzer, Event, EventType, Severity};
-use rayhunter::analysis::information_element::{InformationElement, LteInformationElement};
-
-pub struct TestAnalyzer {
-    pub count: i32,
-}
-
-impl Analyzer for TestAnalyzer {
-    fn get_name(&self) -> Cow<str> {
-        Cow::from("Example Analyzer")
-    }
-
-    fn get_description(&self) -> Cow<str> {
-        Cow::from("Always returns true, if you are seeing this you are either a developer or you are about to have problems.")
-    }
-
-    fn analyze_information_element(&mut self, ie: &InformationElement) -> Option<Event> {
-        self.count += 1;
-        if self.count % 100 == 0 {
-            return Some(Event {
-                event_type: EventType::Informational,
-                message: "multiple of 100 events processed".to_string(),
-            });
-        }
-        let pcch_msg = match ie {
-            InformationElement::LTE(lte_ie) => match &**lte_ie {
-                LteInformationElement::PCCH(pcch_msg) => pcch_msg,
-                _ => return None,
-            },
-            _ => return None,
-        };
-        let PCCH_MessageType::C1(PCCH_MessageType_c1::Paging(paging)) = &pcch_msg.message else {
-            return None;
-        };
-        for record in &paging.paging_record_list.as_ref()?.0 {
-            if let PagingUE_Identity::S_TMSI(_) = record.ue_identity {
-                return Some(Event {
-                    event_type: EventType::QualitativeWarning {
-                        severity: Severity::Low,
-                    },
-                    message: "TMSI was provided to cell".to_string(),
-                });
-            }
-        }
-        None
-    }
-}

bin/src/key_input.rs

@@ -1,100 +0,0 @@
-use log::error;
-use std::time::{Duration, Instant};
-use tokio::fs::File;
-use tokio::io::AsyncReadExt;
-use tokio::sync::mpsc::Sender;
-use tokio_util::task::TaskTracker;
-
-use crate::config;
-use crate::diag::DiagDeviceCtrlMessage;
-
-#[derive(Debug)]
-enum Event {
-    KeyDown,
-    KeyUp,
-}
-
-const INPUT_EVENT_SIZE: usize = 32;
-
-pub fn run_key_input_thread(
-    task_tracker: &TaskTracker,
-    config: &config::Config,
-    diag_tx: Sender<DiagDeviceCtrlMessage>,
-) {
-    if config.key_input_mode == 0 {
-        return;
-    }
-
-    task_tracker.spawn(async move {
-        // Open the input device
-        let mut file = match File::open("/dev/input/event0").await {
-            Ok(file) => file,
-            Err(e) => {
-                error!("Failed to open /dev/input/event0: {}", e);
-                return;
-            }
-        };
-
-        let mut buffer = [0u8; INPUT_EVENT_SIZE];
-        let mut last_keyup: Option<Instant> = None;
-
-        loop {
-            if let Err(e) = file.read_exact(&mut buffer).await {
-                error!("failed to read key input: {}", e);
-                return;
-            }
-
-            let event = parse_event(buffer);
-
-            match event {
-                Event::KeyUp => {
-                    if last_keyup.is_some()
-                        && last_keyup.unwrap().elapsed() < Duration::from_millis(500)
-                    {
-                        if let Err(e) = diag_tx.send(DiagDeviceCtrlMessage::StopRecording).await {
-                            error!("Failed to send StopRecording: {}", e);
-                        }
-                        if let Err(e) = diag_tx.send(DiagDeviceCtrlMessage::StartRecording).await {
-                            error!("Failed to send StartRecording: {}", e);
-                        }
-                        last_keyup = None;
-                    } else {
-                        last_keyup = Some(Instant::now());
-                    }
-                }
-                Event::KeyDown => {}
-            }
-        }
-    });
-}
-
-fn parse_event(input: [u8; INPUT_EVENT_SIZE]) -> Event {
-    if input[12] == 0 {
-        Event::KeyUp
-    } else {
-        Event::KeyDown
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_event_keydown_m7350_v5() {
-        let input = [
-            0x57, 0x6c, 0x09, 0x00, 0x7c, 0xfb, 0x03, 0x00, 0x01, 0x00, 0x74, 0x00, 0x01, 0x00,
-            0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        ];
-        assert!(matches!(parse_event(input), Event::KeyDown));
-    }
-
-    #[test]
-    fn test_parse_event_keyup_m7350_v5() {
-        let input = [
-            0x57, 0x6c, 0x09, 0x00, 0x1b, 0x15, 0x05, 0x00, 0x01, 0x00, 0x74, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        ];
-        assert!(matches!(parse_event(input), Event::KeyUp));
-    }
-}

bin/src/server.rs

@@ -1,78 +0,0 @@
-use axum::body::Body;
-use axum::extract::Path;
-use axum::extract::State;
-use axum::http::header::{self, CONTENT_LENGTH, CONTENT_TYPE};
-use axum::http::{HeaderValue, StatusCode};
-use axum::response::{IntoResponse, Response};
-use include_dir::{include_dir, Dir};
-use std::sync::Arc;
-use tokio::io::AsyncReadExt;
-use tokio::sync::mpsc::Sender;
-use tokio::sync::RwLock;
-use tokio_util::io::ReaderStream;
-
-use crate::analysis::{AnalysisCtrlMessage, AnalysisStatus};
-use crate::qmdl_store::RecordingStore;
-use crate::{display, DiagDeviceCtrlMessage};
-
-pub struct ServerState {
-    pub qmdl_store_lock: Arc<RwLock<RecordingStore>>,
-    pub diag_device_ctrl_sender: Sender<DiagDeviceCtrlMessage>,
-    pub ui_update_sender: Sender<display::DisplayState>,
-    pub analysis_status_lock: Arc<RwLock<AnalysisStatus>>,
-    pub analysis_sender: Sender<AnalysisCtrlMessage>,
-    pub debug_mode: bool,
-}
-
-pub async fn get_qmdl(
-    State(state): State<Arc<ServerState>>,
-    Path(qmdl_name): Path<String>,
-) -> Result<Response, (StatusCode, String)> {
-    let qmdl_idx = qmdl_name.trim_end_matches(".qmdl");
-    let qmdl_store = state.qmdl_store_lock.read().await;
-    let (entry_index, entry) = qmdl_store.entry_for_name(qmdl_idx).ok_or((
-        StatusCode::NOT_FOUND,
-        format!("couldn't find qmdl file with name {}", qmdl_idx),
-    ))?;
-    let qmdl_file = qmdl_store.open_entry_qmdl(entry_index).await.map_err(|e| {
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("error opening QMDL file: {}", e),
-        )
-    })?;
-    let limited_qmdl_file = qmdl_file.take(entry.qmdl_size_bytes as u64);
-    let qmdl_stream = ReaderStream::new(limited_qmdl_file);
-
-    let headers = [
-        (CONTENT_TYPE, "application/octet-stream"),
-        (CONTENT_LENGTH, &entry.qmdl_size_bytes.to_string()),
-    ];
-    let body = Body::from_stream(qmdl_stream);
-    Ok((headers, body).into_response())
-}
-
-// Bundles the server's static files (html/css/js) into the binary for easy distribution
-static STATIC_DIR: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/web/build");
-
-pub async fn serve_static(
-    State(_): State<Arc<ServerState>>,
-    Path(path): Path<String>,
-) -> impl IntoResponse {
-    let path = path.trim_start_matches('/');
-    let mime_type = mime_guess::from_path(path).first_or_text_plain();
-
-    match STATIC_DIR.get_file(path) {
-        None => Response::builder()
-            .status(StatusCode::NOT_FOUND)
-            .body(Body::empty())
-            .unwrap(),
-        Some(file) => Response::builder()
-            .status(StatusCode::OK)
-            .header(
-                header::CONTENT_TYPE,
-                HeaderValue::from_str(mime_type.as_ref()).unwrap(),
-            )
-            .body(Body::from(file.contents()))
-            .unwrap(),
-    }
-}

bin/web/.prettierrc

@@ -1,17 +0,0 @@
-{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"printWidth": 100,
-	"plugins": [
-		"prettier-plugin-svelte"
-	],
-	"overrides": [
-		{
-			"files": "*.svelte",
-			"options": {
-				"parser": "svelte"
-			}
-		}
-	]
-}

bin/web/eslint.config.js

@@ -1,33 +0,0 @@
-import prettier from "eslint-config-prettier";
-import js from '@eslint/js';
-import svelte from 'eslint-plugin-svelte';
-import globals from 'globals';
-import ts from 'typescript-eslint';
-
-export default ts.config(
-  js.configs.recommended,
-  ...ts.configs.recommended,
-  ...svelte.configs["flat/recommended"],
-  prettier,
-  ...svelte.configs['flat/prettier'],
-  {
-    languageOptions: {
-	  globals: {
-	    ...globals.browser,
-	    ...globals.node
-	  }
-	}
-  },
-  {
-    files: ["**/*.svelte"],
-
-    languageOptions: {
-	  parserOptions: {
-	    parser: ts.parser
-	  }
-	}
-  },
-  {
-    ignores: ["build/", ".svelte-kit/", "dist/"]
-  }
-);

bin/web/package.json

@@ -1,37 +0,0 @@
-{
-	"name": "web",
-	"version": "0.0.1",
-	"type": "module",
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build",
-		"preview": "vite preview",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-		"test:unit": "vitest",
-		"test": "npm run test:unit -- --run",
-		"format": "prettier --write .",
-		"lint": "prettier --check . && eslint ."
-	},
-	"devDependencies": {
-		"@sveltejs/adapter-auto": "^3.0.0",
-		"@sveltejs/adapter-static": "^3.0.5",
-		"@sveltejs/kit": "^2.0.0",
-		"@sveltejs/vite-plugin-svelte": "^4.0.0",
-		"@types/eslint": "^9.6.0",
-		"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"
-	}
-}

bin/web/postcss.config.js

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

bin/web/src/app.css

@@ -1,3 +0,0 @@
-@import "tailwindcss/base";
-@import "tailwindcss/components";
-@import "tailwindcss/utilities"

bin/web/src/app.d.ts

@@ -1,13 +0,0 @@
-// See https://svelte.dev/docs/kit/types#app
-// for information about these interfaces
-declare global {
-	namespace App {
-		// interface Error {}
-		// interface Locals {}
-		// interface PageData {}
-		// interface PageState {}
-		// interface Platform {}
-	}
-}
-
-export {};

bin/web/src/app.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en" data-theme="dark">
-	<head>
-		<meta charset="utf-8" />
-		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
-		<meta name="viewport" content="width=device-width, initial-scale=1" />
-		%sveltekit.head%
-	</head>
-	<body data-sveltekit-preload-data="hover">
-		<div style="display: contents" class="m-4 xl:m-8">%sveltekit.body%</div>
-	</body>
-</html>

bin/web/src/lib/analysis.spec.svelte.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { EventType, parse_finished_report, Severity, type QualitativeWarning } from './analysis.svelte';
-import { parse_ndjson, type NewlineDeliminatedJson } from './ndjson';
-
-const SAMPLE_REPORT_NDJSON: NewlineDeliminatedJson = [
-    { "analyzers": [{ "name": "LTE SIB 6/7 Downgrade", "description": "Tests for LTE cells broadcasting a SIB type 6 and 7 which include 2G/3G frequencies with higher priorities." }, { "name": "IMSI Provided", "description": "Tests whether the UE's IMSI was ever provided to the cell" }, { "name": "Null Cipher", "description": "Tests whether the cell suggests using a null cipher (EEA0)" }, { "name": "Example Analyzer", "description": "Always returns true, if you are seeing this you are either a developer or you are about to have problems." }] },
-    { "timestamp": "2024-10-08T13:25:43.011689003-07:00", "skipped_message_reasons": ["DecodingError(UperDecodeError(Error { cause: BufferTooShort, msg: \"PerCodec:DecodeError:Requested Bits to decode 3, Remaining bits 1\", context: [] }))"], "analysis": [] },
-    { "timestamp": "2024-10-08T13:25:43.480872496-07:00", "skipped_message_reasons": [], "analysis": [{ "timestamp": "2024-08-19T03:33:54.318Z", "events": [null, null, null, { "event_type": { "type": "QualitativeWarning", "severity": "Low" }, "message": "TMSI was provided to cell" }] }] },
-];
-
-describe('analysis report parsing', () => {
-	it('parses the example analysis', () => {
-        const report = parse_finished_report(SAMPLE_REPORT_NDJSON);
-        expect(report.metadata.analyzers).toEqual([
-            {
-                "name":"LTE SIB 6/7 Downgrade",
-                "description":"Tests for LTE cells broadcasting a SIB type 6 and 7 which include 2G/3G frequencies with higher priorities.",
-            },
-            {
-                "name":"IMSI Provided",
-                "description":"Tests whether the UE's IMSI was ever provided to the cell",
-            },
-            {
-                "name":"Null Cipher",
-                "description":"Tests whether the cell suggests using a null cipher (EEA0)",
-            },
-            {
-                "name":"Example Analyzer",
-                "description":"Always returns true, if you are seeing this you are either a developer or you are about to have problems.",
-            }
-        ]);
-        expect(report.rows).toHaveLength(2);
-        expect(report.rows[0].skipped_message_reasons).toHaveLength(1);
-        expect(report.rows[0].analysis).toHaveLength(0);
-        expect(report.rows[1].skipped_message_reasons).toHaveLength(0);
-        expect(report.rows[1].analysis).toHaveLength(1);
-        expect(report.rows[1].analysis[0].events).toHaveLength(1);
-        const event = report.rows[1].analysis[0].events[0];
-        if (event.type === EventType.Warning) {
-            expect(event.severity).toEqual(Severity.Low);
-        } else {
-            throw 'wrong event type';
-        }
-	});
-});

bin/web/src/lib/analysis.svelte.ts

@@ -1,118 +0,0 @@
-import { parse_ndjson, type NewlineDeliminatedJson } from "./ndjson";
-import { req } from "./utils.svelte";
-
-export type AnalysisReport = {
-    metadata: ReportMetadata;
-    rows: AnalysisRow[];
-    statistics: ReportStatistics;
-};
-
-export type ReportStatistics = {
-    num_warnings: number;
-    num_informational_logs: number;
-    num_skipped_packets: number;
-}
-
-export type ReportMetadata = {
-    analyzers: AnalyzerMetadata[];
-    rayhunter: RayhunterMetadata;
-};
-
-export type RayhunterMetadata = {
-    rayhunter_version: string;
-    system_os: string;
-    arch: string;
-};
-
-export type AnalyzerMetadata = {
-    name: string;
-    description: string;
-};
-
-export type AnalysisRow = {
-    timestamp: Date;
-    skipped_message_reasons: string[];
-    analysis: PacketAnalysis[];
-};
-
-export type PacketAnalysis = {
-    timestamp: Date;
-    events: Event[];
-};
-export type Event = QualitativeWarning | InformationalEvent;
-export enum EventType {
-    Informational,
-    Warning,
-}
-
-export type QualitativeWarning = {
-    type: EventType.Warning;
-    severity: Severity;
-    message: string;
-};
-
-export enum Severity {
-    Low,
-    Medium,
-    High,
-}
-
-export type InformationalEvent = {
-    type: EventType.Informational;
-    message: string;
-};
-
-export function parse_finished_report(report_json: NewlineDeliminatedJson): AnalysisReport {
-    const metadata: ReportMetadata = report_json[0]; // this can be cast directly
-    let num_warnings = 0;
-    let num_informational_logs = 0;
-    let num_skipped_packets = 0;
-    const rows: AnalysisRow[] = report_json.slice(1).map((row_json: any) => {
-        const analysis: PacketAnalysis[] = row_json.analysis.map((analysis_json: any) => {
-            const events: Event[] = analysis_json.events.map((event_json: any): Event | null => {
-                    if (event_json === null) {
-                        return null;
-                    } else if (event_json.event_type.type === "Informational") {
-                        num_informational_logs += 1;
-                        return {
-                            type: EventType.Informational,
-                            message: event_json.message,
-                        };
-                    } else {
-                        num_warnings += 1;
-                        return {
-                            type: EventType.Warning,
-                            severity: event_json.event_type.severity === "High" ? Severity.High :
-                                event_json.event_type.severity === "Medium" ? Severity.Medium : Severity.Low,
-                            message: event_json.message,
-                        };
-                    }
-                })
-                .filter((maybe_event: Event | null) => maybe_event !== null);
-            return {
-                timestamp: analysis_json.timestamp,
-                events,
-            };
-        });
-        num_skipped_packets += row_json.skipped_message_reasons.length;
-        return {
-            timestamp: new Date(row_json.timestamp),
-            skipped_message_reasons: row_json.skipped_message_reasons,
-            analysis,
-        };
-    });
-    return {
-        statistics: {
-            num_informational_logs,
-            num_warnings,
-            num_skipped_packets,
-        },
-        metadata,
-        rows,
-    };
-}
-
-export async function get_report(name: string): Promise<AnalysisReport> {
-    const report_json = parse_ndjson(await req('GET', `/api/analysis-report/${name}`));
-    return parse_finished_report(report_json);
-}

bin/web/src/lib/components/AnalysisStatus.svelte

@@ -1,52 +0,0 @@
-<script lang="ts">
-	import { AnalysisStatus } from "$lib/analysisManager.svelte";
-	import { EventType } from "$lib/analysis.svelte";
-	import type { ManifestEntry } from "$lib/manifest.svelte";
-    let { entry, onclick, analysis_visible}: {
-        entry: ManifestEntry,
-        onclick: () => void,
-        analysis_visible: boolean,
-    } = $props();
-
-    let summary = $derived.by(() => {
-        if (entry.analysis_status === AnalysisStatus.Queued) {
-            return 'Queued...';
-        } else if (entry.analysis_status === AnalysisStatus.Running) {
-            return 'Running...';
-        } else if (entry.analysis_status === AnalysisStatus.Finished) {
-            if (entry.analysis_report === undefined) {
-                return 'Loading...';
-            } else if (typeof(entry.analysis_report) === 'string') {
-                return entry.analysis_report;
-            } else {
-                let num_warnings = 0;
-                for (let row of entry.analysis_report.rows) {
-                    for (let analysis of row.analysis) {
-                        for (let event of analysis.events) {
-                            if (event.type === EventType.Warning) {
-                                num_warnings += 1;
-                            }
-                        }
-                    }
-                }
-                return `${num_warnings} warnings`;
-            }
-        } else {
-            return 'Loading...';
-        }
-    });
-
-    let ready = $derived.by(() => {
-        let finished = entry.analysis_status === AnalysisStatus.Finished;
-        let report_available = entry.analysis_report !== undefined;
-        return finished && report_available;
-    })
-
-    let button_class = $derived(ready ? "text-blue-600 border rounded-full px-2" : '');
-</script>
-<button class="flex flex-row gap-1 lg:gap-2" disabled={!ready} {onclick}>
-    <span class="{button_class} {entry.get_num_warnings() < 1 ? 'text-green-700 border-green-500 bg-green-200' : 'text-red-700 border-red-500 bg-red-200'}">{summary}</span>
-    <svg class="w-6 h-6 text-gray-800 transition-transform {analysis_visible ? 'rotate-180' : ''}" 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="m19 9-7 7-7-7"/>
-    </svg>
-</button>

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

@@ -1,87 +0,0 @@
-<script lang="ts">
-	import { AnalysisStatus } from "$lib/analysisManager.svelte";
-	import { EventType, type AnalyzerMetadata, type ReportMetadata, type AnalysisRow, type AnalysisReport } from "$lib/analysis.svelte";
-	import type { ManifestEntry } from "$lib/manifest.svelte";
-    let { report }: {
-        report: AnalysisReport,
-    } = $props();
-
-    const date_formatter = new Intl.DateTimeFormat(undefined, {
-        timeStyle: "long",
-        dateStyle: "short",
-    });
-
-    const skipped_messages: Map<string, number> = $derived.by(() => {
-        let map = new Map();
-        for (const row of report.rows) {
-            for (const message of row.skipped_message_reasons) {
-                let count = map.get(message);
-                if (count === undefined) {
-                    count = 0;
-                }
-                map.set(message, count + 1);
-            }
-        }
-        return map;
-    });
-</script>
-<div>
-    <p class="text-lg underline">Warnings and Informational Logs</p>
-    {#if report.statistics.num_warnings === 0 && report.statistics.num_informational_logs === 0}
-        <p>Nothing to show!</p>
-    {:else}
-        <table class="table-auto text-left">
-            <thead class="p-2">
-                <tr class="bg-gray-300">
-                    <th class="p-2">Timestamp</th>
-                    <th class="p-2">Warning</th>
-                    <th class="p-2">Severity</th>
-                </tr>
-            </thead>
-            <tbody>
-                {#each report.rows as row, row_idx}
-                    {#each row.analysis as analysis}
-                        {@const parsed_date = new Date(analysis.timestamp)}
-                        {#each analysis.events.filter(e => e !== null) as event}
-                            <tr class="even:bg-gray-200 odd:bg-white">
-                            {#if event.type === EventType.Warning}
-                            {@const severity = ['Low', 'Medium', 'High'][event.severity]}
-                                {@const severity_class = ['bg-red-200', 'bg-red-400', 'bg-red-600'][event.severity]}
-                                <td class="p-2">{date_formatter.format(parsed_date)}</td>
-                                <td class="p-2">{event.message}</td>
-                                <td class="p-2 {severity_class} text-center">{severity}</td>
-                            {:else if event.type === EventType.Informational}
-                                <td class="p-2">{date_formatter.format(parsed_date)}</td>
-                                <td class="p-2">{event.message}</td>
-                                <td class="p-2">Info</td>
-                            {/if}
-                            </tr>
-                        {/each}
-                    {/each}
-                {/each}
-            </tbody>
-        </table>
-    {/if}
-</div>
-{#if report.statistics.num_skipped_packets > 0}
-<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 ususally a problem.</p>
-    <table class="table-auto text-left">
-        <thead class="p-2">
-            <tr class="bg-gray-300">
-                <th scope="col" class="p-2">Total Msgs Affected</th>
-                <th scope="col">Reason/Error</th>
-            </tr>
-        </thead>
-        <tbody>
-            {#each skipped_messages.entries() as [message, count]}
-                <tr class="even:bg-gray-200 odd:bg-white">
-                    <td class="text-center">{count}</td>
-                    <td>{message}</td>
-                </tr>
-            {/each}
-        </tbody>
-    </table>
-</div>
-{/if}

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

@@ -1,46 +0,0 @@
-<script lang="ts">
-	import { AnalysisStatus } from "$lib/analysisManager.svelte";
-	import { EventType, type AnalyzerMetadata, type ReportMetadata, type AnalysisRow } from "$lib/analysis.svelte";
-	import type { ManifestEntry } from "$lib/manifest.svelte";
-	import AnalysisTable from "./AnalysisTable.svelte";
-    let { entry }: {
-        entry: ManifestEntry,
-    } = $props();
-
-    const date_formatter = new Intl.DateTimeFormat(undefined, {
-        timeStyle: "long",
-        dateStyle: "short",
-    });
-</script>
-
-<div class="container mt-2">
-    {#if entry.analysis_report === undefined}
-        <p>Report unavailable, try refreshing.</p>
-    {:else if typeof(entry.analysis_report) === 'string'}
-        <p>Error getting analysis report: {entry.analysis_report}</p>
-    {:else}
-        {@const metadata: ReportMetadata = entry.analysis_report.metadata}
-        <div class="flex flex-col gap-2">
-            {#if entry.analysis_report.rows.length > 0}
-                <AnalysisTable report={entry.analysis_report} />
-            {:else}
-                <p>No warnings to display!</p>
-            {/if}
-            {#if metadata !== undefined && metadata.rayhunter !== undefined}
-            <div>
-                <p class="text-lg underline">Metadata</p>
-                <p>Analysis by Rayhunter version {metadata.rayhunter.rayhunter_version}</p>
-                <p><b>Device system OS:</b> {metadata.rayhunter.system_os}</p>
-            </div>
-            <div>
-                <p class="text-lg underline">Analyzers</p>
-                {#each metadata.analyzers as analyzer}
-                    <p><b>{analyzer.name}:</b> {analyzer.description}</p>
-                {/each}
-            </div>
-            {:else}
-                <p>N/A (analysis generated by an older version of rayhunter)</p>
-            {/if}
-        </div>
-    {/if}
-</div>

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

@@ -1,18 +0,0 @@
-<script lang="ts">
-	import { req } from "$lib/utils.svelte";
-	import DeleteButton from "./DeleteButton.svelte";
-
-    function confirmDelete() {
-        if (window.confirm(`Permanently delete ALL recordings?`)) {
-            req('POST', '/api/delete-all-recordings')
-        }
-    }
-</script>
-
-<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`}
-    />
-</div>

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

@@ -1,28 +0,0 @@
-<script lang="ts">
-    import { ManifestEntry } from "$lib/manifest.svelte";
-	import { req } from "$lib/utils.svelte";
-    let { text, url, prompt }: {
-        text?: string,
-        url: string,
-        prompt: string,
-    } = $props();
-
-    function confirmDelete() {
-        if (window.confirm(prompt)) {
-            req('POST', url)
-        }
-    }
-</script>
-
-<button class="bg-red-500 hover:bg-red-700 text-white font-bold py-2 px-4 rounded-md flex flex-row" onclick={confirmDelete} aria-label="delete">
-    <p>{text}</p>
-    <svg
-        style="width:24px;height:24px"
-        viewBox="0 0 24 24"
-    >
-        <path
-        fill="white"
-        d="M19,4H15.5L14.5,3H9.5L8.5,4H5V6H19M6,19A2,2 0 0,0 8,21H16A2,2 0 0,0 18,19V7H6V19Z"
-        />
-    </svg>
-</button>

bin/web/src/lib/components/DownloadLink.svelte

@@ -1,18 +0,0 @@
-<script lang="ts">
-    let { url, text, full_button=false }: {
-        url: string;
-        text: string;
-        full_button?: boolean;
-    } = $props();
-
-    function download() {
-        window.location.href = url;
-    }
-</script>
-
-<button class="flex flex-row {full_button ? 'bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded-md' : 'text-blue-600 underline'}" onclick={download}>
-    {text}
-    <svg class="fill-current w-4 h-4 m-1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
-        <path d="M13 8V2H7v6H2l8 8 8-8h-5zM0 18h20v2H0v-2z"/>
-    </svg>
-</button>

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

@@ -1,37 +0,0 @@
-<script lang="ts">
-    import { Manifest, ManifestEntry } from "$lib/manifest.svelte";
-    import TableRow from "./ManifestTableRow.svelte";
-    import Card from "./ManifestCard.svelte"
-    interface Props {
-        entries: ManifestEntry[];
-        server_is_recording: boolean;
-    }
-    let { entries, server_is_recording }: Props = $props();
-</script>
-
-<!--For larger screens we use a table-->
-<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">PCAP</th>
-            <th class='p-2' scope="col">QMDL</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} />
-        {/each}
-    </tbody>
-</table>
-<!--For smaller screens we use cards-->
-<div class="lg:hidden flex flex-col gap-4">
-    {#each entries as entry, i}
-        <Card {entry} current={false} {i} />
-    {/each}
-</div>

bin/web/src/lib/components/RecordingControls.svelte

@@ -1,46 +0,0 @@
-<script lang="ts">
-    import { req } from "$lib/utils.svelte";
-    let { server_is_recording }: {
-        server_is_recording: boolean;
-    } = $props();
-
-    let client_set_recording = $state(server_is_recording);
-    let waiting_for_server = $derived(client_set_recording !== server_is_recording);
-
-    async function start_recording() {
-        await req('POST', '/api/start-recording');
-        client_set_recording = true;
-    }
-
-    async function stop_recording() {
-        await req('POST', '/api/stop-recording');
-        client_set_recording = false;
-    }
-
-    const recording_button_classes = "text-white font-bold py-2 px-4 rounded-md flex flex-row gap-1";
-</script>
-
-<div>
-    {#if waiting_for_server}
-        <button class={server_is_recording ? stop_recording_classes : start_recording_classes}>
-            {server_is_recording ? "Stopping..." : "Starting..."}
-        </button>
-    {:else if server_is_recording}
-        <button class="{recording_button_classes} bg-red-500 hover:bg-red-700" onclick={stop_recording}>
-            <span>Stop</span>
-            <svg class="w-6 h-6 text-white" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="24" height="24" fill="currentColor" viewBox="0 0 24 24">
-                <path d="M7 5a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2H7Z"/>
-            </svg>
-        </button>
-    {:else}
-        <button class="{recording_button_classes} bg-blue-500 hover:bg-blue-700" onclick={start_recording}>
-            <span>Start</span>
-            <svg class="w-6 h-6 text-white" 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="M8.6 5.2A1 1 0 0 0 7 6v12a1 1 0 0 0 1.6.8l8-6a1 1 0 0 0 0-1.6l-8-6Z" clip-rule="evenodd"/>
-            </svg>
-        </button>
-    {/if}
-</div>
-
-<style>
-</style>

bin/web/src/lib/systemStats.ts

@@ -1,26 +0,0 @@
-export interface SystemStats {
-    disk_stats: DiskStats;
-    memory_stats: MemoryStats;
-    runtime_metadata: RuntimeMetadata;
-}
-
-export interface RuntimeMetadata {
-    rayhunter_version: string,
-    system_os: string,
-    arch: string,
-}
-
-export interface DiskStats {
-    partition: string,
-    total_size: string,
-    used_size: string,
-    available_size: string,
-    used_percent: string,
-    mounted_on: string,
-}
-
-export interface MemoryStats {
-    total: string,
-    used: string,
-    free: string,
-}

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

@@ -1,23 +0,0 @@
-import { Manifest } from "./manifest.svelte";
-import type { SystemStats } from "./systemStats";
-
-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 body;
-    } else {
-        throw new Error(body);
-    }
-}
-
-export async function get_manifest(): Promise<Manifest> {
-    const manifest_json = JSON.parse(await req('GET', '/api/qmdl-manifest'));
-    return new Manifest(manifest_json);
-}
-
-export async function get_system_stats(): Promise<SystemStats> {
-    return JSON.parse(await req('GET', '/api/system-stats'));
-}

bin/web/src/routes/+layout.svelte

@@ -1,6 +0,0 @@
-<script lang="ts">
-	import '../app.css';
-	let { children } = $props();
-</script>
-
-{@render children()}

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

@@ -1,84 +0,0 @@
-<script lang="ts">
-    import { ManifestEntry } from "$lib/manifest.svelte";
-    import { get_manifest, get_system_stats } from "$lib/utils.svelte";
-    import ManifestTable from "$lib/components/ManifestTable.svelte";
-    import Card from "$lib/components/ManifestCard.svelte";
-    import type { SystemStats } from "$lib/systemStats";
-    import { AnalysisManager } from "$lib/analysisManager.svelte";
-	import SystemStatsTable from "$lib/components/SystemStatsTable.svelte";
-	import DeleteAllButton from "$lib/components/DeleteAllButton.svelte";
-    import RecordingControls from "$lib/components//RecordingControls.svelte";
-
-    let manager: AnalysisManager = new AnalysisManager();
-    let loaded = $state(false);
-    let recording = $state(false);
-    let entries: ManifestEntry[] = $state([]);
-    let current_entry: ManifestEntry | undefined = $state(undefined);
-    let system_stats: SystemStats | undefined = $state(undefined);
-    $effect(() => {
-        const interval = setInterval(async () => {
-            await manager.update();
-            let new_manifest = await get_manifest();
-            await new_manifest.set_analysis_status(manager);
-            entries = new_manifest.entries;
-            current_entry = new_manifest.current_entry;
-            recording = current_entry !== undefined;
-
-            system_stats = await get_system_stats();
-            loaded = true;
-        }, 1000);
-
-        return () => clearInterval(interval);
-    })
-</script>
-
-<div class="p-4 xl:px-8 bg-rayhunter-blue drop-shadow flex flex-row justify-between items-center">
-    <img src="/rayhunter_text.png" class="h-10 xl:h-12"/>
-    <div class="flex flex-row gap-4">
-        <a class="flex flex-row gap-1 group" href="https://github.com/EFForg/rayhunter/issues" target="_blank">
-            <span class="hidden text-white group-hover:text-gray-400 lg:flex">Report Issue</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 fill-rule="evenodd" d="M12.006 2a9.847 9.847 0 0 0-6.484 2.44 10.32 10.32 0 0 0-3.393 6.17 10.48 10.48 0 0 0 1.317 6.955 10.045 10.045 0 0 0 5.4 4.418c.504.095.683-.223.683-.494 0-.245-.01-1.052-.014-1.908-2.78.62-3.366-1.21-3.366-1.21a2.711 2.711 0 0 0-1.11-1.5c-.907-.637.07-.621.07-.621.317.044.62.163.885.346.266.183.487.426.647.71.135.253.318.476.538.655a2.079 2.079 0 0 0 2.37.196c.045-.52.27-1.006.635-1.37-2.219-.259-4.554-1.138-4.554-5.07a4.022 4.022 0 0 1 1.031-2.75 3.77 3.77 0 0 1 .096-2.713s.839-.275 2.749 1.05a9.26 9.26 0 0 1 5.004 0c1.906-1.325 2.74-1.05 2.74-1.05.37.858.406 1.828.101 2.713a4.017 4.017 0 0 1 1.029 2.75c0 3.939-2.339 4.805-4.564 5.058a2.471 2.471 0 0 1 .679 1.897c0 1.372-.012 2.477-.012 2.814 0 .272.18.592.687.492a10.05 10.05 0 0 0 5.388-4.421 10.473 10.473 0 0 0 1.313-6.948 10.32 10.32 0 0 0-3.39-6.165A9.847 9.847 0 0 0 12.007 2Z" clip-rule="evenodd"/>
-            </svg>
-        </a>
-        <a class="flex flex-row gap-1 group" href="https://efforg.github.io/rayhunter/" target="_blank">
-            <span class="hidden text-white group-hover:text-gray-400 lg:flex">Docs</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="M5 19V4a1 1 0 0 1 1-1h12a1 1 0 0 1 1 1v13H7a2 2 0 0 0-2 2Zm0 0a2 2 0 0 0 2 2h12M9 3v14m7 0v4"/>
-            </svg>
-        </a>
-    </div>
-</div>
-<div class="m-4 xl:mx-8 flex flex-col gap-4">
-{#if loaded}
-    <div class="flex flex-col lg:flex-row gap-4">
-        {#if recording}
-            <Card entry={current_entry} current={true} i={0} server_is_recording={recording}/>
-        {:else}
-            <div 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 class="w-8 h-8 text-red-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 0v5a1 1 0 1 0 2 0V8Zm-1 7a1 1 0 1 0 0 2h.01a1 1 0 1 0 0-2H12Z" clip-rule="evenodd"/>
-                    </svg>
-                    WARNING: Not Running
-                </span>
-                <span>Rayhunter is not currently running and will not detect abnormal behavior!</span>
-                <div class="flex flex-row justify-end mt-2">
-                    <RecordingControls {recording} />
-                </div>
-            </div>
-        {/if}
-        <SystemStatsTable stats={system_stats!} />
-    </div>
-    <div class="flex flex-col gap-2">
-        <span class="text-xl">History</span>
-        <ManifestTable entries={entries} server_is_recording={recording} />
-    </div>
-    <DeleteAllButton/>
-{:else}
-    <div class="flex flex-col justify-center items-center">
-        <img src="/rayhunter_orca_only.png" class="h-48 animate-spin"/>
-        <p class="text-xl">Loading...</p>
-    </div>
-{/if}
-</div>

bin/web/svelte.config.js

@@ -1,15 +0,0 @@
-import adapter from '@sveltejs/adapter-static';
-
-export default {
-	kit: {
-		adapter: adapter({
-			// default options are shown. On some platforms
-			// these options are set automatically — see below
-			pages: 'build',
-			assets: 'build',
-			fallback: undefined,
-			precompress: false,
-			strict: true
-		})
-	}
-};

bin/web/tailwind.config.ts

@@ -1,17 +0,0 @@
-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;

bin/web/tsconfig.json

@@ -1,19 +0,0 @@
-{
-	"extends": "./.svelte-kit/tsconfig.json",
-	"compilerOptions": {
-		"allowJs": true,
-		"checkJs": true,
-		"esModuleInterop": true,
-		"forceConsistentCasingInFileNames": true,
-		"resolveJsonModule": true,
-		"skipLibCheck": true,
-		"sourceMap": true,
-		"strict": true,
-		"moduleResolution": "bundler"
-	}
-	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
-	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
-	//
-	// If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes
-	// from the referenced tsconfig.json - TypeScript does not merge them in
-}

book.toml

@@ -3,3 +3,6 @@ authors = ["The Rayhunter Team"]
 language = "en"
 src = "doc"
 title = "Rayhunter - An IMSI Catcher Catcher"
+
+[output.html]
+edit-url-template = "https://github.com/efforg/rayhunter/edit/main/{path}"

check/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "rayhunter-check"
+version = "0.5.0"
+edition = "2024"
+
+[dependencies]
+rayhunter = { path = "../lib" }
+futures = { version = "0.3.30", default-features = false }
+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

@@ -0,0 +1,221 @@
+use clap::Parser;
+use futures::TryStreamExt;
+use log::{debug, error, info, warn};
+use pcap_file_tokio::pcapng::{Block, PcapNgReader};
+use rayhunter::{
+    analysis::analyzer::{AnalysisRow, AnalyzerConfig, EventType, Harness},
+    diag::DataType,
+    gsmtap_parser,
+    pcap::GsmtapPcapWriter,
+    qmdl::QmdlReader,
+};
+use std::{collections::HashMap, future, path::PathBuf, pin::pin};
+use tokio::fs::File;
+use walkdir::WalkDir;
+
+#[derive(Parser, Debug)]
+#[command(version, about)]
+struct Args {
+    #[arg(short = 'p', long)]
+    path: PathBuf,
+
+    #[arg(short = 'P', long)]
+    pcapify: bool,
+
+    #[arg(long)]
+    show_skipped: bool,
+
+    #[arg(short, long)]
+    quiet: bool,
+
+    #[arg(short, long)]
+    debug: bool,
+}
+
+#[derive(Default)]
+struct Report {
+    skipped_reasons: HashMap<String, u32>,
+    total_messages: u32,
+    warnings: u32,
+    skipped: u32,
+    file_path: String,
+}
+
+impl Report {
+    fn new(file_path: &str) -> Self {
+        Report {
+            file_path: file_path.to_string(),
+            ..Default::default()
+        }
+    }
+
+    fn process_row(&mut self, row: AnalysisRow) {
+        self.total_messages += 1;
+        if let Some(reason) = row.skipped_message_reason {
+            *self.skipped_reasons.entry(reason).or_insert(0) += 1;
+            self.skipped += 1;
+            return;
+        }
+        for maybe_event in row.events {
+            let Some(event) = maybe_event else { continue };
+            let Some(timestamp) = row.packet_timestamp else {
+                continue;
+            };
+            match event.event_type {
+                EventType::Informational => {
+                    info!("{}: INFO - {} {}", self.file_path, timestamp, event.message,);
+                }
+                EventType::QualitativeWarning { severity } => {
+                    warn!(
+                        "{}: WARNING (Severity: {:?}) - {} {}",
+                        self.file_path, severity, timestamp, event.message,
+                    );
+                    self.warnings += 1;
+                }
+            }
+        }
+    }
+
+    fn print_summary(&self, show_skipped: bool) {
+        if show_skipped && self.skipped > 0 {
+            info!("{}: messages skipped:", self.file_path);
+            for (reason, count) in self.skipped_reasons.iter() {
+                info!("    - {count}: \"{reason}\"");
+            }
+        }
+        info!(
+            "{}: {} messages analyzed, {} warnings, {} messages skipped",
+            self.file_path, self.total_messages, self.warnings, self.skipped
+        );
+    }
+}
+
+async fn analyze_pcap(pcap_path: &str, show_skipped: bool) {
+    let mut harness = Harness::new_with_config(&AnalyzerConfig::default());
+    let pcap_file = &mut File::open(&pcap_path).await.expect("failed to open file");
+    let mut pcap_reader = PcapNgReader::new(pcap_file)
+        .await
+        .expect("failed to read PCAP file");
+    let mut report = Report::new(pcap_path);
+    while let Some(Ok(block)) = pcap_reader.next_block().await {
+        let row = match block {
+            Block::EnhancedPacket(packet) => harness.analyze_pcap_packet(packet),
+            other => {
+                debug!("{pcap_path}: skipping pcap packet {other:?}");
+                continue;
+            }
+        };
+        report.process_row(row);
+    }
+    report.print_summary(show_skipped);
+}
+
+async fn analyze_qmdl(qmdl_path: &str, show_skipped: bool) {
+    let mut harness = Harness::new_with_config(&AnalyzerConfig::default());
+    let qmdl_file = &mut File::open(&qmdl_path).await.expect("failed to open file");
+    let file_size = qmdl_file
+        .metadata()
+        .await
+        .expect("failed to get QMDL file metadata")
+        .len();
+    let mut qmdl_reader = QmdlReader::new(qmdl_file, Some(file_size as usize));
+    let mut qmdl_stream = pin!(
+        qmdl_reader
+            .as_stream()
+            .try_filter(|container| future::ready(container.data_type == DataType::UserSpace))
+    );
+    let mut report = Report::new(qmdl_path);
+    while let Some(container) = qmdl_stream
+        .try_next()
+        .await
+        .expect("failed getting QMDL container")
+    {
+        for row in harness.analyze_qmdl_messages(container) {
+            report.process_row(row);
+        }
+    }
+    report.print_summary(show_skipped);
+}
+
+async fn pcapify(qmdl_path: &PathBuf) {
+    let qmdl_file = &mut File::open(&qmdl_path)
+        .await
+        .expect("failed to open qmdl file");
+    let qmdl_file_size = qmdl_file.metadata().await.unwrap().len();
+    let mut qmdl_reader = QmdlReader::new(qmdl_file, Some(qmdl_file_size as usize));
+    let mut pcap_path = qmdl_path.clone();
+    pcap_path.set_extension("pcapng");
+    let pcap_file = &mut File::create(&pcap_path)
+        .await
+        .expect("failed to open pcap file");
+    let mut pcap_writer = GsmtapPcapWriter::new(pcap_file).await.unwrap();
+    pcap_writer.write_iface_header().await.unwrap();
+    while let Some(container) = qmdl_reader
+        .get_next_messages_container()
+        .await
+        .expect("failed to get container")
+    {
+        for msg in container.into_messages().into_iter().flatten() {
+            if let Ok(Some((timestamp, parsed))) = gsmtap_parser::parse(msg) {
+                pcap_writer
+                    .write_gsmtap_message(parsed, timestamp)
+                    .await
+                    .expect("failed to write");
+            }
+        }
+    }
+    info!("wrote pcap to {:?}", &pcap_path);
+}
+
+#[tokio::main]
+async fn main() {
+    let args = Args::parse();
+    let level = if args.debug {
+        log::LevelFilter::Debug
+    } else if args.quiet {
+        log::LevelFilter::Warn
+    } else {
+        log::LevelFilter::Info
+    };
+    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:");
+    for analyzer in harness.get_metadata().analyzers {
+        info!(
+            "    - {} (v{}): {}",
+            analyzer.name, analyzer.version, analyzer.description
+        );
+    }
+
+    for maybe_entry in WalkDir::new(&args.path) {
+        let Ok(entry) = maybe_entry else {
+            error!("failed to open dir entry {maybe_entry:?}");
+            continue;
+        };
+        let name = entry.file_name();
+        let name_str = name.to_str().unwrap();
+        let path = entry.path();
+        let path_str = path.to_str().unwrap();
+        // instead of relying on the QMDL extension, can we check if a file is
+        // QMDL by inspecting the contents?
+        if name_str.ends_with(".qmdl") {
+            info!("**** Beginning analysis of {name_str}");
+            analyze_qmdl(path_str, args.show_skipped).await;
+            if args.pcapify {
+                pcapify(&path.to_path_buf()).await;
+            }
+        } else if name_str.ends_with(".pcap") || name_str.ends_with(".pcapng") {
+            // TODO: if we've already analyzed a QMDL, skip its corresponding pcap
+            info!("**** Beginning analysis of {name_str}");
+            analyze_pcap(path_str, args.show_skipped).await;
+        }
+    }
+}

daemon/Cargo.toml

@@ -1,22 +1,7 @@
 [package]
 name = "rayhunter-daemon"
-version = "0.3.3"
+version = "0.5.0"
-edition = "2021"
+edition = "2024"
-
-[features]
-# These feature flags are mutually exclusive, and exactly one must be enabled.
-orbic = ["rayhunter/orbic"]
-tplink = ["rayhunter/tplink"]
-
-default = ["orbic"]
-
-[[bin]]
-name = "rayhunter-daemon"
-path = "src/daemon.rs"
-
-[[bin]]
-name = "rayhunter-check"
-path = "src/check.rs"
 
 [dependencies]
 rayhunter = { path = "../lib" }
@@ -28,15 +13,14 @@ 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"] }
+tokio-util = { version = "0.7.10", features = ["rt", "io", "compat"] }
 futures-macro = "0.3.30"
 include_dir = "0.7.3"
-mime_guess = "2.0.4"
 chrono = { version = "0.4.31", features = ["serde"] }
 tokio-stream = { version = "0.1.14", default-features = false }
 futures = { version = "0.3.30", default-features = false }
-clap = { version = "4.5.2", features = ["derive"] }
 serde_json = "1.0.114"
 image = { version =  "0.25.1", default-features = false, features = ["png", "gif"] }
 tempfile = "3.10.1"
-simple_logger = "5.0.0"
+async_zip = { version = "0.0.17", features = ["tokio"] }
+anyhow = "1.0.98"

daemon/src/analysis.rs

@@ -7,8 +7,8 @@ use axum::{
     http::StatusCode,
 };
 use futures::TryStreamExt;
-use log::{debug, error, info};
+use log::{error, info};
-use rayhunter::analysis::analyzer::Harness;
+use rayhunter::analysis::analyzer::{AnalyzerConfig, Harness};
 use rayhunter::diag::{DataType, MessagesContainer};
 use rayhunter::qmdl::QmdlReader;
 use serde::Serialize;
@@ -18,14 +18,12 @@ use tokio::sync::mpsc::Receiver;
 use tokio::sync::{RwLock, RwLockWriteGuard};
 use tokio_util::task::TaskTracker;
 
-use crate::dummy_analyzer::TestAnalyzer;
 use crate::qmdl_store::RecordingStore;
 use crate::server::ServerState;
 
 pub struct AnalysisWriter {
     writer: BufWriter<File>,
     harness: Harness,
-    bytes_written: usize,
 }
 
 // We write our analysis results to a file immediately to minimize the amount of
@@ -35,15 +33,11 @@ pub struct AnalysisWriter {
 // lets us simply append new rows to the end without parsing the entire JSON
 // object beforehand.
 impl AnalysisWriter {
-    pub async fn new(file: File, enable_dummy_analyzer: bool) -> Result<Self, std::io::Error> {
+    pub async fn new(file: File, analyzer_config: &AnalyzerConfig) -> Result<Self, std::io::Error> {
-        let mut harness = Harness::new_with_all_analyzers();
+        let harness = Harness::new_with_config(analyzer_config);
-        if enable_dummy_analyzer {
-            harness.add_analyzer(Box::new(TestAnalyzer { count: 0 }));
-        }
 
         let mut result = Self {
             writer: BufWriter::new(file),
-            bytes_written: 0,
             harness,
         };
         let metadata = result.harness.get_metadata();
@@ -52,22 +46,21 @@ impl AnalysisWriter {
     }
 
     // Runs the analysis harness on the given container, serializing the results
-    // to the analysis file and returning the file's new length.
+    // to the analysis file, returning the whether any warnings were detected
-    pub async fn analyze(
+    pub async fn analyze(&mut self, container: MessagesContainer) -> Result<bool, std::io::Error> {
-        &mut self,
+        let mut warning_detected = false;
-        container: MessagesContainer,
+        for row in self.harness.analyze_qmdl_messages(container) {
-    ) -> Result<(usize, bool), std::io::Error> {
+            if !row.is_empty() {
-        let row = self.harness.analyze_qmdl_messages(container);
+                self.write(&row).await?;
-        if !row.is_empty() {
+            }
-            self.write(&row).await?;
+            warning_detected |= row.contains_warnings();
         }
-        Ok((self.bytes_written, row.contains_warnings()))
+        Ok(warning_detected)
     }
 
     async fn write<T: Serialize>(&mut self, value: &T) -> Result<(), std::io::Error> {
         let mut value_str = serde_json::to_string(value).unwrap();
         value_str.push('\n');
-        self.bytes_written += value_str.len();
         self.writer.write_all(value_str.as_bytes()).await?;
         self.writer.flush().await?;
         Ok(())
@@ -130,62 +123,58 @@ async fn finish_running_analysis(analysis_status_lock: Arc<RwLock<AnalysisStatus
 async fn perform_analysis(
     name: &str,
     qmdl_store_lock: Arc<RwLock<RecordingStore>>,
-    enable_dummy_analyzer: bool,
+    analyzer_config: &AnalyzerConfig,
 ) -> Result<(), String> {
-    info!("Opening QMDL and analysis file for {}...", name);
+    info!("Opening QMDL and analysis file for {name}...");
-    let (analysis_file, qmdl_file, entry_index) = {
+    let (analysis_file, qmdl_file) = {
         let mut qmdl_store = qmdl_store_lock.write().await;
         let (entry_index, _) = qmdl_store
             .entry_for_name(name)
-            .ok_or(format!("failed to find QMDL store entry for {}", name))?;
+            .ok_or(format!("failed to find QMDL store entry for {name}"))?;
         let analysis_file = qmdl_store
             .clear_and_open_entry_analysis(entry_index)
             .await
-            .map_err(|e| format!("{:?}", e))?;
+            .map_err(|e| format!("{e:?}"))?;
         let qmdl_file = qmdl_store
             .open_entry_qmdl(entry_index)
             .await
-            .map_err(|e| format!("{:?}", e))?;
+            .map_err(|e| format!("{e:?}"))?;
 
-        (analysis_file, qmdl_file, entry_index)
+        (analysis_file, qmdl_file)
     };
 
-    let mut analysis_writer = AnalysisWriter::new(analysis_file, enable_dummy_analyzer)
+    let mut analysis_writer = AnalysisWriter::new(analysis_file, analyzer_config)
         .await
-        .map_err(|e| format!("{:?}", e))?;
+        .map_err(|e| format!("{e:?}"))?;
     let file_size = qmdl_file
         .metadata()
         .await
         .expect("failed to get QMDL file metadata")
         .len();
     let mut qmdl_reader = QmdlReader::new(qmdl_file, Some(file_size as usize));
-    let mut qmdl_stream = pin::pin!(qmdl_reader
+    let mut qmdl_stream = pin::pin!(
-        .as_stream()
+        qmdl_reader
-        .try_filter(|container| future::ready(container.data_type == DataType::UserSpace)));
+            .as_stream()
+            .try_filter(|container| future::ready(container.data_type == DataType::UserSpace))
+    );
 
-    info!("Starting analysis for {}...", name);
+    info!("Starting analysis for {name}...");
     while let Some(container) = qmdl_stream
         .try_next()
         .await
         .expect("failed getting QMDL container")
     {
-        let (size_bytes, _) = analysis_writer
+        let _ = analysis_writer
             .analyze(container)
             .await
-            .map_err(|e| format!("{:?}", e))?;
+            .map_err(|e| format!("{e:?}"))?;
-        debug!("{} analysis: {} bytes written", name, size_bytes);
-        let mut qmdl_store = qmdl_store_lock.write().await;
-        qmdl_store
-            .update_entry_analysis_size(entry_index, size_bytes)
-            .await
-            .map_err(|e| format!("{:?}", e))?;
     }
 
     analysis_writer
         .close()
         .await
-        .map_err(|e| format!("{:?}", e))?;
+        .map_err(|e| format!("{e:?}"))?;
-    info!("Analysis for {} complete!", name);
+    info!("Analysis for {name} complete!");
 
     Ok(())
 }
@@ -195,7 +184,7 @@ pub fn run_analysis_thread(
     mut analysis_rx: Receiver<AnalysisCtrlMessage>,
     qmdl_store_lock: Arc<RwLock<RecordingStore>>,
     analysis_status_lock: Arc<RwLock<AnalysisStatus>>,
-    enable_dummy_analyzer: bool,
+    analyzer_config: AnalyzerConfig,
 ) {
     task_tracker.spawn(async move {
         loop {
@@ -205,10 +194,9 @@ pub fn run_analysis_thread(
                     for _ in 0..count {
                         let name = dequeue_to_running(analysis_status_lock.clone()).await;
                         if let Err(err) =
-                            perform_analysis(&name, qmdl_store_lock.clone(), enable_dummy_analyzer)
+                            perform_analysis(&name, qmdl_store_lock.clone(), &analyzer_config).await
-                                .await
                         {
-                            error!("failed to analyze {}: {}", name, err);
+                            error!("failed to analyze {name}: {err}");
                         }
                         finish_running_analysis(analysis_status_lock.clone()).await;
                     }
@@ -269,7 +257,7 @@ pub async fn start_analysis(
             .map_err(|e| {
                 (
                     StatusCode::INTERNAL_SERVER_ERROR,
-                    format!("failed to queue new analysis files: {:?}", e),
+                    format!("failed to queue new analysis files: {e:?}"),
                 )
             })?;
     }

daemon/src/config.rs

@@ -1,17 +1,22 @@
+use log::warn;
+use serde::{Deserialize, Serialize};
+
+use rayhunter::Device;
+use rayhunter::analysis::analyzer::AnalyzerConfig;
+
 use crate::error::RayhunterError;
 
-use serde::Deserialize;
+#[derive(Debug, Clone, Deserialize, Serialize)]
-
-#[derive(Debug, Deserialize)]
 #[serde(default)]
 pub struct Config {
     pub qmdl_store_path: String,
     pub port: u16,
     pub debug_mode: bool,
+    pub device: Device,
     pub ui_level: u8,
-    pub enable_dummy_analyzer: bool,
     pub colorblind_mode: bool,
     pub key_input_mode: u8,
+    pub analyzers: AnalyzerConfig,
 }
 
 impl Default for Config {
@@ -20,21 +25,23 @@ impl Default for Config {
             qmdl_store_path: "/data/rayhunter/qmdl".to_string(),
             port: 8080,
             debug_mode: false,
+            device: Device::Orbic,
             ui_level: 1,
-            enable_dummy_analyzer: false,
             colorblind_mode: false,
-            key_input_mode: 1,
+            key_input_mode: 0,
+            analyzers: AnalyzerConfig::default(),
         }
     }
 }
 
-pub fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
+pub async fn parse_config<P>(path: P) -> Result<Config, RayhunterError>
 where
     P: AsRef<std::path::Path>,
 {
-    if let Ok(config_file) = std::fs::read_to_string(&path) {
+    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");
         Ok(Config::default())
     }
 }

daemon/src/diag.rs

@@ -3,23 +3,24 @@ use std::sync::Arc;
 
 use axum::body::Body;
 use axum::extract::{Path, State};
-use axum::http::header::CONTENT_TYPE;
 use axum::http::StatusCode;
+use axum::http::header::CONTENT_TYPE;
 use axum::response::{IntoResponse, Response};
 use futures::{StreamExt, TryStreamExt};
 use log::{debug, error, info, warn};
+use rayhunter::analysis::analyzer::AnalyzerConfig;
 use rayhunter::diag::DataType;
 use rayhunter::diag_device::DiagDevice;
 use rayhunter::qmdl::QmdlWriter;
 use tokio::fs::File;
-use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::sync::RwLock;
+use tokio::sync::mpsc::{Receiver, Sender};
 use tokio_util::io::ReaderStream;
 use tokio_util::task::TaskTracker;
 
 use crate::analysis::{AnalysisCtrlMessage, AnalysisWriter};
 use crate::display;
-use crate::qmdl_store::{RecordingStore, RecordingStoreError};
+use crate::qmdl_store::{EntryType, RecordingStore, RecordingStoreError};
 use crate::server::ServerState;
 
 pub enum DiagDeviceCtrlMessage {
@@ -28,6 +29,7 @@ pub enum DiagDeviceCtrlMessage {
     Exit,
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn run_diag_read_thread(
     task_tracker: &TaskTracker,
     mut dev: DiagDevice,
@@ -35,13 +37,13 @@ pub fn run_diag_read_thread(
     ui_update_sender: Sender<display::DisplayState>,
     qmdl_store_lock: Arc<RwLock<RecordingStore>>,
     analysis_sender: Sender<AnalysisCtrlMessage>,
-    enable_dummy_analyzer: bool,
+    analyzer_config: AnalyzerConfig,
 ) {
     task_tracker.spawn(async move {
         let (initial_qmdl_file, initial_analysis_file) = qmdl_store_lock.write().await.new_entry().await.expect("failed creating QMDL file entry");
         let mut maybe_qmdl_writer: Option<QmdlWriter<File>> = Some(QmdlWriter::new(initial_qmdl_file));
         let mut diag_stream = pin!(dev.as_stream().into_stream());
-        let mut maybe_analysis_writer = Some(AnalysisWriter::new(initial_analysis_file, enable_dummy_analyzer).await
+        let mut maybe_analysis_writer = Some(AnalysisWriter::new(initial_analysis_file, &analyzer_config).await
             .expect("failed to create analysis writer"));
         loop {
             tokio::select! {
@@ -52,7 +54,7 @@ pub fn run_diag_read_thread(
                             let (qmdl_file, new_analysis_file) = match qmdl_store.new_entry().await {
                                 Ok(x) => x,
                                 Err(e) => {
-                                    error!("couldn't create new qmdl entry: {}", e);
+                                    error!("couldn't create new qmdl entry: {e}");
                                     continue;
                                 }
                             };
@@ -63,29 +65,26 @@ pub fn run_diag_read_thread(
                                 analysis_writer.close().await.expect("failed to close analysis writer");
                             }
 
-                            maybe_analysis_writer = Some(AnalysisWriter::new(new_analysis_file, enable_dummy_analyzer).await
+                            maybe_analysis_writer = Some(AnalysisWriter::new(new_analysis_file, &analyzer_config).await
                                 .expect("failed to write to analysis file"));
 
                             if let Err(e) = ui_update_sender.send(display::DisplayState::Recording).await {
-                                warn!("couldn't send ui update message: {}", e);
+                                warn!("couldn't send ui update message: {e}");
                             }
                         },
                         Some(DiagDeviceCtrlMessage::StopRecording) => {
                             let mut qmdl_store = qmdl_store_lock.write().await;
-                            match qmdl_store.get_current_entry() {
+                            if let Some((_, entry)) = qmdl_store.get_current_entry() {
-                                Some((_, entry)) => {
+                                    if let Err(e) = analysis_sender
-                                        if let Err(e) = analysis_sender
+                                    .send(AnalysisCtrlMessage::RecordingFinished(
-                                        .send(AnalysisCtrlMessage::RecordingFinished(
+                                            entry.name.to_string(),
-                                                entry.name.to_string(),
+                                    ))
-                                        ))
+                                    .await {
-                                        .await {
+                                        warn!("couldn't send analysis message: {e}");
-                                            warn!("couldn't send analysis message: {}", e);
+                                    }
-                                        }
-                                }
-                                None => todo!(),
                             }
                             if let Err(e) = qmdl_store.close_current_entry().await {
-                                error!("couldn't close current entry: {}", e);
+                                error!("couldn't close current entry: {e}");
                             }
 
                             maybe_qmdl_writer = None;
@@ -95,7 +94,7 @@ pub fn run_diag_read_thread(
                             maybe_analysis_writer = None;
 
                             if let Err(e) = ui_update_sender.send(display::DisplayState::Paused).await {
-                                warn!("couldn't send ui update message: {}", e);
+                                warn!("couldn't send ui update message: {e}");
                             }
                         },
                         // None means all the Senders have been dropped, so it's
@@ -131,22 +130,17 @@ pub fn run_diag_read_thread(
                             }
 
                             if let Some(analysis_writer) = maybe_analysis_writer.as_mut() {
-                                let analysis_output = analysis_writer.analyze(container).await
+                                let heuristic_warning = analysis_writer.analyze(container).await
                                     .expect("failed to analyze container");
-                                let (analysis_file_len, heuristic_warning) = analysis_output;
                                 if heuristic_warning {
                                     info!("a heuristic triggered on this run!");
                                     ui_update_sender.send(display::DisplayState::WarningDetected).await
                                         .expect("couldn't send ui update message: {}");
                                 }
-                                let mut qmdl_store = qmdl_store_lock.write().await;
-                                let index = qmdl_store.current_entry.expect("DiagDevice had qmdl_writer, but QmdlStore didn't have current entry???");
-                                qmdl_store.update_entry_analysis_size(index, analysis_file_len).await
-                                    .expect("failed to update analysis file size");
                             }
                         },
                         Err(err) => {
-                            error!("error reading diag device: {}", err);
+                            error!("error reading diag device: {err}");
                             return Err(err);
                         }
                     }
@@ -159,7 +153,7 @@ pub fn run_diag_read_thread(
 pub async fn start_recording(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    if state.debug_mode {
+    if state.config.debug_mode {
         return Err((StatusCode::FORBIDDEN, "server is in debug mode".to_string()));
     }
 
@@ -170,7 +164,7 @@ pub async fn start_recording(
         .map_err(|e| {
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send start recording message: {}", e),
+                format!("couldn't send start recording message: {e}"),
             )
         })?;
 
@@ -180,7 +174,7 @@ pub async fn start_recording(
 pub async fn stop_recording(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    if state.debug_mode {
+    if state.config.debug_mode {
         return Err((StatusCode::FORBIDDEN, "server is in debug mode".to_string()));
     }
     state
@@ -190,7 +184,7 @@ pub async fn stop_recording(
         .map_err(|e| {
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send stop recording message: {}", e),
+                format!("couldn't send stop recording message: {e}"),
             )
         })?;
     Ok((StatusCode::ACCEPTED, "ok".to_string()))
@@ -200,52 +194,51 @@ pub async fn delete_recording(
     State(state): State<Arc<ServerState>>,
     Path(qmdl_name): Path<String>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    if state.debug_mode {
+    if state.config.debug_mode {
         return Err((StatusCode::FORBIDDEN, "server is in debug mode".to_string()));
     }
     let mut qmdl_store = state.qmdl_store_lock.write().await;
     match qmdl_store.delete_entry(&qmdl_name).await {
-        Err(RecordingStoreError::NoSuchEntryError) => {
+        Err(RecordingStoreError::NoSuchEntryError) => Err((
-            return Err((
+            StatusCode::BAD_REQUEST,
-                StatusCode::BAD_REQUEST,
+            format!("no recording with name {qmdl_name}"),
-                format!("no recording with name {qmdl_name}"),
+        )),
-            ))
+        Err(e) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("couldn't delete recording: {e}"),
+        )),
+        Ok(entry_type) => {
+            if entry_type == EntryType::Current {
+                state
+                    .diag_device_ctrl_sender
+                    .send(DiagDeviceCtrlMessage::StopRecording)
+                    .await
+                    .map_err(|e| {
+                        (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            format!("couldn't send stop recording message: {e}"),
+                        )
+                    })?;
+                state
+                    .ui_update_sender
+                    .send(display::DisplayState::Paused)
+                    .await
+                    .map_err(|e| {
+                        (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            format!("couldn't send ui update message: {e}"),
+                        )
+                    })?;
+            }
+            Ok((StatusCode::ACCEPTED, "ok".to_string()))
         }
-        Err(e) => {
-            return Err((
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't delete recording: {e}"),
-            ))
-        }
-        Ok(_) => {}
     }
-    state
-        .diag_device_ctrl_sender
-        .send(DiagDeviceCtrlMessage::StopRecording)
-        .await
-        .map_err(|e| {
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send stop recording message: {}", e),
-            )
-        })?;
-    state
-        .ui_update_sender
-        .send(display::DisplayState::Paused)
-        .await
-        .map_err(|e| {
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send ui update message: {}", e),
-            )
-        })?;
-    Ok((StatusCode::ACCEPTED, "ok".to_string()))
 }
 
 pub async fn delete_all_recordings(
     State(state): State<Arc<ServerState>>,
 ) -> Result<(StatusCode, String), (StatusCode, String)> {
-    if state.debug_mode {
+    if state.config.debug_mode {
         return Err((StatusCode::FORBIDDEN, "server is in debug mode".to_string()));
     }
     state
@@ -255,14 +248,14 @@ pub async fn delete_all_recordings(
         .map_err(|e| {
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send stop recording message: {}", e),
+                format!("couldn't send stop recording message: {e}"),
             )
         })?;
     let mut qmdl_store = state.qmdl_store_lock.write().await;
     qmdl_store.delete_all_entries().await.map_err(|e| {
         (
             StatusCode::INTERNAL_SERVER_ERROR,
-            format!("couldn't delete all recordings: {}", e),
+            format!("couldn't delete all recordings: {e}"),
         )
     })?;
     state
@@ -272,7 +265,7 @@ pub async fn delete_all_recordings(
         .map_err(|e| {
             (
                 StatusCode::INTERNAL_SERVER_ERROR,
-                format!("couldn't send ui update message: {}", e),
+                format!("couldn't send ui update message: {e}"),
             )
         })?;
     Ok((StatusCode::ACCEPTED, "ok".to_string()))
@@ -291,13 +284,13 @@ pub async fn get_analysis_report(
     } else {
         qmdl_store.entry_for_name(&qmdl_name).ok_or((
             StatusCode::NOT_FOUND,
-            format!("Couldn't find QMDL entry with name \"{}\"", qmdl_name),
+            format!("Couldn't find QMDL entry with name \"{qmdl_name}\""),
         ))?
     };
     let analysis_file = qmdl_store
         .open_entry_analysis(entry_index)
         .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{:?}", e)))?;
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:?}")))?;
     let analysis_stream = ReaderStream::new(analysis_file);
 
     let headers = [(CONTENT_TYPE, "application/x-ndjson")];

daemon/src/display/generic_framebuffer.rs

@@ -1,4 +1,4 @@
-use image::{codecs::gif::GifDecoder, imageops::FilterType, AnimationDecoder, DynamicImage};
+use image::{AnimationDecoder, DynamicImage, codecs::gif::GifDecoder, imageops::FilterType};
 use std::io::Cursor;
 use std::time::Duration;
 
@@ -13,7 +13,7 @@ use tokio_util::task::TaskTracker;
 
 use std::thread::sleep;
 
-use include_dir::{include_dir, Dir};
+use include_dir::{Dir, include_dir};
 
 #[derive(Copy, Clone)]
 pub struct Dimensions {
@@ -179,9 +179,7 @@ pub fn update_ui(
             }
 
             match display_level {
-                2 => {
+                2 => fb.draw_gif(img.unwrap()),
-                    fb.draw_gif(img.unwrap());
-                }
                 3 => fb.draw_img(img.unwrap()),
                 128 => {
                     fb.draw_line(Color::Cyan, 128);
@@ -190,12 +188,11 @@ pub fn update_ui(
                     fb.draw_line(Color::Pink, 50);
                     fb.draw_line(Color::Cyan, 25);
                 }
-                _ => {
+                // this branch id 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
-                    // unknown value is used
+                _ => {}
-                    fb.draw_line(display_color, 2);
-                }
             };
+            fb.draw_line(display_color, 2);
             sleep(Duration::from_millis(1000));
         }
     });

daemon/src/display/headless.rs

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

daemon/src/display/mod.rs

@@ -0,0 +1,16 @@
+mod generic_framebuffer;
+
+pub mod headless;
+pub mod orbic;
+pub mod tmobile;
+pub mod tplink;
+pub mod tplink_framebuffer;
+pub mod tplink_onebit;
+pub mod wingtech;
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum DisplayState {
+    Recording,
+    Paused,
+    WarningDetected,
+}

daemon/src/display/orbic.rs

@@ -1,6 +1,6 @@
 use crate::config;
-use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 use crate::display::DisplayState;
+use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 
 use tokio::sync::mpsc::Receiver;
 use tokio::sync::oneshot;

daemon/src/display/tmobile.rs

@@ -0,0 +1,83 @@
+/// Display module for Tmobile TMOHS1, blink LEDs on the front of the device.
+/// DisplayState::Recording => Signal LED slowly blinks blue.
+/// DisplayState::Paused => WiFi LED blinks white.
+/// DisplayState::WarningDetected => Signal LED slowly blinks red.
+use log::{error, info};
+use tokio::sync::mpsc;
+use tokio::sync::oneshot;
+use tokio_util::task::TaskTracker;
+
+use std::fs::write;
+use std::thread::sleep;
+use std::time::Duration;
+
+use crate::config;
+use crate::display::DisplayState;
+
+macro_rules! led {
+    ($l:expr) => {{ format!("/sys/class/leds/led:{}/blink", $l) }};
+}
+
+fn start_blinking(path: String) {
+    write(&path, "1").ok();
+}
+
+fn stop_blinking(path: String) {
+    write(&path, "0").ok();
+}
+
+pub fn update_ui(
+    task_tracker: &TaskTracker,
+    config: &config::Config,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
+    mut ui_update_rx: mpsc::Receiver<DisplayState>,
+) {
+    let mut invisible: bool = false;
+    if config.ui_level == 0 {
+        info!("Invisible mode, not spawning UI.");
+        invisible = true;
+    }
+    task_tracker.spawn_blocking(move || {
+        let mut state = DisplayState::Recording;
+        let mut last_state = DisplayState::Paused;
+
+        loop {
+            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,
+                Err(mpsc::error::TryRecvError::Empty) => {}
+                Err(e) => error!("error receiving ui update message: {e}"),
+            };
+            if invisible || state == last_state {
+                sleep(Duration::from_secs(1));
+                continue;
+            }
+            match state {
+                DisplayState::Paused => {
+                    stop_blinking(led!("signal_blue"));
+                    stop_blinking(led!("signal_red"));
+                    start_blinking(led!("wlan_white"));
+                }
+                DisplayState::Recording => {
+                    stop_blinking(led!("wlan_white"));
+                    stop_blinking(led!("signal_red"));
+                    start_blinking(led!("signal_blue"));
+                }
+                DisplayState::WarningDetected => {
+                    stop_blinking(led!("wlan_white"));
+                    stop_blinking(led!("signal_blue"));
+                    start_blinking(led!("signal_red"));
+                }
+            }
+            last_state = state;
+            sleep(Duration::from_secs(1));
+        }
+    });
+}

daemon/src/display/tplink.rs

@@ -4,7 +4,7 @@ use tokio::sync::oneshot;
 use tokio_util::task::TaskTracker;
 
 use crate::config;
-use crate::display::{tplink_framebuffer, tplink_onebit, DisplayState};
+use crate::display::{DisplayState, tplink_framebuffer, tplink_onebit};
 
 use std::fs;
 

daemon/src/display/tplink_framebuffer.rs

@@ -3,8 +3,8 @@ use std::io::Write;
 use std::os::fd::AsRawFd;
 
 use crate::config;
-use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 use crate::display::DisplayState;
+use crate::display::generic_framebuffer::{self, Dimensions, GenericFramebuffer};
 
 use tokio::sync::mpsc::Receiver;
 use tokio::sync::oneshot;
@@ -68,7 +68,7 @@ impl GenericFramebuffer for Framebuffer {
             );
 
             if res < 0 {
-                panic!("failed to send FBIORECT_DISPLAY ioctl, {}", res);
+                panic!("failed to send FBIORECT_DISPLAY ioctl, {res}");
             }
         }
     }

daemon/src/display/tplink_onebit.rs

@@ -148,7 +148,7 @@ pub fn update_ui(
             // we write the status every second because it may have been overwritten through menu
             // navigation.
             if display_level != 0 {
-                if let Err(e) = fs::write(OLED_PATH, &pixels) {
+                if let Err(e) = fs::write(OLED_PATH, pixels) {
                     error!("failed to write to display: {e}");
                 }
             }

daemon/src/display/wingtech.rs

@@ -0,0 +1,54 @@
+/// Display support for the Wingtech CT2MHS01 hotspot.
+///
+/// Tested on (from `/etc/wt_version`):
+///   WT_INNER_VERSION=SW_Q89323AA1_V057_M10_CRICKET_USR_MP
+///   WT_PRODUCTION_VERSION=CT2MHS01_0.04.55
+///   WT_HARDWARE_VERSION=89323_1_20
+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";
+
+#[derive(Copy, Clone, Default)]
+struct Framebuffer;
+
+impl GenericFramebuffer for Framebuffer {
+    fn dimensions(&self) -> Dimensions {
+        Dimensions {
+            height: 128,
+            width: 160,
+        }
+    }
+
+    fn write_buffer(&mut self, buffer: &[(u8, u8, u8)]) {
+        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;
+            rgb565 |= (*b as u16) >> 3;
+            raw_buffer.extend(rgb565.to_le_bytes());
+        }
+
+        std::fs::write(FB_PATH, &raw_buffer).unwrap();
+    }
+}
+
+pub fn update_ui(
+    task_tracker: &TaskTracker,
+    config: &config::Config,
+    ui_shutdown_rx: oneshot::Receiver<()>,
+    ui_update_rx: Receiver<DisplayState>,
+) {
+    generic_framebuffer::update_ui(
+        task_tracker,
+        config,
+        Framebuffer,
+        ui_shutdown_rx,
+        ui_update_rx,
+    )
+}

daemon/src/key_input.rs

@@ -0,0 +1,131 @@
+use log::{error, info};
+use std::time::{Duration, Instant};
+use tokio::fs::File;
+use tokio::io::AsyncReadExt;
+use tokio::sync::mpsc::Sender;
+use tokio::sync::oneshot;
+use tokio_util::task::TaskTracker;
+
+use crate::config;
+use crate::diag::DiagDeviceCtrlMessage;
+
+#[derive(Debug)]
+enum Event {
+    KeyDown,
+    KeyUp,
+}
+
+const INPUT_EVENT_SIZE: usize = 32;
+
+pub fn run_key_input_thread(
+    task_tracker: &TaskTracker,
+    config: &config::Config,
+    diag_tx: Sender<DiagDeviceCtrlMessage>,
+    mut ui_shutdown_rx: oneshot::Receiver<()>,
+) {
+    if config.key_input_mode == 0 {
+        return;
+    }
+
+    task_tracker.spawn(async move {
+        // Open the input device
+        let mut file = match File::open("/dev/input/event0").await {
+            Ok(file) => file,
+            Err(e) => {
+                error!("Failed to open /dev/input/event0: {e}");
+                return;
+            }
+        };
+
+        let mut buffer = [0u8; INPUT_EVENT_SIZE];
+        let mut last_keyup: Option<Instant> = None;
+        let mut last_event_time: Option<Instant> = None;
+
+        loop {
+            tokio::select! {
+                _ = &mut ui_shutdown_rx => {
+                    info!("received key input shutdown");
+                    return;
+                }
+                result = file.read_exact(&mut buffer) => {
+                    if let Err(e) = result {
+                        error!("failed to read key input: {e}");
+                        return;
+                    }
+                }
+            }
+
+            let event = parse_event(buffer);
+
+            let now = Instant::now();
+
+            // On orbic it was observed that pressing the power button can trigger many successive
+            // events. Drop events that are too close together.
+            if let Some(last_time) = last_event_time {
+                if now.duration_since(last_time) < Duration::from_millis(50) {
+                    last_event_time = Some(now);
+                    continue;
+                }
+            }
+            last_event_time = Some(now);
+
+            match event {
+                Event::KeyUp => {
+                    if let Some(last_keyup_instant) = last_keyup {
+                        let elapsed = now.duration_since(last_keyup_instant);
+
+                        if elapsed >= Duration::from_millis(100)
+                            && elapsed <= Duration::from_millis(800)
+                        {
+                            if let Err(e) = diag_tx.send(DiagDeviceCtrlMessage::StopRecording).await
+                            {
+                                error!("Failed to send StopRecording: {e}");
+                            }
+                            if let Err(e) =
+                                diag_tx.send(DiagDeviceCtrlMessage::StartRecording).await
+                            {
+                                error!("Failed to send StartRecording: {e}");
+                            }
+                            last_keyup = None;
+                            continue;
+                        }
+                    }
+
+                    last_keyup = Some(now);
+                }
+                Event::KeyDown => {}
+            }
+        }
+    });
+}
+
+fn parse_event(input: [u8; INPUT_EVENT_SIZE]) -> Event {
+    if input[12] == 0 {
+        Event::KeyUp
+    } else {
+        Event::KeyDown
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_event_keydown_m7350_v5() {
+        let input = [
+            0x57, 0x6c, 0x09, 0x00, 0x7c, 0xfb, 0x03, 0x00, 0x01, 0x00, 0x74, 0x00, 0x01, 0x00,
+            0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+        assert!(matches!(parse_event(input), Event::KeyDown));
+    }
+
+    #[test]
+    fn test_parse_event_keyup_m7350_v5() {
+        let input = [
+            0x57, 0x6c, 0x09, 0x00, 0x1b, 0x15, 0x05, 0x00, 0x01, 0x00, 0x74, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ];
+        assert!(matches!(parse_event(input), Event::KeyUp));
+    }
+}

daemon/src/main.rs

@@ -2,7 +2,6 @@ mod analysis;
 mod config;
 mod diag;
 mod display;
-mod dummy_analyzer;
 mod error;
 mod key_input;
 mod pcap;
@@ -10,33 +9,36 @@ mod qmdl_store;
 mod server;
 mod stats;
 
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
 use crate::config::{parse_args, parse_config};
 use crate::diag::run_diag_read_thread;
 use crate::error::RayhunterError;
 use crate::pcap::get_pcap;
 use crate::qmdl_store::RecordingStore;
-use crate::server::{get_qmdl, serve_static, ServerState};
+use crate::server::{ServerState, get_config, get_qmdl, get_zip, serve_static, set_config};
-use crate::stats::get_system_stats;
+use crate::stats::{get_qmdl_manifest, get_system_stats};
 
 use analysis::{
-    get_analysis_status, run_analysis_thread, start_analysis, AnalysisCtrlMessage, AnalysisStatus,
+    AnalysisCtrlMessage, AnalysisStatus, get_analysis_status, run_analysis_thread, start_analysis,
 };
+use axum::Router;
 use axum::response::Redirect;
 use axum::routing::{get, post};
-use axum::Router;
 use diag::{
-    delete_all_recordings, delete_recording, get_analysis_report, start_recording, stop_recording,
+    DiagDeviceCtrlMessage, delete_all_recordings, delete_recording, get_analysis_report,
-    DiagDeviceCtrlMessage,
+    start_recording, stop_recording,
 };
 use log::{error, info};
 use qmdl_store::RecordingStoreError;
+use rayhunter::Device;
 use rayhunter::diag_device::DiagDevice;
-use stats::get_qmdl_manifest;
-use std::net::SocketAddr;
-use std::sync::Arc;
 use tokio::net::TcpListener;
+use tokio::select;
 use tokio::sync::mpsc::{self, Sender};
-use tokio::sync::{oneshot, RwLock};
+use tokio::sync::{RwLock, oneshot};
 use tokio::task::JoinHandle;
 use tokio_util::task::TaskTracker;
 
@@ -46,6 +48,7 @@ fn get_router() -> AppRouter {
     Router::new()
         .route("/api/pcap/{name}", get(get_pcap))
         .route("/api/qmdl/{name}", get(get_qmdl))
+        .route("/api/zip/{name}", get(get_zip))
         .route("/api/system-stats", get(get_system_stats))
         .route("/api/qmdl-manifest", get(get_qmdl_manifest))
         .route("/api/start-recording", post(start_recording))
@@ -55,6 +58,8 @@ fn get_router() -> AppRouter {
         .route("/api/analysis-report/{name}", get(get_analysis_report))
         .route("/api/analysis", get(get_analysis_status))
         .route("/api/analysis/{name}", post(start_analysis))
+        .route("/api/config", get(get_config))
+        .route("/api/config", post(set_config))
         .route("/", get(|| async { Redirect::permanent("/index.html") }))
         .route("/{*path}", get(serve_static))
 }
@@ -64,14 +69,14 @@ fn get_router() -> AppRouter {
 // (i.e. user hit ctrl+c)
 async fn run_server(
     task_tracker: &TaskTracker,
-    config: &config::Config,
     state: Arc<ServerState>,
     server_shutdown_rx: oneshot::Receiver<()>,
 ) -> JoinHandle<()> {
     info!("spinning up server");
-    let app = get_router().with_state(state);
+    let addr = SocketAddr::from(([0, 0, 0, 0], state.config.port));
-    let addr = SocketAddr::from(([0, 0, 0, 0], config.port));
     let listener = TcpListener::bind(&addr).await.unwrap();
+    let app = get_router().with_state(state);
+
     task_tracker.spawn(async move {
         info!("The orca is hunting for stingrays...");
         axum::serve(listener, app)
@@ -88,7 +93,7 @@ async fn server_shutdown_signal(server_shutdown_rx: oneshot::Receiver<()>) {
 
 // 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 by making a new (empty) manifest in the same directory.
+// mode, try to recover the manifest from the existing QMDL files
 async fn init_qmdl_store(config: &config::Config) -> Result<RecordingStore, RayhunterError> {
     let store_exists = RecordingStore::exists(&config.qmdl_store_path).await?;
     if config.debug_mode {
@@ -103,9 +108,9 @@ async fn init_qmdl_store(config: &config::Config) -> Result<RecordingStore, Rayh
         match RecordingStore::load(&config.qmdl_store_path).await {
             Ok(store) => Ok(store),
             Err(RecordingStoreError::ParseManifestError(err)) => {
-                error!("failed to parse QMDL manifest: {}", err);
+                error!("failed to parse QMDL manifest: {err}");
-                info!("creating new empty manifest...");
+                info!("recovering manifest from existing QMDL files...");
-                Ok(RecordingStore::create(&config.qmdl_store_path).await?)
+                Ok(RecordingStore::recover(&config.qmdl_store_path).await?)
             }
             Err(err) => Err(err.into()),
         }
@@ -117,46 +122,62 @@ 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
-fn run_ctrl_c_thread(
+#[allow(clippy::too_many_arguments)]
+fn run_shutdown_thread(
     task_tracker: &TaskTracker,
     diag_device_sender: Sender<DiagDeviceCtrlMessage>,
+    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>> {
+    info!("create shutdown thread");
+
     task_tracker.spawn(async move {
-        match tokio::signal::ctrl_c().await {
+        select! {
-            Ok(()) => {
+            res = tokio::signal::ctrl_c() => {
-                let mut qmdl_store = qmdl_store_lock.write().await;
+                if let Err(err) = res {
-                if qmdl_store.current_entry.is_some() {
+                    error!("Unable to listen for shutdown signal: {err}");
-                    info!("Closing current QMDL entry...");
-                    qmdl_store.close_current_entry().await?;
-                    info!("Done!");
                 }
 
-                server_shutdown_tx
+                should_restart_flag.store(false, Ordering::Relaxed);
-                    .send(())
+            }
-                    .expect("couldn't send server shutdown signal");
+            res = daemon_restart_rx => {
-                info!("sending UI shutdown");
+                if let Err(err) = res {
-                if let Some(ui_shutdown_tx) = maybe_ui_shutdown_tx {
+                    error!("Unable to listen for shutdown signal: {err}");
-                    ui_shutdown_tx
-                        .send(())
-                        .expect("couldn't send ui shutdown signal");
                 }
-                diag_device_sender
+
-                    .send(DiagDeviceCtrlMessage::Exit)
+                should_restart_flag.store(true, Ordering::Relaxed);
-                    .await
-                    .expect("couldn't send Exit message to diag thread");
-                analysis_tx
-                    .send(AnalysisCtrlMessage::Exit)
-                    .await
-                    .expect("couldn't send Exit message to analysis thread");
-            }
-            Err(err) => {
-                error!("Unable to listen for shutdown signal: {}", err);
             }
+        };
+
+        let mut qmdl_store = qmdl_store_lock.write().await;
+        if qmdl_store.current_entry.is_some() {
+            info!("Closing current QMDL entry...");
+            qmdl_store.close_current_entry().await?;
+            info!("Done!");
         }
+
+        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
+            .expect("couldn't send Exit message to diag thread");
+        analysis_tx
+            .send(AnalysisCtrlMessage::Exit)
+            .await
+            .expect("couldn't send Exit message to analysis thread");
         Ok(())
     })
 }
@@ -166,8 +187,19 @@ async fn main() -> Result<(), RayhunterError> {
     env_logger::init();
 
     let args = parse_args();
-    let config = parse_config(&args.config_path)?;
 
+    loop {
+        let config = parse_config(&args.config_path).await?;
+        if !run_with_config(&args, config).await? {
+            return Ok(());
+        }
+    }
+}
+
+async fn run_with_config(
+    args: &config::Args,
+    config: config::Config,
+) -> Result<bool, RayhunterError> {
     // TaskTrackers give us an interface to spawn tokio threads, and then
     // eventually await all of them ending
     let task_tracker = TaskTracker::new();
@@ -180,10 +212,12 @@ async fn main() -> Result<(), RayhunterError> {
     let (ui_update_tx, ui_update_rx) = mpsc::channel::<display::DisplayState>(1);
     let (analysis_tx, analysis_rx) = mpsc::channel::<AnalysisCtrlMessage>(5);
     let mut maybe_ui_shutdown_tx = None;
+    let mut maybe_key_input_shutdown_tx = None;
     if !config.debug_mode {
         let (ui_shutdown_tx, ui_shutdown_rx) = oneshot::channel();
         maybe_ui_shutdown_tx = Some(ui_shutdown_tx);
-        let mut dev = DiagDevice::new()
+        info!("Using configuration for device: {0:?}", config.device);
+        let mut dev = DiagDevice::new(&config.device)
             .await
             .map_err(RayhunterError::DiagInitError)?;
         dev.config_logs()
@@ -198,47 +232,70 @@ async fn main() -> Result<(), RayhunterError> {
             ui_update_tx.clone(),
             qmdl_store_lock.clone(),
             analysis_tx.clone(),
-            config.enable_dummy_analyzer,
+            config.analyzers.clone(),
         );
         info!("Starting UI");
-        display::update_ui(&task_tracker, &config, ui_shutdown_rx, ui_update_rx);
+
+        let update_ui = match &config.device {
+            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,
+        };
+        update_ui(&task_tracker, &config, ui_shutdown_rx, ui_update_rx);
 
         info!("Starting Key Input service");
-        key_input::run_key_input_thread(&task_tracker, &config, diag_tx.clone());
+        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(),
+            key_input_shutdown_rx,
+        );
     }
+
+    let (daemon_restart_tx, daemon_restart_rx) = oneshot::channel::<()>();
     let (server_shutdown_tx, server_shutdown_rx) = oneshot::channel::<()>();
-    info!("create shutdown thread");
     let analysis_status_lock = Arc::new(RwLock::new(analysis_status));
     run_analysis_thread(
         &task_tracker,
         analysis_rx,
         qmdl_store_lock.clone(),
         analysis_status_lock.clone(),
-        config.enable_dummy_analyzer,
+        config.analyzers.clone(),
     );
-    run_ctrl_c_thread(
+    let should_restart_flag = Arc::new(AtomicBool::new(false));
+
+    run_shutdown_thread(
         &task_tracker,
         diag_tx.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(),
     );
     let state = Arc::new(ServerState {
+        config_path: args.config_path.clone(),
+        config,
         qmdl_store_lock: qmdl_store_lock.clone(),
         diag_device_ctrl_sender: diag_tx,
         ui_update_sender: ui_update_tx,
-        debug_mode: config.debug_mode,
         analysis_status_lock,
         analysis_sender: analysis_tx,
+        daemon_restart_tx: Arc::new(RwLock::new(Some(daemon_restart_tx))),
     });
-    run_server(&task_tracker, &config, state, server_shutdown_rx).await;
+    run_server(&task_tracker, state, server_shutdown_rx).await;
 
     task_tracker.close();
     task_tracker.wait().await;
 
     info!("see you space cowboy...");
-    Ok(())
+    Ok(should_restart_flag.load(Ordering::Relaxed))
 }
 
 #[cfg(test)]

daemon/src/pcap.rs

@@ -1,19 +1,18 @@
 use crate::ServerState;
 
+use anyhow::Error;
 use axum::body::Body;
 use axum::extract::{Path, State};
-use axum::http::header::CONTENT_TYPE;
 use axum::http::StatusCode;
+use axum::http::header::CONTENT_TYPE;
 use axum::response::{IntoResponse, Response};
-use futures::TryStreamExt;
 use log::error;
 use rayhunter::diag::DataType;
 use rayhunter::gsmtap_parser;
 use rayhunter::pcap::GsmtapPcapWriter;
 use rayhunter::qmdl::QmdlReader;
 use std::sync::Arc;
-use std::{future, pin::pin};
+use tokio::io::{AsyncRead, AsyncWrite, duplex};
-use tokio::io::duplex;
 use tokio_util::io::ReaderStream;
 
 // Streams a pcap file chunk-by-chunk to the client by reading the QMDL data
@@ -21,12 +20,15 @@ use tokio_util::io::ReaderStream;
 // pcap data to a channel that's piped to the client.
 pub async fn get_pcap(
     State(state): State<Arc<ServerState>>,
-    Path(qmdl_name): Path<String>,
+    Path(mut qmdl_name): Path<String>,
 ) -> Result<Response, (StatusCode, String)> {
     let qmdl_store = state.qmdl_store_lock.read().await;
+    if qmdl_name.ends_with("pcapng") {
+        qmdl_name = qmdl_name.trim_end_matches(".pcapng").to_string();
+    }
     let (entry_index, entry) = qmdl_store.entry_for_name(&qmdl_name).ok_or((
         StatusCode::NOT_FOUND,
-        format!("couldn't find qmdl file with name {}", qmdl_name),
+        format!("couldn't find manifest entry with name {qmdl_name}"),
     ))?;
     if entry.qmdl_size_bytes == 0 {
         return Err((
@@ -38,39 +40,14 @@ pub async fn get_pcap(
     let qmdl_file = qmdl_store
         .open_entry_qmdl(entry_index)
         .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{:?}", e)))?;
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("{e:?}")))?;
     // the QMDL reader should stop at the last successfully written data chunk
     // (entry.size_bytes)
     let (reader, writer) = duplex(1024);
-    let mut pcap_writer = GsmtapPcapWriter::new(writer).await.unwrap();
-    pcap_writer.write_iface_header().await.unwrap();
 
     tokio::spawn(async move {
-        let mut reader = QmdlReader::new(qmdl_file, Some(qmdl_size_bytes));
+        if let Err(e) = generate_pcap_data(writer, qmdl_file, qmdl_size_bytes).await {
-        let mut messages_stream = pin!(reader
+            error!("failed to generate PCAP: {e:?}");
-            .as_stream()
-            .try_filter(|container| future::ready(container.data_type == DataType::UserSpace)));
-
-        while let Some(container) = messages_stream
-            .try_next()
-            .await
-            .expect("failed getting QMDL container")
-        {
-            for maybe_msg in container.into_messages() {
-                match maybe_msg {
-                    Ok(msg) => {
-                        let maybe_gsmtap_msg =
-                            gsmtap_parser::parse(msg).expect("error parsing gsmtap message");
-                        if let Some((timestamp, gsmtap_msg)) = maybe_gsmtap_msg {
-                            pcap_writer
-                                .write_gsmtap_message(gsmtap_msg, timestamp)
-                                .await
-                                .expect("error writing pcap packet");
-                        }
-                    }
-                    Err(e) => error!("error parsing message: {:?}", e),
-                }
-            }
         }
     });
 
@@ -78,3 +55,39 @@ pub async fn get_pcap(
     let body = Body::from_stream(ReaderStream::new(reader));
     Ok((headers, body).into_response())
 }
+
+pub async fn generate_pcap_data<R, W>(
+    writer: W,
+    qmdl_file: R,
+    qmdl_size_bytes: usize,
+) -> Result<(), Error>
+where
+    W: AsyncWrite + Unpin + Send,
+    R: AsyncRead + Unpin,
+{
+    let mut pcap_writer = GsmtapPcapWriter::new(writer).await?;
+    pcap_writer.write_iface_header().await?;
+
+    let mut reader = QmdlReader::new(qmdl_file, Some(qmdl_size_bytes));
+    while let Some(container) = reader.get_next_messages_container().await? {
+        if container.data_type != DataType::UserSpace {
+            continue;
+        }
+
+        for maybe_msg in container.into_messages() {
+            match maybe_msg {
+                Ok(msg) => {
+                    let maybe_gsmtap_msg = gsmtap_parser::parse(msg)?;
+                    if let Some((timestamp, gsmtap_msg)) = maybe_gsmtap_msg {
+                        pcap_writer
+                            .write_gsmtap_message(gsmtap_msg, timestamp)
+                            .await?;
+                    }
+                }
+                Err(e) => error!("error parsing message: {e:?}"),
+            }
+        }
+    }
+
+    Ok(())
+}

daemon/src/qmdl_store.rs

@@ -1,12 +1,14 @@
 use std::io::{self, ErrorKind};
+use std::os::unix::fs::MetadataExt;
 use std::path::{Path, PathBuf};
 
 use chrono::{DateTime, Local};
+use log::{info, warn};
 use rayhunter::util::RuntimeMetadata;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tokio::{
-    fs::{self, try_exists, File, OpenOptions},
+    fs::{self, File, OpenOptions, try_exists},
     io::AsyncWriteExt,
 };
 
@@ -49,12 +51,17 @@ pub struct ManifestEntry {
     pub start_time: DateTime<Local>,
     pub last_message_time: Option<DateTime<Local>>,
     pub qmdl_size_bytes: usize,
-    pub analysis_size_bytes: usize,
     pub rayhunter_version: Option<String>,
     pub system_os: Option<String>,
     pub arch: Option<String>,
 }
 
+#[derive(PartialEq, Eq)]
+pub enum EntryType {
+    Current,
+    Past,
+}
+
 impl ManifestEntry {
     fn new() -> Self {
         let now = Local::now();
@@ -64,7 +71,6 @@ impl ManifestEntry {
             start_time: now,
             last_message_time: None,
             qmdl_size_bytes: 0,
-            analysis_size_bytes: 0,
             rayhunter_version: Some(metadata.rayhunter_version),
             system_os: Some(metadata.system_os),
             arch: Some(metadata.arch),
@@ -138,6 +144,83 @@ impl RecordingStore {
         Ok(store)
     }
 
+    // Does a best-effort attempt to recover the manifest from a directory of
+    // QMDL files. We expect these files to be named like "<timestamp>.qmdl",
+    // and skip any files which don't match that pattern.
+    pub async fn recover<P>(path: P) -> Result<Self, RecordingStoreError>
+    where
+        P: AsRef<Path>,
+    {
+        let mut dir_entries = fs::read_dir(path.as_ref())
+            .await
+            .map_err(RecordingStoreError::OpenDirError)?;
+        let mut manifest_entries = Vec::new();
+
+        while let Some(entry) = dir_entries
+            .next_entry()
+            .await
+            .map_err(RecordingStoreError::OpenDirError)?
+        {
+            let os_filename = entry.file_name();
+            let Some(filename) = os_filename.to_str() else {
+                continue;
+            };
+
+            if !filename.ends_with(".qmdl") {
+                continue;
+            }
+
+            let stem = filename.trim_end_matches(".qmdl");
+            let Ok(start_timestamp) = stem.parse::<i64>() else {
+                warn!("QMDL file has invalid name {os_filename:?}, skipping");
+                continue;
+            };
+
+            let metadata = match entry.metadata().await {
+                Ok(metadata) => metadata,
+                Err(err) => {
+                    warn!("failed to read QMDL file metadata: {err:?}, skipping");
+                    continue;
+                }
+            };
+
+            let Some(start_time) = DateTime::from_timestamp(start_timestamp, 0) else {
+                warn!("QMDL filename {os_filename:?} gave an invalid timestamp, skipping");
+                continue;
+            };
+
+            let Ok(last_message_time) = metadata.modified() else {
+                warn!("failed to get modified time for QMDL file {os_filename:?}, skipping");
+                continue;
+            };
+
+            info!("successfully recovered QMDL entry {os_filename:?}!");
+            manifest_entries.push(ManifestEntry {
+                name: stem.to_string(),
+                start_time: start_time.into(),
+                last_message_time: Some(last_message_time.into()),
+                qmdl_size_bytes: metadata.size() as usize,
+                rayhunter_version: None,
+                system_os: None,
+                arch: None,
+            });
+        }
+
+        // sort chronologically
+        manifest_entries.sort_by(|a, b| a.start_time.cmp(&b.start_time));
+
+        let mut store = RecordingStore {
+            path: path.as_ref().to_path_buf(),
+            manifest: Manifest {
+                entries: manifest_entries,
+            },
+            current_entry: None,
+        };
+        store.write_manifest().await?;
+
+        Ok(store)
+    }
+
     async fn read_manifest<P>(path: P) -> Result<Manifest, RecordingStoreError>
     where
         P: AsRef<Path>,
@@ -202,7 +285,6 @@ impl RecordingStore {
             .open(entry.get_analysis_filepath(&self.path))
             .await
             .map_err(RecordingStoreError::ReadFileError)?;
-        self.update_entry_analysis_size(entry_index, 0).await?;
         Ok(file)
     }
 
@@ -228,17 +310,9 @@ impl RecordingStore {
         self.write_manifest().await
     }
 
-    // Sets the given entry's analysis file size
-    pub async fn update_entry_analysis_size(
-        &mut self,
-        entry_index: usize,
-        size_bytes: usize,
-    ) -> Result<(), RecordingStoreError> {
-        self.manifest.entries[entry_index].analysis_size_bytes = size_bytes;
-        self.write_manifest().await
-    }
-
     async fn write_manifest(&mut self) -> Result<(), RecordingStoreError> {
+        // we don't technically need a mutable reference to `self` here, but it
+        // does prevent multiple concurrent writes across different threads
         let tmp_path = self.path.join("manifest.toml.new");
         let mut manifest_tmp_file = File::create(&tmp_path)
             .await
@@ -273,20 +347,24 @@ impl RecordingStore {
         Some((entry_index, &self.manifest.entries[entry_index]))
     }
 
-    pub async fn delete_entry(&mut self, name: &str) -> Result<ManifestEntry, RecordingStoreError> {
+    pub async fn delete_entry(&mut self, name: &str) -> Result<EntryType, RecordingStoreError> {
         let entry_to_delete_idx = self
             .manifest
             .entries
             .iter()
             .position(|entry| entry.name == name)
             .ok_or(RecordingStoreError::NoSuchEntryError)?;
-        if let Some(current_entry) = self.current_entry {
+        let is_current = match self.current_entry {
-            if current_entry == entry_to_delete_idx {
+            Some(current_entry) if current_entry == entry_to_delete_idx => {
                 self.close_current_entry().await?;
-            } else {
+                EntryType::Current
-                self.current_entry = Some(current_entry - 1);
             }
-        }
+            Some(current_entry) => {
+                self.current_entry = Some(current_entry - 1);
+                EntryType::Past
+            }
+            None => EntryType::Past,
+        };
         let entry_to_delete = self.manifest.entries.remove(entry_to_delete_idx);
         self.write_manifest().await?;
         let qmdl_filepath = entry_to_delete.get_qmdl_filepath(&self.path);
@@ -297,7 +375,7 @@ impl RecordingStore {
         remove_file_if_exists(&analysis_filepath)
             .await
             .map_err(RecordingStoreError::DeleteFileError)?;
-        Ok(entry_to_delete)
+        Ok(is_current)
     }
 
     pub async fn delete_all_entries(&mut self) -> Result<(), RecordingStoreError> {
@@ -369,9 +447,11 @@ mod tests {
             RecordingStore::read_manifest(dir.path()).await.unwrap(),
             store.manifest
         );
-        assert!(store.manifest.entries[entry_index]
+        assert!(
-            .last_message_time
+            store.manifest.entries[entry_index]
-            .is_none());
+                .last_message_time
+                .is_none()
+        );
 
         store
             .update_entry_qmdl_size(entry_index, 1000)

daemon/src/server.rs

@@ -0,0 +1,348 @@
+use anyhow::Error;
+use async_zip::Compression;
+use async_zip::ZipEntryBuilder;
+use async_zip::tokio::write::ZipFileWriter;
+use axum::Json;
+use axum::body::Body;
+use axum::extract::Path;
+use axum::extract::State;
+use axum::http::header::{self, CONTENT_LENGTH, CONTENT_TYPE};
+use axum::http::{HeaderValue, StatusCode};
+use axum::response::{IntoResponse, Response};
+use log::{error, warn};
+use std::sync::Arc;
+use tokio::fs::write;
+use tokio::io::{AsyncReadExt, copy, duplex};
+use tokio::sync::mpsc::Sender;
+use tokio::sync::{RwLock, oneshot};
+use tokio_util::compat::FuturesAsyncWriteCompatExt;
+use tokio_util::io::ReaderStream;
+
+use crate::analysis::{AnalysisCtrlMessage, AnalysisStatus};
+use crate::config::Config;
+use crate::pcap::generate_pcap_data;
+use crate::qmdl_store::RecordingStore;
+use crate::{DiagDeviceCtrlMessage, display};
+
+pub struct ServerState {
+    pub config_path: String,
+    pub config: Config,
+    pub qmdl_store_lock: Arc<RwLock<RecordingStore>>,
+    pub diag_device_ctrl_sender: Sender<DiagDeviceCtrlMessage>,
+    pub ui_update_sender: Sender<display::DisplayState>,
+    pub analysis_status_lock: Arc<RwLock<AnalysisStatus>>,
+    pub analysis_sender: Sender<AnalysisCtrlMessage>,
+    pub daemon_restart_tx: Arc<RwLock<Option<oneshot::Sender<()>>>>,
+}
+
+pub async fn get_qmdl(
+    State(state): State<Arc<ServerState>>,
+    Path(qmdl_name): Path<String>,
+) -> Result<Response, (StatusCode, String)> {
+    let qmdl_idx = qmdl_name.trim_end_matches(".qmdl");
+    let qmdl_store = state.qmdl_store_lock.read().await;
+    let (entry_index, entry) = qmdl_store.entry_for_name(qmdl_idx).ok_or((
+        StatusCode::NOT_FOUND,
+        format!("couldn't find qmdl file with name {qmdl_idx}"),
+    ))?;
+    let qmdl_file = qmdl_store
+        .open_entry_qmdl(entry_index)
+        .await
+        .map_err(|err| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("error opening QMDL file: {err}"),
+            )
+        })?;
+    let limited_qmdl_file = qmdl_file.take(entry.qmdl_size_bytes as u64);
+    let qmdl_stream = ReaderStream::new(limited_qmdl_file);
+
+    let headers = [
+        (CONTENT_TYPE, "application/octet-stream"),
+        (CONTENT_LENGTH, &entry.qmdl_size_bytes.to_string()),
+    ];
+    let body = Body::from_stream(qmdl_stream);
+    Ok((headers, body).into_response())
+}
+
+pub async fn serve_static(
+    State(_): State<Arc<ServerState>>,
+    Path(path): Path<String>,
+) -> impl IntoResponse {
+    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"),
+        )
+            .into_response(),
+        "rayhunter_text.png" => (
+            [(header::CONTENT_TYPE, HeaderValue::from_static("image/png"))],
+            include_bytes!("../web/build/rayhunter_text.png"),
+        )
+            .into_response(),
+        "favicon.png" => (
+            [(header::CONTENT_TYPE, HeaderValue::from_static("image/png"))],
+            include_bytes!("../web/build/favicon.png"),
+        )
+            .into_response(),
+        "index.html" => (
+            [
+                (header::CONTENT_TYPE, HeaderValue::from_static("text/html")),
+                (header::CONTENT_ENCODING, HeaderValue::from_static("gzip")),
+            ],
+            include_bytes!("../web/build/index.html.gz"),
+        )
+            .into_response(),
+        path => {
+            warn!("404 on path: {path}");
+            StatusCode::NOT_FOUND.into_response()
+        }
+    }
+}
+
+pub async fn get_config(
+    State(state): State<Arc<ServerState>>,
+) -> Result<Json<Config>, (StatusCode, String)> {
+    Ok(Json(state.config.clone()))
+}
+
+pub async fn set_config(
+    State(state): State<Arc<ServerState>>,
+    Json(config): Json<Config>,
+) -> Result<(StatusCode, String), (StatusCode, String)> {
+    let config_str = toml::to_string_pretty(&config).map_err(|err| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("failed to serialize config as TOML: {err}"),
+        )
+    })?;
+
+    write(&state.config_path, config_str).await.map_err(|err| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("failed to write config file: {err}"),
+        )
+    })?;
+
+    // Trigger daemon restart after writing config
+    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(),
+        ))
+    }
+}
+
+pub async fn get_zip(
+    State(state): State<Arc<ServerState>>,
+    Path(entry_name): Path<String>,
+) -> Result<Response, (StatusCode, String)> {
+    let qmdl_idx = entry_name.trim_end_matches(".zip").to_owned();
+    let (entry_index, qmdl_size_bytes) = {
+        let qmdl_store = state.qmdl_store_lock.read().await;
+        let (entry_index, entry) = qmdl_store.entry_for_name(&qmdl_idx).ok_or((
+            StatusCode::NOT_FOUND,
+            format!("couldn't find entry with name {qmdl_idx}"),
+        ))?;
+
+        if entry.qmdl_size_bytes == 0 {
+            return Err((
+                StatusCode::SERVICE_UNAVAILABLE,
+                "QMDL file is empty, try again in a bit!".to_string(),
+            ));
+        }
+
+        (entry_index, entry.qmdl_size_bytes)
+    };
+
+    let qmdl_store_lock = state.qmdl_store_lock.clone();
+
+    let (reader, writer) = duplex(8192);
+
+    tokio::spawn(async move {
+        let result: Result<(), Error> = async {
+            let mut zip = ZipFileWriter::with_tokio(writer);
+
+            // Add QMDL file
+            {
+                let entry =
+                    ZipEntryBuilder::new(format!("{qmdl_idx}.qmdl").into(), Compression::Stored);
+                // FuturesAsyncWriteCompatExt::compat_write because async-zip's entrystream does
+                // not impl tokio's AsyncWrite, but only future's AsyncWrite. This can be removed
+                // once https://github.com/Majored/rs-async-zip/pull/160 is released.
+                let mut entry_writer = zip.write_entry_stream(entry).await?.compat_write();
+
+                let mut qmdl_file = {
+                    let qmdl_store = qmdl_store_lock.read().await;
+                    qmdl_store
+                        .open_entry_qmdl(entry_index)
+                        .await?
+                        .take(qmdl_size_bytes as u64)
+                };
+
+                copy(&mut qmdl_file, &mut entry_writer).await?;
+                entry_writer.into_inner().close().await?;
+            }
+
+            // Add PCAP file
+            {
+                let entry =
+                    ZipEntryBuilder::new(format!("{qmdl_idx}.pcapng").into(), Compression::Stored);
+                let mut entry_writer = zip.write_entry_stream(entry).await?.compat_write();
+
+                let qmdl_file_for_pcap = {
+                    let qmdl_store = qmdl_store_lock.read().await;
+                    qmdl_store
+                        .open_entry_qmdl(entry_index)
+                        .await?
+                        .take(qmdl_size_bytes as u64)
+                };
+
+                if let Err(e) =
+                    generate_pcap_data(&mut entry_writer, qmdl_file_for_pcap, qmdl_size_bytes).await
+                {
+                    // if we fail to generate the PCAP file, we should still continue and give the
+                    // user the QMDL.
+                    error!("Failed to generate PCAP: {e:?}");
+                }
+
+                entry_writer.into_inner().close().await?;
+            }
+
+            zip.close().await?;
+            Ok(())
+        }
+        .await;
+
+        if let Err(e) = result {
+            error!("Error generating ZIP file: {e:?}");
+        }
+    });
+
+    let headers = [(CONTENT_TYPE, "application/zip")];
+    let body = Body::from_stream(ReaderStream::new(reader));
+    Ok((headers, body).into_response())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use async_zip::base::read::mem::ZipFileReader;
+    use axum::extract::{Path, State};
+    use tempfile::TempDir;
+
+    async fn create_test_qmdl_store() -> (TempDir, Arc<RwLock<crate::qmdl_store::RecordingStore>>) {
+        let temp_dir = TempDir::new().unwrap();
+        let store_path = temp_dir.path().to_path_buf();
+        let store = crate::qmdl_store::RecordingStore::create(&store_path)
+            .await
+            .unwrap();
+        (temp_dir, Arc::new(RwLock::new(store)))
+    }
+
+    async fn create_test_entry_with_data(
+        store_lock: &Arc<RwLock<crate::qmdl_store::RecordingStore>>,
+        test_data: &[u8],
+    ) -> String {
+        let entry_name = {
+            let mut store = store_lock.write().await;
+            let (mut qmdl_file, _analysis_file) = store.new_entry().await.unwrap();
+
+            if !test_data.is_empty() {
+                use tokio::io::AsyncWriteExt;
+                qmdl_file.write_all(test_data).await.unwrap();
+                qmdl_file.flush().await.unwrap();
+            }
+
+            let current_entry = store.current_entry.unwrap();
+            let entry = &store.manifest.entries[current_entry];
+            let entry_name = entry.name.clone();
+
+            store
+                .update_entry_qmdl_size(current_entry, test_data.len())
+                .await
+                .unwrap();
+            entry_name
+        };
+
+        let mut store = store_lock.write().await;
+        store.close_current_entry().await.unwrap();
+        entry_name
+    }
+
+    fn create_test_server_state(
+        store_lock: Arc<RwLock<crate::qmdl_store::RecordingStore>>,
+    ) -> Arc<ServerState> {
+        let (tx, _rx) = tokio::sync::mpsc::channel(1);
+        let (ui_tx, _ui_rx) = tokio::sync::mpsc::channel(1);
+        let (analysis_tx, _analysis_rx) = tokio::sync::mpsc::channel(1);
+
+        let analysis_status = {
+            let store = store_lock.try_read().unwrap();
+            crate::analysis::AnalysisStatus::new(&store)
+        };
+
+        Arc::new(ServerState {
+            config_path: "/tmp/test_config.toml".to_string(),
+            config: Config::default(),
+            qmdl_store_lock: store_lock,
+            diag_device_ctrl_sender: tx,
+            ui_update_sender: ui_tx,
+            analysis_status_lock: Arc::new(RwLock::new(analysis_status)),
+            analysis_sender: analysis_tx,
+            daemon_restart_tx: Arc::new(RwLock::new(None)),
+        })
+    }
+
+    #[tokio::test]
+    async fn test_get_zip_success() {
+        let (_temp_dir, store_lock) = create_test_qmdl_store().await;
+        let test_qmdl_data = vec![0x7E, 0x00, 0x00, 0x00, 0x10, 0x00, 0x7E];
+        let entry_name = create_test_entry_with_data(&store_lock, &test_qmdl_data).await;
+        let state = create_test_server_state(store_lock);
+
+        let result = get_zip(State(state), Path(entry_name.clone())).await;
+
+        assert!(result.is_ok());
+        let response = result.unwrap();
+
+        let headers = response.headers();
+        assert_eq!(headers.get("content-type").unwrap(), "application/zip");
+
+        let body = response.into_body();
+        let body_bytes = axum::body::to_bytes(body, usize::MAX).await.unwrap();
+
+        let zip_reader = ZipFileReader::new(body_bytes.to_vec()).await.unwrap();
+
+        let filenames = zip_reader
+            .file()
+            .entries()
+            .iter()
+            .map(|entry| entry.filename().as_str().unwrap().to_owned())
+            .collect::<Vec<String>>();
+
+        assert_eq!(
+            filenames,
+            vec![format!("{entry_name}.qmdl"), format!("{entry_name}.pcapng"),]
+        );
+    }
+}

daemon/src/stats.rs

@@ -3,9 +3,9 @@ use std::sync::Arc;
 use crate::qmdl_store::ManifestEntry;
 use crate::server::ServerState;
 
+use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
-use axum::Json;
 use log::error;
 use rayhunter::util::RuntimeMetadata;
 use serde::Serialize;
@@ -102,7 +102,7 @@ impl MemoryStats {
 // turns a number of kilobytes (like 28293) into a human-readable string (like "28.3M")
 fn humanize_kb(kb: usize) -> String {
     if kb < 1000 {
-        return format!("{}K", kb);
+        return format!("{kb}K");
     }
     format!("{:.1}M", kb as f64 / 1024.0)
 }
@@ -114,7 +114,7 @@ pub async fn get_system_stats(
     match SystemStats::new(qmdl_store.path.to_str().unwrap()).await {
         Ok(stats) => Ok(Json(stats)),
         Err(err) => {
-            error!("error getting system stats: {}", err);
+            error!("error getting system stats: {err}");
             Err((
                 StatusCode::INTERNAL_SERVER_ERROR,
                 "error getting system stats".to_string(),

daemon/web/.prettierignore

@@ -2,3 +2,6 @@
 package-lock.json
 pnpm-lock.yaml
 yarn.lock
+
+# Static Assets
+static/pico.min.css

daemon/web/.prettierrc

@@ -0,0 +1,15 @@
+{
+    "singleQuote": true,
+    "tabWidth": 4,
+    "trailingComma": "es5",
+    "printWidth": 100,
+    "plugins": ["prettier-plugin-svelte"],
+    "overrides": [
+        {
+            "files": "*.svelte",
+            "options": {
+                "parser": "svelte"
+            }
+        }
+    ]
+}

daemon/web/eslint.config.js

@@ -0,0 +1,42 @@
+import prettier from 'eslint-config-prettier';
+import js from '@eslint/js';
+import svelte from 'eslint-plugin-svelte';
+import globals from 'globals';
+import ts from 'typescript-eslint';
+
+export default ts.config(
+    {
+        ignores: ['build/', '.svelte-kit/**', 'dist/'],
+    },
+    js.configs.recommended,
+    ...ts.configs.recommended,
+    ...svelte.configs['flat/recommended'],
+    prettier,
+    ...svelte.configs['flat/prettier'],
+    {
+        languageOptions: {
+            globals: {
+                ...globals.browser,
+                ...globals.node,
+            },
+        },
+    },
+    {
+        files: ['**/*.svelte'],
+
+        languageOptions: {
+            parserOptions: {
+                parser: ts.parser,
+            },
+        },
+    },
+    {
+        rules: {
+            '@typescript-eslint/no-unused-vars': [
+                'error',
+                { argsIgnorePattern: '^_', varsIgnorePattern: '^_' },
+            ],
+            '@typescript-eslint/no-explicit-any': 'off',
+        },
+    }
+);

daemon/web/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "web",
+    "version": "0.0.1",
+    "type": "module",
+    "scripts": {
+        "dev": "vite dev",
+        "build": "vite build && gzip -9 ./build/index.html",
+        "preview": "vite preview",
+        "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+        "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+        "test:unit": "vitest",
+        "test": "npm run test:unit -- --run",
+        "format": "prettier --write .",
+        "lint": "prettier --check . && eslint .",
+        "fix": "eslint --fix ."
+    },
+    "devDependencies": {
+        "@sveltejs/adapter-auto": "^3.0.0",
+        "@sveltejs/adapter-static": "^3.0.5",
+        "@sveltejs/kit": "^2.13.0",
+        "@sveltejs/vite-plugin-svelte": "^4.0.0",
+        "@types/eslint": "^9.6.0",
+        "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

@@ -0,0 +1,3 @@
+@import 'tailwindcss/base';
+@import 'tailwindcss/components';
+@import 'tailwindcss/utilities';

daemon/web/src/app.d.ts

@@ -0,0 +1,13 @@
+// See https://svelte.dev/docs/kit/types#app
+// for information about these interfaces
+declare global {
+    namespace App {
+        // interface Error {}
+        // interface Locals {}
+        // interface PageData {}
+        // interface PageState {}
+        // interface Platform {}
+    }
+}
+
+export {};

daemon/web/src/app.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en" data-theme="dark">
+    <head>
+        <meta charset="utf-8" />
+        <link rel="icon" href="%sveltekit.assets%/favicon.png" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        %sveltekit.head%
+    </head>
+    <body data-sveltekit-preload-data="hover">
+        <div style="display: contents" class="m-4 xl:m-8">%sveltekit.body%</div>
+    </body>
+</html>

daemon/web/src/lib/analysis.svelte.spec.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { AnalysisRowType, EventType, parse_finished_report, Severity } from './analysis.svelte';
+import { type NewlineDeliminatedJson } from './ndjson';
+
+const SAMPLE_V1_REPORT_NDJSON: NewlineDeliminatedJson = [
+    {
+        analyzers: [
+            {
+                name: 'Analyzer 1',
+                description: 'A first analyzer',
+            },
+            {
+                name: 'Analyzer 2',
+                description: 'A second analyzer',
+            },
+        ],
+    },
+    {
+        timestamp: '2024-10-08T13:25:43.011689003-07:00',
+        skipped_message_reasons: ['The reason why the message was skipped'],
+        analysis: [],
+    },
+    {
+        timestamp: '2024-10-08T13:25:43.480872496-07:00',
+        skipped_message_reasons: [],
+        analysis: [
+            {
+                timestamp: '2024-08-19T03:33:54.318Z',
+                events: [
+                    null,
+                    {
+                        event_type: { type: 'QualitativeWarning', severity: 'Low' },
+                        message: 'Something nasty happened',
+                    },
+                ],
+            },
+        ],
+    },
+];
+
+const SAMPLE_V2_REPORT_NDJSON: NewlineDeliminatedJson = [
+    {
+        analyzers: [
+            {
+                name: 'Analyzer 1',
+                description: 'A first analyzer',
+                version: 2,
+            },
+            {
+                name: 'Analyzer 2',
+                description: 'A second analyzer',
+                version: 2,
+            },
+        ],
+        report_version: 2,
+    },
+    {
+        skipped_message_reason: 'The reason why the message was skipped',
+    },
+    {
+        packet_timestamp: '2024-08-19T03:33:54.318Z',
+        events: [
+            null,
+            {
+                event_type: { type: 'QualitativeWarning', severity: 'Low' },
+                message: 'Something nasty happened',
+            },
+        ],
+    },
+];
+
+describe('analysis report parsing', () => {
+    it('parses v1 example analysis', () => {
+        const report = parse_finished_report(SAMPLE_V1_REPORT_NDJSON);
+        expect(report.metadata.report_version).toEqual(1);
+        expect(report.metadata.analyzers).toEqual([
+            {
+                name: 'Analyzer 1',
+                description: 'A first analyzer',
+                version: 0,
+            },
+            {
+                name: 'Analyzer 2',
+                description: 'A second analyzer',
+                version: 0,
+            },
+        ]);
+        expect(report.rows).toHaveLength(2);
+        expect(report.rows[0].type).toBe(AnalysisRowType.Skipped);
+        if (report.rows[1].type === AnalysisRowType.Analysis) {
+            const row = report.rows[1];
+            expect(row.events).toHaveLength(2);
+            expect(row.events[0]).toBeNull();
+            const event = row.events[1];
+            const expected_timestamp = new Date('2024-08-19T03:33:54.318Z');
+            expect(row.packet_timestamp.getTime()).toEqual(expected_timestamp.getTime());
+            if (event !== null && event.type === EventType.Warning) {
+                expect(event.severity).toEqual(Severity.Low);
+            } else {
+                throw 'wrong event type';
+            }
+        } else {
+            throw 'wrong row type';
+        }
+    });
+
+    it('parses v2 example analysis', () => {
+        const report = parse_finished_report(SAMPLE_V2_REPORT_NDJSON);
+        expect(report.metadata.report_version).toEqual(2);
+        expect(report.metadata.analyzers).toEqual([
+            {
+                name: 'Analyzer 1',
+                description: 'A first analyzer',
+                version: 2,
+            },
+            {
+                name: 'Analyzer 2',
+                description: 'A second analyzer',
+                version: 2,
+            },
+        ]);
+        expect(report.rows).toHaveLength(2);
+        expect(report.rows[0].type).toBe(AnalysisRowType.Skipped);
+        if (report.rows[1].type === AnalysisRowType.Analysis) {
+            const row = report.rows[1];
+            expect(row.events).toHaveLength(2);
+            expect(row.events[0]).toBeNull();
+            const event = row.events[1];
+            const expected_timestamp = new Date('2024-08-19T03:33:54.318Z');
+            expect(row.packet_timestamp.getTime()).toEqual(expected_timestamp.getTime());
+            if (event !== null && event.type === EventType.Warning) {
+                expect(event.severity).toEqual(Severity.Low);
+            } else {
+                throw 'wrong event type';
+            }
+        } else {
+            throw 'wrong row type';
+        }
+    });
+});

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

@@ -0,0 +1,208 @@
+import { parse_ndjson, type NewlineDeliminatedJson } from './ndjson';
+import { req } from './utils.svelte';
+
+export type AnalysisReport = {
+    metadata: ReportMetadata;
+    rows: AnalysisRow[];
+    statistics: ReportStatistics;
+};
+
+export type ReportStatistics = {
+    num_warnings: number;
+    num_informational_logs: number;
+    num_skipped_packets: number;
+};
+
+export class ReportMetadata {
+    public analyzers: AnalyzerMetadata[];
+    public rayhunter: RayhunterMetadata;
+    public report_version: number;
+
+    constructor(ndjson: any) {
+        this.analyzers = ndjson.analyzers;
+        this.rayhunter = ndjson.rayhunter;
+        if (ndjson.report_version === undefined) {
+            this.report_version = 1;
+            // we consider our legacy (unversioned) heuristics to be v0 --
+            // this'll let us clearly differentiate some known false-positive
+            // results from the pre-versioned era from v1 heuristics
+            this.analyzers.forEach((analyzer) => {
+                analyzer.version = 0;
+            });
+        } else {
+            this.report_version = ndjson.report_version;
+        }
+    }
+}
+
+export type RayhunterMetadata = {
+    rayhunter_version: string;
+    system_os: string;
+    arch: string;
+};
+
+export type AnalyzerMetadata = {
+    name: string;
+    description: string;
+    version: number;
+};
+
+export type AnalysisRow = SkippedPacket | PacketAnalysis;
+export enum AnalysisRowType {
+    Skipped,
+    Analysis,
+}
+
+export type SkippedPacket = {
+    type: AnalysisRowType.Skipped;
+    reason: string;
+};
+
+export type PacketAnalysis = {
+    type: AnalysisRowType.Analysis;
+    packet_timestamp: Date;
+    events: Event[];
+};
+
+export type Event = QualitativeWarning | InformationalEvent | null;
+export enum EventType {
+    Informational,
+    Warning,
+}
+
+export type QualitativeWarning = {
+    type: EventType.Warning;
+    severity: Severity;
+    message: string;
+};
+
+export enum Severity {
+    Low,
+    Medium,
+    High,
+}
+
+export type InformationalEvent = {
+    type: EventType.Informational;
+    message: string;
+};
+
+function get_event(event_json: any): Event {
+    if (event_json.event_type.type === 'Informational') {
+        return {
+            type: EventType.Informational,
+            message: event_json.message,
+        };
+    } else {
+        return {
+            type: EventType.Warning,
+            severity:
+                event_json.event_type.severity === 'High'
+                    ? Severity.High
+                    : event_json.event_type.severity === 'Medium'
+                      ? Severity.Medium
+                      : Severity.Low,
+            message: event_json.message,
+        };
+    }
+}
+
+function get_v1_rows(row_jsons: any[]): AnalysisRow[] {
+    const rows: AnalysisRow[] = [];
+    for (const row_json of row_jsons) {
+        for (const reason of row_json.skipped_message_reasons) {
+            rows.push({
+                type: AnalysisRowType.Skipped,
+                reason,
+            });
+        }
+        for (const analysis_json of row_json.analysis) {
+            const events: Event[] = analysis_json.events.map((event_json: any): Event | null => {
+                if (event_json === null) {
+                    return null;
+                } else {
+                    return get_event(event_json);
+                }
+            });
+            rows.push({
+                type: AnalysisRowType.Analysis,
+                packet_timestamp: new Date(analysis_json.timestamp),
+                events,
+            });
+        }
+    }
+    return rows;
+}
+
+function get_v2_rows(row_jsons: any[]): AnalysisRow[] {
+    const rows: AnalysisRow[] = [];
+    for (const row_json of row_jsons) {
+        if (row_json.skipped_message_reason) {
+            rows.push({
+                type: AnalysisRowType.Skipped,
+                reason: row_json.skipped_message_reason,
+            });
+        } else {
+            const events: Event[] = row_json.events.map((event_json: any): Event | null => {
+                if (event_json === null) {
+                    return null;
+                } else {
+                    return get_event(event_json);
+                }
+            });
+            rows.push({
+                type: AnalysisRowType.Analysis,
+                packet_timestamp: new Date(row_json.packet_timestamp),
+                events,
+            });
+        }
+    }
+    return rows;
+}
+
+function get_report_stats(rows: AnalysisRow[]): ReportStatistics {
+    let num_warnings = 0;
+    let num_informational_logs = 0;
+    let num_skipped_packets = 0;
+    for (const row of rows) {
+        if (row.type === AnalysisRowType.Skipped) {
+            num_skipped_packets++;
+        } else {
+            for (const event of row.events) {
+                if (event !== null) {
+                    if (event.type === EventType.Informational) {
+                        num_informational_logs++;
+                    } else {
+                        num_warnings++;
+                    }
+                }
+            }
+        }
+    }
+    return {
+        num_warnings,
+        num_informational_logs,
+        num_skipped_packets,
+    };
+}
+
+export function parse_finished_report(report_json: NewlineDeliminatedJson): AnalysisReport {
+    const metadata = new ReportMetadata(report_json[0]);
+    let rows;
+    if (metadata.report_version === 1) {
+        rows = get_v1_rows(report_json.slice(1));
+    } else {
+        rows = get_v2_rows(report_json.slice(1));
+    }
+    const statistics = get_report_stats(rows);
+    return {
+        statistics,
+        metadata,
+        rows,
+    };
+}
+
+export async function get_report(name: string): Promise<AnalysisReport> {
+    const report_json = parse_ndjson(await req('GET', `/api/analysis-report/${name}`));
+    return parse_finished_report(report_json);
+}

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

@@ -1,6 +1,5 @@
-import { get_report, type AnalysisReport } from "./analysis.svelte";
+import { get_report, type AnalysisReport } from './analysis.svelte';
-import type { Manifest, ManifestEntry } from "./manifest.svelte";
+import { req } from './utils.svelte';
-import { req } from "./utils.svelte";
 
 export enum AnalysisStatus {
     // rayhunter is currently analyzing this entry (note that this is distinct
@@ -19,8 +18,8 @@ type AnalysisStatusJson = {
 };
 
 export type AnalysisResult = {
-    name: string,
+    name: string;
-    status: AnalysisStatus,
+    status: AnalysisStatus;
 };
 
 export class AnalysisManager {
@@ -53,11 +52,13 @@ export class AnalysisManager {
 
             // fetch the analysis report
             this.reports.delete(entry);
-            get_report(entry).then(report => {
+            get_report(entry)
-                this.reports.set(entry, report);
+                .then((report) => {
-            }).catch(err => {
+                    this.reports.set(entry, report);
-                this.reports.set(entry, `Failed to get analysis: ${err}`);
+                })
-            });
+                .catch((err) => {
+                    this.reports.set(entry, `Failed to get analysis: ${err}`);
+                });
         }
     }
 }

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

@@ -0,0 +1,64 @@
+<script lang="ts">
+    import { AnalysisStatus } from '$lib/analysisManager.svelte';
+    import type { ManifestEntry } from '$lib/manifest.svelte';
+    let {
+        entry,
+        onclick,
+        analysis_visible,
+    }: {
+        entry: ManifestEntry;
+        onclick: () => void;
+        analysis_visible: boolean;
+    } = $props();
+
+    let summary = $derived.by(() => {
+        if (entry.analysis_status === AnalysisStatus.Queued) {
+            return 'Queued...';
+        } else if (entry.analysis_status === AnalysisStatus.Running) {
+            return 'Running...';
+        } else if (entry.analysis_status === AnalysisStatus.Finished) {
+            if (entry.analysis_report === undefined) {
+                return 'Loading...';
+            } else if (typeof entry.analysis_report === 'string') {
+                return entry.analysis_report;
+            } else {
+                return `${entry.analysis_report.statistics.num_warnings} warnings`;
+            }
+        } else {
+            return 'Loading...';
+        }
+    });
+
+    let ready = $derived.by(() => {
+        let finished = entry.analysis_status === AnalysisStatus.Finished;
+        let report_available = entry.analysis_report !== undefined;
+        return finished && report_available;
+    });
+
+    let button_class = $derived(ready ? 'text-blue-600 border rounded-full px-2' : '');
+</script>
+
+<button class="flex flex-row gap-1 lg:gap-2" disabled={!ready} {onclick}>
+    <span
+        class="{button_class} {(entry.get_num_warnings() || 0) < 1
+            ? 'text-green-700 border-green-500 bg-green-200'
+            : 'text-red-700 border-red-500 bg-red-200'}">{summary}</span
+    >
+    <svg
+        class="w-6 h-6 text-gray-800 transition-transform {analysis_visible ? 'rotate-180' : ''}"
+        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="m19 9-7 7-7-7"
+        />
+    </svg>
+</button>

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

@@ -0,0 +1,101 @@
+<script lang="ts">
+    import { AnalysisRowType, EventType, type AnalysisReport } from '$lib/analysis.svelte';
+    let {
+        report,
+    }: {
+        report: AnalysisReport;
+    } = $props();
+
+    const date_formatter = new Intl.DateTimeFormat(undefined, {
+        timeStyle: 'long',
+        dateStyle: 'short',
+    });
+
+    const analyzers = report.metadata.analyzers;
+
+    const skipped_messages: Map<string, number> = $derived.by(() => {
+        let map = new Map();
+        for (const row of report.rows) {
+            if (row.type === AnalysisRowType.Skipped) {
+                let count = map.get(row.reason);
+                if (count === undefined) {
+                    count = 0;
+                }
+                map.set(row.reason, count + 1);
+            }
+        }
+        return map;
+    });
+</script>
+
+<div>
+    <p class="text-lg underline">Warnings and Informational Logs</p>
+    {#if report.statistics.num_warnings === 0 && report.statistics.num_informational_logs === 0}
+        <p>Nothing to show!</p>
+    {:else}
+        <table class="table-auto text-left">
+            <thead class="p-2">
+                <tr class="bg-gray-300">
+                    <th class="p-2">Timestamp</th>
+                    <th class="p-2">Heuristic</th>
+                    <th class="p-2">Warning</th>
+                    <th class="p-2">Severity</th>
+                </tr>
+            </thead>
+            <tbody>
+                {#each report.rows as row}
+                    {#if row.type === AnalysisRowType.Analysis}
+                        {@const parsed_date = new Date(row.packet_timestamp)}
+                        {#each row.events.filter((e) => e !== null) as event, i}
+                            {@const analyzer = analyzers[i]}
+                            <tr class="even:bg-gray-200 odd:bg-white">
+                                {#if event.type === EventType.Warning}
+                                    {@const severity = ['Low', 'Medium', 'High'][event.severity]}
+                                    {@const severity_class = [
+                                        'bg-red-200',
+                                        'bg-red-400',
+                                        'bg-red-600',
+                                    ][event.severity]}
+                                    <td class="p-2">{date_formatter.format(parsed_date)}</td>
+                                    <td class="p-2">{analyzer.name} v{analyzer.version}</td>
+                                    <td class="p-2">{event.message}</td>
+                                    <td class="p-2 {severity_class} text-center">{severity}</td>
+                                {:else if event.type === EventType.Informational}
+                                    <td class="p-2">{date_formatter.format(parsed_date)}</td>
+                                    <td class="p-2">{analyzer.name} v{analyzer.version}</td>
+                                    <td class="p-2">{event.message}</td>
+                                    <td class="p-2">Info</td>
+                                {/if}
+                            </tr>
+                        {/each}
+                    {/if}
+                {/each}
+            </tbody>
+        </table>
+    {/if}
+</div>
+{#if report.statistics.num_skipped_packets > 0}
+    <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 ususally a
+            problem.
+        </p>
+        <table class="table-auto text-left">
+            <thead class="p-2">
+                <tr class="bg-gray-300">
+                    <th scope="col" class="p-2">Total Msgs Affected</th>
+                    <th scope="col">Reason/Error</th>
+                </tr>
+            </thead>
+            <tbody>
+                {#each skipped_messages.entries() as [message, count]}
+                    <tr class="even:bg-gray-200 odd:bg-white">
+                        <td class="text-center">{count}</td>
+                        <td>{message}</td>
+                    </tr>
+                {/each}
+            </tbody>
+        </table>
+    </div>
+{/if}

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

@@ -0,0 +1,42 @@
+<script lang="ts">
+    import { type ReportMetadata } from '$lib/analysis.svelte';
+    import type { ManifestEntry } from '$lib/manifest.svelte';
+    import AnalysisTable from './AnalysisTable.svelte';
+    let {
+        entry,
+    }: {
+        entry: ManifestEntry;
+    } = $props();
+</script>
+
+<div class="container mt-2">
+    {#if entry.analysis_report === undefined}
+        <p>Report unavailable, try refreshing.</p>
+    {:else if typeof entry.analysis_report === 'string'}
+        <p>Error getting analysis report: {entry.analysis_report}</p>
+    {:else}
+        {@const metadata: ReportMetadata = entry.analysis_report.metadata}
+        <div class="flex flex-col gap-2">
+            {#if entry.analysis_report.rows.length > 0}
+                <AnalysisTable report={entry.analysis_report} />
+            {:else}
+                <p>No warnings to display!</p>
+            {/if}
+            {#if metadata !== undefined && metadata.rayhunter !== undefined}
+                <div>
+                    <p class="text-lg underline">Metadata</p>
+                    <p>Analysis by Rayhunter version {metadata.rayhunter.rayhunter_version}</p>
+                    <p><b>Device system OS:</b> {metadata.rayhunter.system_os}</p>
+                </div>
+                <div>
+                    <p class="text-lg underline">Analyzers</p>
+                    {#each metadata.analyzers as analyzer}
+                        <p><b>{analyzer.name}:</b> {analyzer.description}</p>
+                    {/each}
+                </div>
+            {:else}
+                <p>N/A (analysis generated by an older version of rayhunter)</p>
+            {/if}
+        </div>
+    {/if}
+</div>

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

@@ -0,0 +1,258 @@
+<script lang="ts">
+    import { get_config, set_config, type Config } from '../utils.svelte';
+
+    let config = $state<Config | null>(null);
+
+    let loading = $state(false);
+    let saving = $state(false);
+    let message = $state('');
+    let messageType = $state<'success' | 'error' | null>(null);
+    let showConfig = $state(false);
+
+    async function loadConfig() {
+        try {
+            loading = true;
+            config = await get_config();
+            message = '';
+            messageType = null;
+        } catch (error) {
+            message = `Failed to load config: ${error}`;
+            messageType = 'error';
+        } finally {
+            loading = false;
+        }
+    }
+
+    async function saveConfig() {
+        if (!config) return;
+
+        try {
+            saving = true;
+            await set_config(config);
+            message =
+                'Config saved successfully! Rayhunter is restarting now. Reload the page in a few seconds.';
+            messageType = 'success';
+        } catch (error) {
+            message = `Failed to save config: ${error}`;
+            messageType = 'error';
+        } finally {
+            saving = false;
+        }
+    }
+
+    // Load config when first shown
+    $effect(() => {
+        if (showConfig && !config) {
+            loadConfig();
+        }
+    });
+</script>
+
+<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}
+            <form
+                class="space-y-4"
+                onsubmit={(e) => {
+                    e.preventDefault();
+                    saveConfig();
+                }}
+            >
+                <div>
+                    <label for="ui_level" class="block text-sm font-medium text-gray-700 mb-1">
+                        Device UI Level
+                    </label>
+                    <select
+                        id="ui_level"
+                        bind:value={config.ui_level}
+                        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>
+                    </select>
+                </div>
+
+                <div>
+                    <label
+                        for="key_input_mode"
+                        class="block text-sm font-medium text-gray-700 mb-1"
+                    >
+                        Device Input Mode
+                    </label>
+                    <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-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/stop recording</option
+                        >
+                    </select>
+                </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"
+                        />
+                        <label for="colorblind_mode" class="ml-2 block text-sm text-gray-700">
+                            Colorblind Mode
+                        </label>
+                    </div>
+                </div>
+
+                <div class="border-t pt-4 mt-6">
+                    <h3 class="text-lg font-semibold text-gray-800 mb-4">
+                        Analyzer Heuristic Settings
+                    </h3>
+                    <div class="space-y-3">
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label for="imsi_requested" class="ml-2 block text-sm text-gray-700">
+                                IMSI Requested Heuristic
+                            </label>
+                        </div>
+
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label
+                                for="connection_redirect_2g_downgrade"
+                                class="ml-2 block text-sm text-gray-700"
+                            >
+                                Connection Redirect 2G Downgrade Heuristic
+                            </label>
+                        </div>
+
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label
+                                for="lte_sib6_and_7_downgrade"
+                                class="ml-2 block text-sm text-gray-700"
+                            >
+                                LTE SIB6 and SIB7 Downgrade Heuristic
+                            </label>
+                        </div>
+
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label for="null_cipher" class="ml-2 block text-sm text-gray-700">
+                                Null Cipher Heuristic
+                            </label>
+                        </div>
+
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label for="nas_null_cipher" class="ml-2 block text-sm text-gray-700">
+                                NAS Null Cipher Heuristic
+                            </label>
+                        </div>
+
+                        <div class="flex items-center">
+                            <input
+                                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"
+                            />
+                            <label for="nas_null_cipher" class="ml-2 block text-sm text-gray-700">
+                                Incomplete SIB Heuristic
+                            </label>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="flex gap-2 pt-4">
+                    <button
+                        type="submit"
+                        disabled={saving}
+                        class="bg-blue-500 hover:bg-blue-700 disabled:opacity-50 text-white font-bold py-2 px-4 rounded-md flex flex-row gap-1 items-center"
+                    >
+                        {#if saving}
+                            <div
+                                class="w-4 h-4 border-2 border-white border-t-transparent rounded-full animate-spin"
+                            ></div>
+                            Saving...
+                        {: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="M5 13l4 4L19 7"
+                                ></path>
+                            </svg>
+                            Apply and restart
+                        {/if}
+                    </button>
+                </div>
+            </form>
+            {#if message}
+                <div
+                    class="mt-4 p-3 rounded {messageType === 'error'
+                        ? 'bg-red-100 text-red-700'
+                        : 'bg-green-100 text-green-700'}"
+                >
+                    {message}
+                </div>
+            {/if}
+        {:else}
+            <div class="text-center py-4 text-red-600">
+                Failed to load configuration. Please try reloading the page.
+            </div>
+        {/if}
+    {/if}
+</div>

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

@@ -0,0 +1,11 @@
+<script lang="ts">
+    import DeleteButton from './DeleteButton.svelte';
+</script>
+
+<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`}
+    />
+</div>

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

@@ -0,0 +1,32 @@
+<script lang="ts">
+    import { req } from '$lib/utils.svelte';
+    let {
+        text,
+        url,
+        prompt,
+    }: {
+        text?: string;
+        url: string;
+        prompt: string;
+    } = $props();
+
+    function confirmDelete() {
+        if (window.confirm(prompt)) {
+            req('POST', url);
+        }
+    }
+</script>
+
+<button
+    class="bg-red-500 hover:bg-red-700 text-white font-bold py-2 px-4 rounded-md flex flex-row"
+    onclick={confirmDelete}
+    aria-label="delete"
+>
+    <p>{text}</p>
+    <svg style="width:24px;height:24px" viewBox="0 0 24 24">
+        <path
+            fill="white"
+            d="M19,4H15.5L14.5,3H9.5L8.5,4H5V6H19M6,19A2,2 0 0,0 8,21H16A2,2 0 0,0 18,19V7H6V19Z"
+        />
+    </svg>
+</button>

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

@@ -0,0 +1,27 @@
+<script lang="ts">
+    let {
+        url,
+        text,
+        full_button = false,
+    }: {
+        url: string;
+        text: string;
+        full_button?: boolean;
+    } = $props();
+
+    function download() {
+        window.location.href = url;
+    }
+</script>
+
+<button
+    class="flex flex-row {full_button
+        ? 'bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded-md'
+        : 'text-blue-600 underline'}"
+    onclick={download}
+>
+    {text}
+    <svg class="fill-current w-4 h-4 m-1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20">
+        <path d="M13 8V2H7v6H2l8 8 8-8h-5zM0 18h20v2H0v-2z" />
+    </svg>
+</button>

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

@@ -1,64 +1,87 @@
 <script lang="ts">
-    import { ManifestEntry } from "$lib/manifest.svelte";
+    import { ManifestEntry } from '$lib/manifest.svelte';
     import DownloadLink from '$lib/components/DownloadLink.svelte';
-    import DeleteButton from "$lib/components/DeleteButton.svelte";
+    import DeleteButton from '$lib/components/DeleteButton.svelte';
-	import AnalysisStatus from "./AnalysisStatus.svelte";
+    import AnalysisStatus from './AnalysisStatus.svelte';
-	import AnalysisView from "./AnalysisView.svelte";
+    import AnalysisView from './AnalysisView.svelte';
-    import RecordingControls from "./RecordingControls.svelte";
+    import RecordingControls from './RecordingControls.svelte';
-    let { entry, current, i, server_is_recording }: {
+    let {
+        entry,
+        current,
+        server_is_recording,
+    }: {
         entry: ManifestEntry;
         current: boolean;
-        i: number;
         server_is_recording: boolean;
     } = $props();
 
     // passing `undefined` as the locale uses the browser default
     const date_formatter = new Intl.DateTimeFormat(undefined, {
-        timeStyle: "long",
+        timeStyle: 'long',
-        dateStyle: "short",
+        dateStyle: 'short',
     });
     let status_row_color = $derived.by(() => {
         const num_warnings = entry.get_num_warnings();
         if (num_warnings !== undefined && num_warnings > 0) {
-            return "bg-red-100";
+            return 'bg-red-100';
         }
-        return current ? "bg-green-100" : "bg-gray-100"
+        return current ? 'bg-green-100' : 'bg-gray-100';
     });
     let status_border_color = $derived.by(() => {
         const num_warnings = entry.get_num_warnings();
         if (num_warnings !== undefined && num_warnings > 0) {
-            return "border-red-100";
+            return 'border-red-100';
         }
-        return current ? "border-green-100" : "border-gray-100"
+        return current ? 'border-green-100' : 'border-gray-100';
     });
     let analysis_visible = $state(false);
     function toggle_analysis_visibility() {
         analysis_visible = !analysis_visible;
     }
 </script>
-<div class="{status_row_color} {status_border_color} drop-shadow p-4 flex flex-col gap-2 border rounded-md flex-1">
+
+<div
+    class="{status_row_color} {status_border_color} drop-shadow p-4 flex flex-col gap-2 border rounded-md flex-1"
+>
     {#if current}
         <div class="flex flex-row justify-between gap-2">
             <span class="text-xl mb-2">Current Recording</span>
-            <span class=""><AnalysisStatus onclick={toggle_analysis_visibility} entry={entry} analysis_visible={analysis_visible}/></span>
+            <span class=""
+                ><AnalysisStatus
+                    onclick={toggle_analysis_visibility}
+                    {entry}
+                    {analysis_visible}
+                /></span
+            >
         </div>
     {/if}
     <div class="flex flex-col">
         <div class="flex flex-row justify-between">
             <span class="font-bold">ID: {entry.name}</span>
             {#if !current}
-                <span class=""><AnalysisStatus onclick={toggle_analysis_visibility} entry={entry} analysis_visible={analysis_visible}/></span>
+                <span class=""
+                    ><AnalysisStatus
+                        onclick={toggle_analysis_visibility}
+                        {entry}
+                        {analysis_visible}
+                    /></span
+                >
             {/if}
         </div>
         <span class="">{entry.get_readable_qmdl_size()}</span>
     </div>
     <div class="flex flex-col">
         <span class="">Start: {date_formatter.format(entry.start_time)}</span>
-        <span class="">Last Message: {date_formatter.format(entry.last_message_time)}</span>
+        <span class=""
+            >Last Message: {(entry.last_message_time &&
+                date_formatter.format(entry.last_message_time)) ||
+                'N/A'}</span
+        >
     </div>
     <div class="flex flex-row justify-between lg:justify-end gap-2 mt-2">
-        <DownloadLink url={entry.get_pcap_url()} text="pcap" full_button=true />
+        <DownloadLink url={entry.get_pcap_url()} text="pcap" full_button />
-        <DownloadLink url={entry.get_qmdl_url()} text="qmdl" full_button=true />
+        <DownloadLink url={entry.get_qmdl_url()} text="qmdl" full_button />
+        <DownloadLink url={entry.get_zip_url()} text="zip" full_button />
         {#if current}
             <RecordingControls {server_is_recording} />
         {:else}

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

@@ -0,0 +1,38 @@
+<script lang="ts">
+    import { ManifestEntry } from '$lib/manifest.svelte';
+    import TableRow from './ManifestTableRow.svelte';
+    import Card from './ManifestCard.svelte';
+    interface Props {
+        entries: ManifestEntry[];
+        server_is_recording: boolean;
+    }
+    let { entries, server_is_recording }: Props = $props();
+</script>
+
+<!--For larger screens we use a table-->
+<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">PCAP</th>
+            <th class="p-2" scope="col">QMDL</th>
+            <th class="p-2" scope="col">ZIP</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} />
+        {/each}
+    </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} />
+    {/each}
+</div>

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

@@ -1,10 +1,14 @@
 <script lang="ts">
-    import { ManifestEntry } from "$lib/manifest.svelte";
+    import { ManifestEntry } from '$lib/manifest.svelte';
     import DownloadLink from '$lib/components/DownloadLink.svelte';
-    import DeleteButton from "$lib/components/DeleteButton.svelte";
+    import DeleteButton from '$lib/components/DeleteButton.svelte';
-	import AnalysisStatus from "./AnalysisStatus.svelte";
+    import AnalysisStatus from './AnalysisStatus.svelte';
-	import AnalysisView from "./AnalysisView.svelte";
+    import AnalysisView from './AnalysisView.svelte';
-    let { entry, current, i }: {
+    let {
+        entry,
+        current,
+        i,
+    }: {
         entry: ManifestEntry;
         current: boolean;
         i: number;
@@ -12,16 +16,16 @@
 
     // passing `undefined` as the locale uses the browser default
     const date_formatter = new Intl.DateTimeFormat(undefined, {
-        timeStyle: "long",
+        timeStyle: 'long',
-        dateStyle: "short",
+        dateStyle: 'short',
     });
-    let alternating_row_color = $derived(i % 2 == 0 ? "bg-white" : "bg-gray-100");
+    let alternating_row_color = $derived(i % 2 == 0 ? 'bg-white' : 'bg-gray-100');
     let status_row_color = $derived.by(() => {
         const num_warnings = entry.get_num_warnings();
         if (num_warnings !== undefined && num_warnings > 0) {
-            return "bg-red-100";
+            return 'bg-red-100';
         }
-        return current ? "bg-green-100" : alternating_row_color
+        return current ? 'bg-green-100' : alternating_row_color;
     });
     let analysis_visible = $state(false);
     function toggle_analysis_visibility() {
@@ -32,11 +36,16 @@
 <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">{date_formatter.format(entry.last_message_time)}</td>
+    <td class="p-2"
+        >{(entry.last_message_time && date_formatter.format(entry.last_message_time)) || 'N/A'}</td
+    >
     <td class="p-2">{entry.get_readable_qmdl_size()}</td>
     <td class="p-2"><DownloadLink url={entry.get_pcap_url()} text="pcap" /></td>
     <td class="p-2"><DownloadLink url={entry.get_qmdl_url()} text="qmdl" /></td>
-    <td class="p-2"><AnalysisStatus onclick={toggle_analysis_visibility} entry={entry} analysis_visible={analysis_visible}/></td>
+    <td class="p-2"><DownloadLink url={entry.get_zip_url()} text="zip" /></td>
+    <td class="p-2"
+        ><AnalysisStatus onclick={toggle_analysis_visibility} {entry} {analysis_visible} /></td
+    >
     {#if current}
         <td class="p-2"></td>
     {:else}
@@ -49,7 +58,7 @@
     {/if}
 </tr>
 <tr class="{alternating_row_color} border-b {analysis_visible ? '' : 'hidden'}">
-    <td class="border-t border-dashed p-2" colspan="8">
+    <td class="border-t border-dashed p-2" colspan="9">
         <AnalysisView {entry} />
     </td>
 </tr>

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

@@ -0,0 +1,100 @@
+<script lang="ts">
+    import { req } from '$lib/utils.svelte';
+    let {
+        server_is_recording,
+    }: {
+        server_is_recording: boolean;
+    } = $props();
+
+    let client_set_recording = $state(server_is_recording);
+    let waiting_for_server = $derived(client_set_recording !== server_is_recording);
+
+    async function start_recording() {
+        await req('POST', '/api/start-recording');
+        client_set_recording = true;
+    }
+
+    async function stop_recording() {
+        await req('POST', '/api/stop-recording');
+        client_set_recording = false;
+    }
+
+    const recording_button_classes =
+        'text-white font-bold py-2 px-4 rounded-md flex flex-row gap-1';
+    const stop_recording_classes = `${recording_button_classes} bg-red-500 opacity-50 cursor-not-allowed`;
+    const start_recording_classes = `${recording_button_classes} bg-blue-500 opacity-50 cursor-not-allowed`;
+</script>
+
+<div>
+    {#if waiting_for_server}
+        <button
+            class={server_is_recording ? stop_recording_classes : start_recording_classes}
+            disabled
+        >
+            <span>{server_is_recording ? 'Stopping...' : 'Starting...'}</span>
+            <svg
+                class="w-4 h-4 text-white animate-spin"
+                xmlns="http://www.w3.org/2000/svg"
+                fill="none"
+                viewBox="0 0 24 24"
+            >
+                <circle
+                    class="opacity-25"
+                    cx="12"
+                    cy="12"
+                    r="10"
+                    stroke="currentColor"
+                    stroke-width="4"
+                ></circle>
+                <path
+                    class="opacity-75"
+                    fill="currentColor"
+                    d="m4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+                ></path>
+            </svg>
+        </button>
+    {:else if server_is_recording}
+        <button
+            class="{recording_button_classes} bg-red-500 hover:bg-red-700"
+            onclick={stop_recording}
+        >
+            <span>Stop</span>
+            <svg
+                class="w-6 h-6 text-white"
+                aria-hidden="true"
+                xmlns="http://www.w3.org/2000/svg"
+                width="24"
+                height="24"
+                fill="currentColor"
+                viewBox="0 0 24 24"
+            >
+                <path d="M7 5a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2H7Z" />
+            </svg>
+        </button>
+    {:else}
+        <button
+            class="{recording_button_classes} bg-blue-500 hover:bg-blue-700"
+            onclick={start_recording}
+        >
+            <span>Start</span>
+            <svg
+                class="w-6 h-6 text-white"
+                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="M8.6 5.2A1 1 0 0 0 7 6v12a1 1 0 0 0 1.6.8l8-6a1 1 0 0 0 0-1.6l-8-6Z"
+                    clip-rule="evenodd"
+                />
+            </svg>
+        </button>
+    {/if}
+</div>
+
+<style>
+</style>

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

@@ -1,34 +1,33 @@
 <script lang="ts">
-    import { type SystemStats } from "$lib/systemStats";
+    import { type SystemStats } from '$lib/systemStats';
-    let { stats }: {
+    let {
+        stats,
+    }: {
         stats: SystemStats;
     } = $props();
 
-    const table_cell_classes = "border p-1 lg:p-2";
+    const table_cell_classes = 'border p-1 lg:p-2';
 </script>
 
-<div class="flex-1 drop-shadow p-4 flex flex-col gap-2 border rounded-md bg-gray-100 border-gray-100">
+<div
+    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">
         <tbody>
             <tr class="border">
-                <th class={table_cell_classes}>
+                <th class={table_cell_classes}> Rayhunter Version </th>
-                    Rayhunter Version
-                </th>
                 <td class={table_cell_classes}>{stats.runtime_metadata.rayhunter_version}</td>
             </tr>
             <tr class="border">
-                <th class={table_cell_classes}>
+                <th class={table_cell_classes}> Storage </th>
-                    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)
+                    {stats.disk_stats.used_percent} used ({stats.disk_stats.used_size} used / {stats
+                        .disk_stats.available_size} available)
                 </td>
             </tr>
             <tr class="border-b">
-                <th class={table_cell_classes}>
+                <th class={table_cell_classes}> Memory (RAM) </th>
-                    Memory (RAM)
-                </th>
                 <td class={table_cell_classes}>
                     Free: {stats.memory_stats.free}, Used: {stats.memory_stats.used}
                 </td>

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

@@ -1,5 +1,5 @@
-import { get_report, type AnalysisReport } from "./analysis.svelte";
+import { get_report, type AnalysisReport } from './analysis.svelte';
-import { AnalysisStatus, type AnalysisManager } from "./analysisManager.svelte";
+import { AnalysisStatus, type AnalysisManager } from './analysisManager.svelte';
 
 interface JsonManifest {
     entries: JsonManifestEntry[];
@@ -11,7 +11,6 @@ interface JsonManifestEntry {
     start_time: string;
     last_message_time: string;
     qmdl_size_bytes: number;
-    analysis_size_bytes: number;
 }
 
 export class Manifest {
@@ -19,7 +18,7 @@ export class Manifest {
     public current_entry: ManifestEntry | undefined;
 
     constructor(json: JsonManifest) {
-        for (let entry of json.entries) {
+        for (const entry of json.entries) {
             this.entries.push(new ManifestEntry(entry));
         }
         if (json.current_entry !== null) {
@@ -31,7 +30,7 @@ export class Manifest {
     }
 
     async set_analysis_status(manager: AnalysisManager) {
-        for (let entry of this.entries) {
+        for (const entry of this.entries) {
             entry.analysis_status = manager.status.get(entry.name);
             entry.analysis_report = manager.reports.get(entry.name);
         }
@@ -39,7 +38,7 @@ export class Manifest {
         if (this.current_entry) {
             try {
                 this.current_entry.analysis_report = await get_report(this.current_entry.name);
-            } catch(err) {
+            } catch (err) {
                 this.current_entry.analysis_report = `Err: failed to get analysis report: ${err}`;
             }
 
@@ -47,11 +46,11 @@ export class Manifest {
             // analysis report is always available
             this.current_entry.analysis_status = AnalysisStatus.Finished;
         }
-	}
+    }
 }
 
 export class ManifestEntry {
-    public name = $state("");
+    public name = $state('');
     public start_time: Date;
     public last_message_time: Date | undefined = $state(undefined);
     public qmdl_size_bytes = $state(0);
@@ -62,35 +61,38 @@ export class ManifestEntry {
     constructor(json: JsonManifestEntry) {
         this.name = json.name;
         this.qmdl_size_bytes = json.qmdl_size_bytes;
-        this.analysis_size_bytes = json.analysis_size_bytes;
         this.start_time = new Date(json.start_time);
-        if (json.last_message_time !== undefined) {
+        if (json.last_message_time) {
             this.last_message_time = new Date(json.last_message_time);
         }
     }
 
     get_readable_qmdl_size(): string {
-        if (this.qmdl_size_bytes === 0) return "0 Bytes";
+        if (this.qmdl_size_bytes === 0) return '0 Bytes';
         const k = 1024;
-        const dm = 2 || 2;
+        const dm = 2;
-        const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
         const i = Math.floor(Math.log(this.qmdl_size_bytes) / Math.log(k));
         return `${Number.parseFloat((this.qmdl_size_bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
-      }
+    }
 
     get_num_warnings(): number | undefined {
-        if (this.analysis_report === undefined || typeof(this.analysis_report) === 'string') {
+        if (this.analysis_report === undefined || typeof this.analysis_report === 'string') {
             return undefined;
         }
         return this.analysis_report.statistics.num_warnings;
     }
 
     get_pcap_url(): string {
-        return `/api/pcap/${this.name}`;
+        return `/api/pcap/${this.name}.pcapng`;
     }
 
     get_qmdl_url(): string {
-        return `/api/qmdl/${this.name}`;
+        return `/api/qmdl/${this.name}.qmdl`;
+    }
+
+    get_zip_url(): string {
+        return `/api/zip/${this.name}.zip`;
     }
 
     get_analysis_report_url(): string {
@@ -99,5 +101,5 @@ export class ManifestEntry {
 
     get_delete_url(): string {
         return `/api/delete-recording/${this.name}`;
-	}
+    }
 }

daemon/web/src/lib/ndjson.spec.ts

@@ -2,32 +2,32 @@ import { describe, it, expect } from 'vitest';
 import { parse_ndjson } from './ndjson';
 
 describe('parsing newline-deliminated json', () => {
-	it('parses normal JSON', () => {
+    it('parses normal JSON', () => {
         const json = JSON.stringify({ foo: 100 });
         const result = parse_ndjson(json);
         expect(result).toHaveLength(1);
         expect(result[0]).toEqual({ foo: 100 });
-	});
+    });
 
-	it('parses simple newline-deliminated json', () => {
+    it('parses simple newline-deliminated json', () => {
         const json_a = JSON.stringify({ a: 100 });
         const json_b = JSON.stringify({ b: 200 });
         const result = parse_ndjson(`${json_a}\n${json_b}`);
         expect(result).toHaveLength(2);
         expect(result[0]).toEqual({ a: 100 });
         expect(result[1]).toEqual({ b: 200 });
-	})
+    });
 
-	it('parses newline-deliminated json with escaped newlines within', () => {
+    it('parses newline-deliminated json with escaped newlines within', () => {
-    	const json_a = JSON.stringify({ a: 'this one has\n newlines and\nstuff' });
+        const json_a = JSON.stringify({ a: 'this one has\n newlines and\nstuff' });
         const json_b = JSON.stringify({ b: 200 });
         const result = parse_ndjson(`${json_a}\n${json_b}`);
         expect(result).toHaveLength(2);
         expect(result[0]).toEqual({ a: 'this one has\n newlines and\nstuff' });
         expect(result[1]).toEqual({ b: 200 });
-	})
+    });
 
     it('actually errors out on invalid ndjson', () => {
-        expect(() =>  parse_ndjson("invalid\njson")).toThrow();
+        expect(() => parse_ndjson('invalid\njson')).toThrow();
     });
 });

daemon/web/src/lib/systemStats.ts

@@ -0,0 +1,26 @@
+export interface SystemStats {
+    disk_stats: DiskStats;
+    memory_stats: MemoryStats;
+    runtime_metadata: RuntimeMetadata;
+}
+
+export interface RuntimeMetadata {
+    rayhunter_version: string;
+    system_os: string;
+    arch: string;
+}
+
+export interface DiskStats {
+    partition: string;
+    total_size: string;
+    used_size: string;
+    available_size: string;
+    used_percent: string;
+    mounted_on: string;
+}
+
+export interface MemoryStats {
+    total: string;
+    used: string;
+    free: string;
+}

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

@@ -0,0 +1,58 @@
+import { Manifest } from './manifest.svelte';
+import type { SystemStats } from './systemStats';
+
+export interface AnalyzerConfig {
+    imsi_requested: boolean;
+    connection_redirect_2g_downgrade: boolean;
+    lte_sib6_and_7_downgrade: boolean;
+    null_cipher: boolean;
+    nas_null_cipher: boolean;
+    incomplete_sib: boolean;
+}
+
+export interface Config {
+    ui_level: number;
+    colorblind_mode: boolean;
+    key_input_mode: number;
+    analyzers: AnalyzerConfig;
+}
+
+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 body;
+    } else {
+        throw new Error(body);
+    }
+}
+
+export async function get_manifest(): Promise<Manifest> {
+    const manifest_json = JSON.parse(await req('GET', '/api/qmdl-manifest'));
+    return new Manifest(manifest_json);
+}
+
+export async function get_system_stats(): Promise<SystemStats> {
+    return JSON.parse(await req('GET', '/api/system-stats'));
+}
+
+export async function get_config(): Promise<Config> {
+    return JSON.parse(await req('GET', '/api/config'));
+}
+
+export async function set_config(config: Config): Promise<void> {
+    const response = await fetch('/api/config', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(config),
+    });
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(error);
+    }
+}