docs: Readme (#1358)

*

.devcontainer/codespaces.yml

@@ -0,0 +1,19 @@
+services:
+  dsm:
+    container_name: dsm
+    image: ghcr.io/vdsm/virtual-dsm
+    environment:
+      RAM_SIZE: "half"
+      DISK_SIZE: "max"
+      CPU_CORES: "max"
+    devices:
+      - /dev/kvm
+      - /dev/net/tun
+    cap_add:
+      - NET_ADMIN
+    ports:
+      - 5000:5000
+    volumes:
+      - ./dsm:/storage
+    restart: on-failure
+    stop_grace_period: 2m

.devcontainer/devcontainer.json

@@ -0,0 +1,15 @@
+{
+  "name": "Virtual DSM",
+  "service": "dsm",
+  "forwardPorts": [5000],
+  "portsAttributes": {
+    "5000": {
+      "label": "Web",
+      "onAutoForward": "notify"
+    }
+  },
+  "otherPortsAttributes": {
+    "onAutoForward": "ignore"
+  }, 
+  "dockerComposeFile": "codespaces.yml"
+}

.dockerignore

@@ -1,4 +1,5 @@
 .dockerignore
+.devcontainer
 .git
 .github
 .gitignore
@@ -6,7 +7,10 @@
 .gitmodules
 Dockerfile
 Dockerfile.archive
+compose.yml
+compose.yaml
 docker-compose.yml
+docker-compose.yaml
 
 *.md
 

.github/ISSUE_TEMPLATE/1-issue.yml

@@ -0,0 +1,41 @@
+name: "\U0001F6A8 Technical issue"
+description: When you're experiencing problems using the container
+body:
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: Your Linux distribution (can be shown by `lsb_release -a`).
+      placeholder: e.g. Ubuntu 24.04
+    validations:
+      required: true
+  - type: textarea
+    id: summary
+    attributes:
+      label: Description
+      description: A clear and concise description of your issue.
+    validations:
+      required: true
+  - type: textarea
+    id: compose
+    attributes:
+      label: Docker compose
+      description: The compose file (or otherwise the `docker run` command used).
+      render: yaml
+    validations:
+      required: true
+  - type: textarea
+    id: log
+    attributes:
+      label: Docker log
+      description: The logfile of the container (as shown by `docker logs dsm`).
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: screenshot
+    attributes:
+      label: Screenshots (optional)
+      description: Screenshots that might help to make the problem more clear.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/2-feature.yml

@@ -0,0 +1,37 @@
+name: "\U0001F680 Feature request"
+description: Suggest an idea for improving the container
+title: "[Feature]: "
+labels: ["enhancement"]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Is your proposal related to a problem?
+      description: |
+        Provide a clear and concise description of what the problem is.
+        For example, "I'm always frustrated when..."
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like.
+      description: |
+        Provide a clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered.
+      description: |
+        Let us know about other solutions you've tried or researched.
+    validations:
+      required: true
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: |
+        Is there anything else you can add about the proposal?
+        You might want to link to related issues here, if you haven't already.

.github/ISSUE_TEMPLATE/3-bug.yml

@@ -0,0 +1,43 @@
+name: "\U0001F41E Bug report"
+description: Create a report to help us improve the container
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: input
+    id: os
+    attributes:
+      label: Operating system
+      description: Your Linux distribution (can be shown by `lsb_release -a`).
+      placeholder: e.g. Ubuntu 24.04
+    validations:
+      required: true
+  - type: textarea
+    id: summary
+    attributes:
+      label: Description
+      description: Describe the expected behaviour, the actual behaviour, and the steps to reproduce.
+    validations:
+      required: true
+  - type: textarea
+    id: compose
+    attributes:
+      label: Docker compose
+      description: The compose file (or otherwise the `docker run` command used).
+      render: yaml
+    validations:
+      required: true
+  - type: textarea
+    id: log
+    attributes:
+      label: Docker log
+      description: The logfile of the container (as shown by `docker logs dsm`).
+      render: shell
+    validations:
+      required: true
+  - type: textarea
+    id: screenshot
+    attributes:
+      label: Screenshots (optional)
+      description: Screenshots that might help to make the problem more clear.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/4-question.yml

@@ -0,0 +1,26 @@
+name: "\U00002753 General question"
+description: Questions about the container not related to an issue
+title: "[Question]: "
+labels: ["question"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Is your question not already answered in the FAQ?
+      description: Please read the [FAQ](https://github.com/vdsm/virtual-dsm/blob/master/readme.md) carefully to avoid asking duplicate questions.
+      options:
+      - label: I made sure the question is not listed in the [FAQ](https://github.com/vdsm/virtual-dsm/blob/master/readme.md).
+        required: true
+  - type: checkboxes
+    attributes:
+      label: Is this a general question and not a technical issue?
+      description: For questions related to issues you must use the [technical issue](https://github.com/vdsm/virtual-dsm/issues/new?assignees=&labels=&projects=&template=1-issue.yml) form instead. It contains all the right fields (system info, logfiles, etc.) we need in order to be able to help you.
+      options:
+      - label: I am sure my question is not about a technical issue.
+        required: true
+  - type: textarea
+    id: question
+    attributes:
+      label: Question
+      description: What's the question you have about the container?
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/dependabot.yml

@@ -1,10 +1,21 @@
 version: 2
+
 updates:
   - package-ecosystem: docker
     directory: /
     schedule:
       interval: weekly
+    cooldown:
+      default-days: 7
+
   - package-ecosystem: github-actions
     directory: /
     schedule:
       interval: weekly
+    cooldown:
+      default-days: 7
+    ignore:
+      - dependency-name: "*"
+        update-types:
+          - version-update:semver-minor
+          - version-update:semver-patch

.github/workflows/build.yml

@@ -2,16 +2,6 @@ name: Build
 
 on:
   workflow_dispatch:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**/*.md'
-      - '**/*.yml'
-      - '.gitignore'
-      - '.dockerignore'
-      - '.github/**'
-      - '.github/workflows/**'
 
 concurrency:
   group: build
@@ -32,13 +22,13 @@ jobs:
     steps:
       -
         name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0
       -
         name: Docker metadata
         id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
         with:
           context: git
           images: |
@@ -53,28 +43,28 @@ jobs:
           DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,index
       - 
         name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
       -
         name: Login into Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
       -
         name: Login to GitHub Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       -
         name: Build Docker image
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v7
         with:
           context: .
           push: true
           provenance: false
-          platforms: linux/amd64,linux/arm64,linux/arm
+          platforms: linux/amd64,linux/arm64
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           annotations: ${{ steps.meta.outputs.annotations }}
@@ -99,3 +89,15 @@ jobs:
           url: ${{ secrets.GITLAB_URL }}
           token: ${{ secrets.GITLAB_TOKEN }}
           username: ${{ secrets.GITLAB_USERNAME }}
+      -
+        name: Send mail
+        uses: action-pack/send-mail@v1
+        with:
+          to: ${{secrets.MAILTO}}
+          from: Github Actions <${{secrets.MAILTO}}>
+          connection_url: ${{secrets.MAIL_CONNECTION}}
+          subject: Build of ${{ github.event.repository.name }} v${{ steps.meta.outputs.version }} completed
+          body: |
+              The build job of ${{ github.event.repository.name }} v${{ steps.meta.outputs.version }} was completed successfully! 
+              
+              See https://github.com/${{ github.repository }}/actions for more information.

.github/workflows/check.yml

@@ -1,5 +1,7 @@
 on: [workflow_call]
+
 name: "Check"
+
 permissions: {}
 
 jobs:
@@ -7,8 +9,29 @@ jobs:
     name: shellcheck
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      -
-      - name: Run ShellCheck
+        name: Checkout
-        uses: ludeeus/action-shellcheck@master
+        uses: actions/checkout@v7
-env:
+      - parallel:
-        SHELLCHECK_OPTS: -x --source-path=src -e SC2001 -e SC2002 -e SC2223 -e SC2034 -e SC2064 -e SC2317 -e SC2028 -e SC2153 -e SC2004 
+          -
+            name: Run ShellCheck
+            uses: ludeeus/action-shellcheck@master
+            env:
+              SHELLCHECK_OPTS: >-
+                -x
+                --source-path=src
+                -e SC1091
+                -e SC2001
+                -e SC2034
+                -e SC2317
+                -e SC2153
+          -
+            name: Lint Dockerfile
+            uses: hadolint/hadolint-action@v3.4.0
+            with:
+              dockerfile: Dockerfile
+              ignore: DL3008
+              failure-threshold: warning
+          -
+            name: Validate JSON and YML files
+            uses: GrantBirki/json-yaml-validate@v5

.github/workflows/hub.yml

@@ -12,13 +12,15 @@ jobs:
   dockerHubDescription:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+      -
-    - 
+        name: Checkout repo
-      name: Docker Hub Description
+        uses: actions/checkout@v7
-      uses: peter-evans/dockerhub-description@v3
+      - 
-      with:
+        name: Docker Hub Description
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        uses: peter-evans/dockerhub-description@v5
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
+        with:
-        repository: ${{ secrets.DOCKERHUB_REPO }}
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
-        short-description: ${{ github.event.repository.description }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
-        readme-filepath: ./readme.md
+          repository: ${{ secrets.DOCKERHUB_REPO }}
+          short-description: ${{ github.event.repository.description }}
+          readme-filepath: ./readme.md

.github/workflows/review.yml

@@ -0,0 +1,14 @@
+on:
+  pull_request:
+
+name: "Review"
+
+permissions:
+  contents: read
+  pull-requests: write
+  checks: write
+
+jobs:
+  review:
+    name: review
+    uses: action-pack/.github/.github/workflows/review.yml@master

.github/workflows/test.yml

@@ -1,10 +1,6 @@
 on:
   workflow_dispatch:
   pull_request:
-    paths:
-      - '**/*.sh'
-      - '.github/workflows/test.yml'
-      - '.github/workflows/check.yml'
 
 name: "Test"
 permissions: {}

.gitignore

@@ -1 +1,268 @@
-build.sh
+##############################
+# Operating System Files
+##############################
+
+.DS_Store
+.AppleDouble
+.LSOverride
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+Icon?
+$RECYCLE.BIN/
+.Spotlight-V100/
+.Trashes/
+.fseventsd
+
+##############################
+# IDEs
+##############################
+
+.vscode/
+.idea/
+*.iml
+*.ipr
+*.iws
+
+##############################
+# VS Code
+##############################
+
+.history/
+*.code-workspace
+
+##############################
+# Vim
+##############################
+
+*.swp
+*.swo
+Session.vim
+
+##############################
+# Sublime
+##############################
+
+*.sublime-workspace
+*.sublime-project
+
+##############################
+# Temporary Files
+##############################
+
+*.tmp
+*.temp
+*.bak
+*.old
+*.orig
+*.rej
+*.save
+
+##############################
+# Logs
+##############################
+
+*.log
+logs/
+log/
+*.out
+*.err
+*.trace
+
+##############################
+# Runtime
+##############################
+
+*.pid
+*.seed
+*.pid.lock
+
+##############################
+# Secrets
+##############################
+
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.crt
+*.cer
+*.p12
+*.pfx
+*.kdbx
+*.secret
+*.token
+
+##############################
+# SSH
+##############################
+
+.ssh/
+
+##############################
+# Docker
+##############################
+
+docker-compose.override.yml
+docker-compose.local.yml
+
+##############################
+# VM Storage
+##############################
+
+storage/
+windows/
+downloads/
+
+##############################
+# Disk Images
+##############################
+
+*.qcow2
+*.qcow
+*.vhd
+*.vhdx
+*.vdi
+*.raw
+*.img
+*.iso
+*.bin
+
+##############################
+# QEMU
+##############################
+
+*.nvram
+*.fd
+*.efi
+*.sock
+*.monitor
+*.serial
+
+##############################
+# Samba
+##############################
+
+shared/
+share/
+
+##############################
+# Backups
+##############################
+
+backup/
+backups/
+*.backup
+
+##############################
+# Cache
+##############################
+
+.cache/
+.cache-loader/
+.tmp/
+temp/
+tmp/
+
+##############################
+# Python
+##############################
+
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.venv/
+venv/
+
+##############################
+# Node
+##############################
+
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+##############################
+# Build
+##############################
+
+dist/
+build/
+out/
+release/
+
+##############################
+# Coverage
+##############################
+
+coverage/
+.coverage
+coverage.xml
+
+##############################
+# Archives
+##############################
+
+*.zip
+*.tar
+*.tar.gz
+*.tgz
+*.7z
+*.rar
+
+##############################
+# Generated Config
+##############################
+
+config.local.*
+settings.local.*
+local.env
+
+##############################
+# Test Files
+##############################
+
+test-output/
+playwright-report/
+
+##############################
+# macOS
+##############################
+
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+
+##############################
+# Linux
+##############################
+
+*~
+.nfs*
+
+##############################
+# Windows
+##############################
+
+*.stackdump
+
+##############################
+# Misc
+##############################
+
+*.cache
+*.lock
+*.lock.json
+*.bak.*
+
+##############################
+# Keep Examples
+##############################
+
+!.gitkeep
+!.env.example

Dockerfile

@@ -1,63 +1,87 @@
-FROM qemux/qemu-host as builder
+# syntax=docker/dockerfile:1
-
-#  FROM golang as builder
-#  WORKDIR /
-#  RUN git clone https://github.com/qemu-tools/qemu-host.git
-#  WORKDIR /qemu-host/src
-#  RUN go mod download
-#  RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o /qemu-host.bin .
 
+FROM qemux/qemu-host:2.06 AS builder
 FROM debian:trixie-slim
 
+ARG TARGETARCH
 ARG TARGETPLATFORM
-ARG DEBCONF_NOWARNINGS="yes"
-ARG DEBIAN_FRONTEND noninteractive
-
-RUN apt-get update && apt-get -y upgrade \
-    && if [ "$TARGETPLATFORM" != "linux/amd64" ]; then extra="qemu-user"; fi \
-    && apt-get --no-install-recommends -y install \
-        jq \
-        tini \
-        curl \
-        cpio \
-        wget \
-        fdisk \
-        unzip \
-        socat \
-        procps \
-        xz-utils \
-        iptables \
-        iproute2 \
-        dnsmasq \
-        fakeroot \        
-        net-tools \
-        qemu-utils \
-        ca-certificates \
-        netcat-openbsd \
-        qemu-system-x86 \
-        "$extra" \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-COPY ./src /run/
-COPY --from=builder /qemu-host.bin /run/host.bin
-RUN chmod +x /run/*.sh && chmod +x /run/*.bin
-
-VOLUME /storage
-
-EXPOSE 22
-EXPOSE 80
-EXPOSE 139
-EXPOSE 445
-EXPOSE 5000
-
-ENV RAM_SIZE "1G"
-ENV DISK_SIZE "16G"
-ENV CPU_CORES "1"
 
 ARG VERSION_ARG="0.0"
-RUN echo "$VERSION_ARG" > /run/version
+ARG VERSION_WSD="0.4.2"
+ARG VERSION_CSTRUCT="4.7"
+ARG VERSION_PASST="2026_07_28"
 
-HEALTHCHECK --interval=60s --start-period=45s --retries=2 CMD /run/check.sh
+ARG DEBCONF_NOWARNINGS="yes"
+ARG DEBIAN_FRONTEND="noninteractive"
+ARG DEBCONF_NONINTERACTIVE_SEEN="true"
+
+RUN <<EOF
+  set -eu
+
+  apt-get update
+  apt-get --no-install-recommends -y install \
+    jq \
+    tini \
+    curl \
+    wget \
+    fdisk \
+    unzip \
+    nginx \
+    procps \
+    ipcalc \
+    ethtool \
+    xz-utils \
+    iptables \
+    iproute2 \
+    dnsmasq \
+    fakeroot \
+    apt-utils \
+    net-tools \
+    e2fsprogs \
+    diffutils \
+    qemu-utils \
+    iputils-ping \
+    inotify-tools \
+    ca-certificates \
+    netcat-openbsd \
+    qemu-system-x86 \
+    python3 \
+    python3-pip \
+    python3-msgpack \
+    python3-pysodium
+
+  # Install Passt package
+  wget "https://github.com/qemus/passt/releases/download/v${VERSION_PASST}/passt_${VERSION_PASST}_${TARGETARCH}.deb" -O /tmp/passt.deb -q --timeout=10
+  dpkg -i /tmp/passt.deb
+
+  # Install Websocketd package
+  wget "https://github.com/qemus/websocketd/releases/download/v${VERSION_WSD}/websocketd-${VERSION_WSD}_${TARGETARCH}.deb" -O /tmp/wsd.deb -q --timeout=10
+  dpkg -i /tmp/wsd.deb
+
+  apt-get clean
+
+  # Install Python dependencies
+  pip3 install --no-cache-dir --break-system-packages --root-user-action=ignore "dissect.cstruct==$VERSION_CSTRUCT"
+
+  # Set version file
+  echo "$VERSION_ARG" > /etc/version
+
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+EOF
+
+COPY --chmod=755 ./src /run/
+COPY --chmod=755 ./web /var/www/
+COPY --chmod=755 --from=builder /qemu-host.bin /run/host.bin
+COPY --chmod=744 ./web/conf/nginx.conf /etc/nginx/default.conf
+ADD --chmod=775 https://raw.githubusercontent.com/sud0woodo/patology/refs/heads/main/patology.py /run/extract.py
+
+VOLUME /storage
+EXPOSE 22 139 445 5000
+
+ENV RAM_SIZE="2G"
+ENV CPU_CORES="2"
+ENV DISK_SIZE="256G"
+
+HEALTHCHECK --interval=60s --start-period=45s --retries=2 CMD ["/run/check.sh"]
 
 ENTRYPOINT ["/usr/bin/tini", "-s", "/run/entry.sh"]

agent/agent.sh

@@ -1,140 +0,0 @@
-#!/usr/bin/env bash
-set -u
-
-VERSION="9"
-HEADER="VirtualDSM Agent"
-
-# Functions
-
-error () { echo -e "\E[1;31m❯ ERROR: $1\E[0m" ; }
-info () { echo -e "\E[1;34m❯\E[1;36m $1\E[0m" ; }
-
-finish() {
-
-  echo "❯ $HEADER: Shutting down.."
-  exit
-
-}
-
-function checkNMI {
-
-  local nmi
-  nmi=$(cat /proc/interrupts | grep NMI | sed 's/[^1-9]*//g')
-
-  if [ "$nmi" != "" ]; then
-
-    info "Received shutdown request through NMI.."
-
-    /usr/syno/sbin/synoshutdown -s > /dev/null
-    finish
-
-  fi
-}
-
-function downloadUpdate {
-
-  TMP="/tmp/agent.sh"
-  rm -f "${TMP}"
-
-  # Auto update the agent
-
-  URL="https://raw.githubusercontent.com/vdsm/virtual-dsm/master/agent/agent.sh"
-  
-  remote_size=$(curl -sIk -m 4 "${URL}" | grep -i "content-length:" | tr -d " \t" | cut -d ':' -f 2)
-  remote_size=${remote_size//$'\r'}
-
-  [[ "$remote_size" == "" || "$remote_size" == "0" ]] && return
-
-  remote_size=$(($remote_size+0))
-  ((remote_size<100)) && return
-
-  SCRIPT=$(readlink -f "${BASH_SOURCE[0]}")
-  local_size=$(stat -c%s "$SCRIPT")
-  local_size=$(($local_size+0))
-
-  [[ remote_size -eq local_size ]] && return
-
-  if ! curl -sfk -m 10 -o "${TMP}" "${URL}"; then
-    error "$HEADER: curl error ($?)" && return
-  fi
-
-  if [ ! -f "${TMP}" ]; then
-    error "$HEADER: update error, file not found.." && return
-  fi
-
-  line=$(head -1 "${TMP}")
-
-  if [[ "$line" != "#!/usr/bin/env bash" ]]; then
-    error "$HEADER: update error, invalid header: $line" && return
-  fi
-
-  if cmp --silent -- "${TMP}" "${SCRIPT}"; then
-    error "$HEADER: update file is already equal? (${local_size} / ${remote_size})" && return
-  fi
-
-  mv -f "${TMP}" "${SCRIPT}"
-  chmod 755 "${SCRIPT}"
-
-  info "$HEADER: succesfully installed update..."
-
-}
-
-function installPackages {
-
-  for filename in /usr/local/packages/*.spk; do
-    if [ -f "$filename" ]; then
-
-      BASE=$(basename "$filename" .spk)
-      BASE="${BASE%%-*}"
-
-      [[ $BASE == "ActiveInsight" ]] && continue
-
-      info "Installing package ${BASE}.."
-
-      /usr/syno/bin/synopkg install "$filename" > /dev/null
-      /usr/syno/bin/synopkg start "$BASE" > /dev/null &
-
-      rm "$filename"
-
-    fi
-  done
-
-}
-
-trap finish SIGINT SIGTERM
-
-ts=$(date +%s%N)
-
-echo ""
-echo "❯ Started $HEADER v$VERSION..."
-
-checkNMI
-
-# Install packages 
-
-first_run=false
-
-for filename in /usr/local/packages/*.spk; do
-  if [ -f "$filename" ]; then
-    first_run=true
-  fi
-done
-
-if [ "$first_run" = true ]; then
-
-  installPackages
-
-else
-
-  downloadUpdate
-
-fi
-
-# Wait for NMI interrupt as a shutdown signal
-
-while true; do
-
-  checkNMI
-  sleep 2 & wait $!
-
-done

agent/service.sh

@@ -1,87 +0,0 @@
-#!/bin/bash
-
-PIDFILE="/var/run/agent.pid"
-SCRIPT="/usr/local/bin/agent.sh"
-
-error () { echo -e "\E[1;31m❯ ERROR: $1\E[0m" ; }
-info () { echo -e "\E[1;34m❯\E[1;36m $1\E[0m" ; }
-
-status() {
-
-  if [ -f "$PIDFILE" ] && kill -0 "$(cat "$PIDFILE")"; then
-    echo 'Service running'
-    return 1
-  fi
-
-  return 0
-}
-
-start() {
-
-  if [ -f "$PIDFILE" ] && kill -0 "$(cat "$PIDFILE")"; then
-    echo 'Service already running'
-    return 1
-  fi
-
-  echo 'Starting agent service...'
-  chmod 666 /dev/ttyS0
-
-  if [ ! -f "$SCRIPT" ]; then
-
-    URL="https://raw.githubusercontent.com/vdsm/virtual-dsm/master/agent/agent.sh"
-
-    if ! curl -sfk -m 10 -o "${SCRIPT}" "${URL}"; then
-      error 'Failed to download agent script.' > /dev/ttyS0
-      rm -f "${SCRIPT}"
-      return 1
-    else
-      info 'Agent script was missing?' > /dev/ttyS0
-    fi
-
-    chmod 755 "${SCRIPT}"
-
-  fi
-
-  echo "-" > /var/lock/subsys/agent.sh
-  "$SCRIPT" &> /dev/ttyS0 & echo $! > "$PIDFILE"
-
-  return 0
-}
-
-stop() {
-
-  if [ ! -f "$PIDFILE" ] || ! kill -0 "$(cat "$PIDFILE")"; then
-    echo 'Service not running'
-    return 1
-  fi
-
-  echo 'Stopping agent service...'
-
-  chmod 666 /dev/ttyS0
-  info 'Stopping agent service...' > /dev/ttyS0
-
-  kill -15 "$(cat "$PIDFILE")" && rm -f "$PIDFILE"
-  rm -f /var/lock/subsys/agent.sh
-
-  echo 'Service stopped'
-  return 0
-}
-
-case "$1" in
-  start)
-    start
-    ;;
-  stop)
-    stop
-    ;;
-  status)
-    status
-    ;;
-  restart)
-    stop
-    start
-    ;;
-  *)
-    echo "Usage: $0 {start|stop|restart}"
-    exit 1
-esac

compose.yml

@@ -0,0 +1,17 @@
+services:
+  dsm:
+    container_name: dsm
+    image: vdsm/virtual-dsm
+    environment:
+      DISK_SIZE: "256G"
+    devices:
+      - /dev/kvm
+      - /dev/net/tun
+    cap_add:
+      - NET_ADMIN
+    ports:
+      - 5000:5000
+    volumes:
+      - ./dsm:/storage
+    restart: always
+    stop_grace_period: 2m

docker-compose.yml

@@ -1,23 +0,0 @@
-version: "3"
-services:
-    dsm:
-        container_name: dsm
-        image: vdsm/virtual-dsm:latest
-        environment:
-            DISK_SIZE: "16G"
-            RAM_SIZE: "1G"
-            CPU_CORES: "1"
-        devices:
-            - /dev/kvm
-            - /dev/net/tun
-            - /dev/vhost-net
-        device_cgroup_rules:
-            - 'c *:* rwm'
-        cap_add:
-            - NET_ADMIN
-        ports:
-            - 5000:5000
-        volumes:
-            - /var/dsm:/storage
-        restart: on-failure
-        stop_grace_period: 2m

docs/environment.md

@@ -0,0 +1,100 @@
+# Environment Variables
+
+This page lists all the environment variables that can be used to configure the container.
+
+An empty default means the variable is unset and its value is determined automatically when applicable.
+
+## 💽 Virtual DSM
+
+| Variable | Default | Description |
+|---|---|---|
+| `URL` |  | URL or local path to a custom `.pat` installation file. |
+| `COUNTRY` |  | Country code used to select the Synology download mirror. |
+| `HOST_MAC` |  | MAC address reported to DSM. |
+| `HOST_MODEL` |  | Synology host model reported to DSM. |
+| `HOST_SERIAL` |  | Synology host serial number reported to DSM. |
+| `GUEST_SERIAL` |  | Synology guest serial number reported to DSM. |
+
+## 🧠 CPU and Memory
+
+| Variable | Default | Description |
+|---|---|---|
+| `CPU_CORES` | `2` | Number of virtual CPU cores, such as `4`, `half`, or `max`. |
+| `CPU_MODEL` | `host` | QEMU CPU model. |
+| `CPU_FLAGS` |  | Additional QEMU CPU flags. |
+| `HOST_CPU` |  | CPU name reported to DSM. Selected automatically when unset. |
+| `KVM` | `Y` | Enables KVM hardware acceleration. |
+| `RAM_SIZE` | `2G` | Amount of RAM assigned to DSM, such as `2G`, `4G`, `half`, or `max`. |
+| `RAM_CHECK` | `Y` | Checks whether enough host memory is available before starting DSM. |
+
+## 💾 Storage
+
+| Variable | Default | Description |
+|---|---|---|
+| `DISK_SIZE` | `256G` | Size of the main data disk. |
+| `DISK_FMT` | `raw` | Disk image format: `raw` or `qcow2`. |
+| `DISK_TYPE` | `scsi` | Disk device type, such as `sata`, `scsi`, `nvme`, or `blk`. |
+| `DISK_CACHE` | `none` | Disk cache mode, such as `none` or `writeback`. |
+| `DISK_IO` | `native` | Disk I/O mode, such as `native`, `threads`, or `io_uring`. |
+| `DISK_DISCARD` | `unmap` | Discard/TRIM mode for the primary disk. |
+| `DISK_ROTATION` | `1` | Rotation rate reported to the guest. Use `1` to identify the disk as an SSD. |
+| `DISK_FLAGS` |  | Additional options used when creating `qcow2` disks. |
+| `DISK_OPTIONS` |  | Additional options appended to QEMU disk devices. |
+| `ALLOCATE` | `N` | Preallocates space for the data disks. |
+| `STORAGE` | `/storage` | Storage directory used for disks, settings, and downloads. |
+
+## 🌐 Networking
+
+| Variable | Default | Description |
+|---|---|---|
+| `NETWORK` |  | Network mode, such as `nat`, `user`, or `N` to disable networking. |
+| `DHCP` | `N` | Enables macvtap networking so DSM receives a DHCP address. |
+| `HOST` |  | Hostname assigned to the machine on the network. |
+| `IP` |  | Overrides the automatically selected guest IPv4 address. |
+| `MAC` |  | Guest network adapter MAC address. |
+| `ADAPTER` | `virtio-net-pci` | QEMU network adapter model. |
+| `DEV` | `eth0` | Container network interface used as the uplink. |
+| `MTU` |  | MTU assigned to the guest network interface. |
+| `MASK` | `255.255.255.0` | IPv4 netmask for guest network. |
+| `TAP` | `dsm` | TAP or macvtap interface name. |
+| `BRIDGE` | `docker` | Bridge name used for NAT networking. |
+| `HOST_PORTS` |  | Ports excluded from guest forwarding. |
+| `USER_PORTS` |  | Additional ports to forward to DSM when using user-mode networking. |
+| `DNSMASQ_OPTS` |  | Additional options passed to dnsmasq. |
+| `DNSMASQ_DEBUG` | `N` | Enables dnsmasq debug output. |
+| `DNSMASQ_DISABLE` | `N` | Disables the internal dnsmasq resolver. |
+| `PASST_OPTS` |  | Additional options passed to passt. |
+| `PASST_DEBUG` | `N` | Enables passt debug output. |
+
+## 🖥️ Display
+
+| Variable | Default | Description |
+|---|---|---|
+| `DISPLAY` | `none` | Display backend, such as `vnc`, `disabled`, or `none`. |
+| `LOSSY` | `N` | Enables lossy VNC compression to reduce bandwidth usage. |
+| `VGA` | `none` | QEMU video adapter model. |
+| `GPU` | `N` | Enables Intel iGPU acceleration. |
+| `RENDERNODE` | `/dev/dri/renderD128` | Render node used for GPU acceleration. |
+
+## ⚙️ System
+
+| Variable | Default | Description |
+|---|---|---|
+| `MACHINE` | `q35` | QEMU machine type. |
+| `ARGUMENTS` |  | Additional raw arguments appended to the QEMU command line. |
+
+## 🔌 Shutdown
+
+| Variable | Default | Description |
+|---|---|---|
+| `SHUTDOWN` | `Y` | Enables graceful shutdown. |
+| `TIMEOUT` | `115` | Maximum time, in seconds, to wait before forcing DSM to stop. |
+| `API_TIMEOUT` | `90` | Maximum time, in seconds, to wait for the shutdown API call. |
+
+## 🐞 Debugging
+
+| Variable | Default | Description |
+|---|---|---|
+| `DEBUG` | `N` | Enables verbose debug output. |
+| `TRACE` | `N` | Enables shell command tracing. |
+| `HOST_DEBUG` | `N` | Enables debug output for the DSM host helper. |

kubernetes.yml

@@ -0,0 +1,79 @@
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: dsm-pvc
+spec:
+  accessModes:
+  - ReadWriteOnce
+  resources:
+    requests:
+      storage: 256Gi
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: dsm
+  labels:
+    name: dsm
+spec:
+  replicas: 1
+  strategy:
+    type: Recreate
+  selector:
+    matchLabels:
+      app: dsm
+  template:
+    metadata:
+      labels:
+        app: dsm
+    spec:
+      containers:
+      - name: dsm
+        image: vdsm/virtual-dsm
+        env:
+        - name: DISK_SIZE
+          value: "256G"
+        ports:
+          - containerPort: 5000
+            name: http
+            protocol: TCP
+        securityContext:
+          capabilities:
+            add:
+            - NET_ADMIN
+          privileged: true
+        volumeMounts:
+        - mountPath: /storage
+          name: storage
+        - mountPath: /dev/kvm
+          name: dev-kvm
+        - mountPath: /dev/net/tun
+          name: dev-tun
+      terminationGracePeriodSeconds: 120
+      volumes:
+      - name: storage
+        persistentVolumeClaim:
+          claimName: dsm-pvc
+      - hostPath:
+          path: /dev/kvm
+        name: dev-kvm
+      - hostPath:
+          path: /dev/net/tun
+          type: CharDevice
+        name: dev-tun
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: dsm
+spec:
+  internalTrafficPolicy: Cluster
+  ports:
+    - name: http
+      port: 5000
+      protocol: TCP
+      targetPort: 5000
+  selector:
+    app: dsm
+  type: ClusterIP

readme.md

@@ -1,225 +1,298 @@
-<h1 align="center">Virtual DSM for Docker<br />
+<h1 align="center">Virtual DSM<br />
 <div align="center">
-<img src="https://github.com/vdsm/virtual-dsm/raw/master/.github/screen.jpg" title="Screenshot" style="max-width:100%;" width="432" />
+<a href="https://github.com/vdsm/virtual-dsm"><img src="https://github.com/vdsm/virtual-dsm/raw/master/.github/screen.jpg" title="Screenshot" style="max-width:100%;" width="432" /></a>
 </div>
 <div align="center">
 
 [![Build]][build_url]
 [![Version]][tag_url]
 [![Size]][tag_url]
+[![Package]][pkg_url]
 [![Pulls]][hub_url]
 
 </div></h1>
 
-Virtual DSM in a docker container.
+Virtual DSM in a Docker container.
 
-## Features
+## Features ✨
 
- - Multiple disks
+- Runs Virtual DSM inside a Docker container
- - KVM acceleration
+- Automatic download of the installation files
- - GPU passthrough
+- Web-based access to the DSM desktop
- - Upgrades supported
+- Near-native performance with KVM acceleration
+- Customizable CPU, memory, and storage allocation
+- Supports multiple disks and physical disk passthrough
+- Supports NAT, user-mode, macvlan, and macvtap networking
 
-## Usage
+## Usage  🐳
 
-Via `docker-compose.yml`
+##### Docker Compose:
 
 ```yaml
-version: "3"
 services:
   dsm:
     container_name: dsm
-    image: vdsm/virtual-dsm:latest
+    image: vdsm/virtual-dsm
     environment:
-      DISK_SIZE: "16G"
+      DISK_SIZE: "256G"
     devices:
       - /dev/kvm
+      - /dev/net/tun
     cap_add:
       - NET_ADMIN
     ports:
       - 5000:5000
     volumes:
-      - /var/dsm:/storage
+      - ./dsm:/storage
-    restart: on-failure
+    restart: always
     stop_grace_period: 2m
 ```
 
-Via `docker run`
+##### Docker CLI:
 
 ```bash
-docker run -it --rm -p 5000:5000 --device=/dev/kvm --cap-add NET_ADMIN --stop-timeout 60 vdsm/virtual-dsm:latest
+docker run -it --rm --name dsm -e "DISK_SIZE=256G" -p 5000:5000 --device=/dev/kvm --device=/dev/net/tun --cap-add NET_ADMIN -v "${PWD:-.}/dsm:/storage" --stop-timeout 120 docker.io/vdsm/virtual-dsm
 ```
 
-## FAQ
+##### Kubernetes:
 
-  * ### How do I change the size of the virtual disk?
+```shell
+kubectl apply -f https://raw.githubusercontent.com/vdsm/virtual-dsm/refs/heads/master/kubernetes.yml
+```
 
-    To expand the default size of 16 GB, locate the `DISK_SIZE` setting in your compose file and modify it to your preferred capacity:
+##### GitHub Codespaces:
 
-    ```yaml
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/vdsm/virtual-dsm)
-    environment:
-      DISK_SIZE: "128G"
-    ```
 
-    This can also be used to resize the existing disk to a larger capacity without any data loss. 
+## Requirements ⚙️
 
-  * ### How do I change the location of the virtual disk?
+- Docker or Podman on a Linux host with KVM support.
+- Docker Desktop or Podman (Desktop) on Windows 11 with nested virtualization enabled.
+- At least 1 GB of available RAM.
+- At least 16 GB of free disk space.
 
-    To change the location of the virtual disk, include the following bind mount in your compose file:
+> [!NOTE]
+> Docker Desktop on Linux, macOS, and Windows 10 does not currently provide KVM access to containers and is therefore not supported.
 
-    ```yaml
+## FAQ 💬
-    volumes:
-      - /var/dsm:/storage
-    ```
 
-    Replace the example path `/var/dsm` with the desired storage folder.
+### How do I use it?
 
-  * ### How do I add multiple disks?
+  Very simple! These are the steps:
   
-    To create additional disks, modify your compose file like this:
+  - Start the container and connect to [port 5000](http://127.0.0.1:5000/) using your web browser.
 
-    ```yaml
+  - Wait until DSM finishes its installation
-    environment:
-      DISK2_SIZE: "32G"
-      DISK3_SIZE: "64G"
-    volumes:
-      - /home/example:/storage2
-      - /mnt/data/example:/storage3
-    ```
  
-  * ### How do I create a growable disk?
+  - Choose a username and password, and you will be taken to the desktop.
   
-    By default, the entire capacity of the disk is reserved in advance.
+  Enjoy your brand new NAS, and don't forget to star this repo!
 
-    To create a growable disk that only allocates space that is actually used, add the following environment variables:
+### How do I change the storage location?
 
-    ```yaml
+  To change the storage location, include the following bind mount in your compose file:
-    environment:
-      ALLOCATE: "N"
-      DISK_FMT: "qcow2"
-    ```
 
-    Please note that this may reduce the write performance of the disk.
+  ```yaml
+  volumes:
+    - ./dsm:/storage
+  ```
 
-  * ### How do I increase the amount of CPU or RAM?
+  Replace the example path `./dsm` with the desired storage folder or named volume.
  
-    By default, a single core and 1 GB of RAM are allocated to the container.
+### How do I change the size of the disk?
 
-    To increase this, add the following environment variables:
+  To expand the default size of 256 GB, locate the `DISK_SIZE` setting in your compose file and modify it to your preferred capacity:
 
-    ```yaml
+  ```yaml
-    environment:
+  environment:
-      RAM_SIZE: "4G"
+    DISK_SIZE: "512G"
-      CPU_CORES: "4"
+  ```
-    ```
   
-  * ### How do I verify if my system supports KVM?
+> [!TIP]
+> This can also be used to resize an existing disk to a larger capacity without any data loss.
 
-    To verify if your system supports KVM, run the following commands:
+### How do I add multiple disks?
 
-    ```bash
+  To create additional disks, modify your compose file like this:
-    sudo apt install cpu-checker
-    sudo kvm-ok
-    ```
   
-    If you receive an error from `kvm-ok` indicating that KVM acceleration can't be used, check your BIOS settings.
+  ```yaml
+  environment:
+    DISK2_SIZE: "500G"
+    DISK3_SIZE: "750G"
+  volumes:
+    - ./example2:/storage2
+    - ./example3:/storage3
+  ```
 
-  * ### How do I assign an individual IP address to the container?
+### How do I pass through a disk?
 
-    By default, the container uses bridge networking, which shares the IP address with the host. 
+   You can pass through disk devices or partitions directly by adding them to your compose file in this way:
 
-    If you want to assign an individual IP address to the container, you can create a macvlan network as follows:
+  ```yaml
+  devices:
+    - /dev/sdb:/disk1
+    - /dev/sdc1:/disk2
+  ```
 
-    ```bash
+  Make sure it is totally empty (without any filesystem), otherwise DSM may not format it as a volume.
-    docker network create -d macvlan \
-        --subnet=192.168.0.0/24 \
-        --gateway=192.168.0.1 \
-        --ip-range=192.168.0.100/28 \
-        -o parent=eth0 vdsm
-    ```
 
-    Be sure to modify these values to match your local subnet. 
+### How do I change the amount of CPU or RAM?
 
-    Once you have created the network, change your compose file to look as follows:
+  By default, Virtual DSM will be allowed to use 2 CPU cores and 2 GB of RAM.
 
-    ```yaml
+  If you want to adjust this, you can specify the desired amount using the following environment variables:
-    services:
-      dsm:
-        container_name: dsm
-        ..<snip>..
-        networks:
-          vdsm:
-            ipv4_address: 192.168.0.100
 
-    networks:
+  ```yaml
-      vdsm:
+  environment:
-        external: true
+    RAM_SIZE: "4G"
-    ```
+    CPU_CORES: "4"
+  ```
 
-    An added benefit of this approach is that you won't have to perform any port mapping anymore since all ports will be exposed by default.
+### How do I assign an individual IP address to the container?
 
-    Please note that this IP address won't be accessible from the Docker host due to the design of macvlan, which doesn't permit communication between the two. If this is a concern, you need to create a [second macvlan](https://blog.oddbit.com/post/2018-03-12-using-docker-macvlan-networks/#host-access) as a workaround.
+  By default, the container uses bridge networking, which shares the IP address with the host. 
 
-  * ### How can the container acquire an IP address from my router?
+  If you want to assign an individual IP address to the container, you can create a macvlan network as follows:
 
-    After configuring the container for macvlan (see above), it is possible for DSM to become part of your home network by requesting an IP from your router, just like your other devices.
+  ```bash
+  docker network create -d macvlan \
+      --subnet=192.168.0.0/24 \
+      --gateway=192.168.0.1 \
+      --ip-range=192.168.0.100/28 \
+      -o parent=eth0 vdsm
+  ```
   
-    To enable this feature, add the following lines to your compose file:
+  Be sure to modify these values to match your local subnet. 
 
-    ```yaml
+  Once you have created the network, change your compose file to look as follows:
-    environment:
-      DHCP: "Y"
-    devices:
-      - /dev/vhost-net
-    device_cgroup_rules:
-      - 'c *:* rwm'
-    ```
 
-    Please note that even if you don't want DHCP, it's still recommended to enable this feature as it prevents NAT issues and increases performance by using a `macvtap` interface. In that case just set a static IP from the DSM control panel after you enabled this mode.
+  ```yaml
+  services:
+    dsm:
+      container_name: dsm
+      ..<snip>..
+      networks:
+        vdsm:
+          ipv4_address: 192.168.0.100
 
-  * ### How do I passthrough the GPU?
+  networks:
+    vdsm:
+      external: true
+  ```
  
-    To passthrough your Intel GPU, add the following lines to your compose file:
+  An added benefit of this approach is that you won't have to perform any port mapping anymore, since all ports will be exposed by default.
 
-    ```yaml
+> [!IMPORTANT]
-    environment:
+> This IP address won't be accessible from the Docker host due to the design of macvlan, which doesn't permit communication between the two. If this is a concern, you need to create a [second macvlan](https://blog.oddbit.com/post/2018-03-12-using-docker-macvlan-networks/#host-access) as a workaround.
-      GPU: "Y"
-    devices:
-      - /dev/dri
-    ```
 
-    This can be used to enable the facial recognition function in Synology Photos for example.
+### How can DSM acquire an IP address from my router?
 
-  * ### How do I install a specific version of vDSM?
+  After configuring the container for [macvlan](#how-do-i-assign-an-individual-ip-address-to-the-container), it is possible for DSM to become part of your home network by requesting an IP from your router, just like your other devices.
 
-    By default, version 7.2.1 will be installed, but if you prefer an older version, you can add its download URL to your compose file as follows:
+  To enable this mode, in which the container and DSM will have separate IP addresses, add the following lines to your compose file:
 
-    ```yaml
+  ```yaml
-    environment:
+  environment:
-      URL: "https://global.synologydownload.com/download/DSM/release/7.0.1/42218/DSM_VirtualDSM_42218.pat"
+    DHCP: "Y"
-    ```
+  devices:
+    - /dev/vhost-net
+  device_cgroup_rules:
+    - 'c *:* rwm'
+  ```
 
-    With this method, it is even possible to switch between different versions while keeping all your file data intact.
+### How do I pass through the GPU?
 
-  * ### What are the differences compared to the standard DSM?
+  To pass through your Intel GPU, add the following lines to your compose file:
 
-    There are only two minor differences: the Virtual Machine Manager package is not available, and Surveillance Station will not include any free licenses.
+  ```yaml
+  environment:
+    GPU: "Y"
+  devices:
+    - /dev/dri
+  ```
 
-  * ### Is this project legal?
+> [!NOTE]
+> This can be used to enable the facial recognition function in Synology Photos, but does not provide hardware transcoding for video.
 
-    Yes, this project contains only open-source code and does not distribute any copyrighted material. Neither does it try to circumvent any copyright protection measures. So under all applicable laws, this project would be considered legal. 
+### How do I install a specific version of vDSM?
 
-    However, by installing Synology's Virtual DSM, you must accept their end-user license agreement, which does not permit installation on non-Synology hardware. So only run this project on an official Synology NAS, as any other use will be a violation of their terms and conditions.
+  By default, version 7.2 will be installed, but if you prefer an older version, you can add the download URL of the `.pat` file to your compose file as follows:
 
-## Disclaimer
+  ```yaml
+  environment:
+    URL: "https://global.synologydownload.com/download/DSM/release/7.0.1/42218/DSM_VirtualDSM_42218.pat"
+  ```
 
-Only run this container on Synology hardware, any other use is not permitted by their EULA. The product names, logos, brands, and other trademarks referred to within this project are the property of their respective trademark holders. This project is not affiliated, sponsored, or endorsed by Synology, Inc.
+  With this method, it is even possible to switch back and forth between versions while keeping your file data intact.
+
+  Alternatively, you can also skip the download and use a local file instead, by binding it in your compose file in this way:
+  
+  ```yaml
+  volumes:
+    - ./DSM_VirtualDSM_42218.pat:/boot.pat
+  ```
+
+  Replace the example path `./DSM_VirtualDSM_42218.pat` with the filename of your desired `.pat` file. The value of `URL` will be ignored in this case.
+
+### Are these all available options?
+
+  No. For a complete overview of all supported settings, see the [environment variables](docs/environment.md) page.
+
+### How do I verify that KVM is available?
+
+  First, make sure your platform and container runtime meet the [requirements](#requirements-️) listed above.
+
+  On a Linux host, install `cpu-checker` and run:
+
+  ```bash
+  sudo apt install cpu-checker
+  sudo kvm-ok
+  ```
+
+  A working configuration should report:
+
+  ```text
+  KVM acceleration can be used
+  ```
+
+  You can also verify that the KVM device exists:
+
+  ```bash
+  ls -l /dev/kvm
+  ```
+
+  If KVM is unavailable, check whether:
+
+  - Hardware virtualization (`Intel VT-x` or `AMD-V`) is enabled in your BIOS or UEFI.
+  - Nested virtualization is enabled when the host itself is a virtual machine.
+  - Your VPS or cloud provider supports nested virtualization.
+
+  If `kvm-ok` succeeds but the container still reports that KVM is unavailable, you can temporarily add `privileged: true` to your Compose file to rule out a permission or device-access issue.
+
+### What are the differences compared to the standard DSM?
+
+  There are only two minor differences: the Virtual Machine Manager package is not available, and Surveillance Station will not include any free licenses.
+
+### Is this project legal?
+
+  Yes, this project contains only open-source code and does not distribute any material owned by Synology. Neither does it try to circumvent any copyright protection measures.
+  
+  However, by installing Synology's Virtual DSM, you must accept their end-user license agreement, which does not permit installation on non-Synology hardware. So only run this container on an official Synology NAS, as any other use will be a violation of their terms and conditions.
+
+## Stars 🌟
+[![Stargazers](https://raw.githubusercontent.com/star-stats/stars/refs/heads/data/charts/vdsm-virtual-dsm.svg)](https://github.com/vdsm/virtual-dsm/stargazers)
+
+## Disclaimer ⚖️
+
+*Only run this container on Synology hardware, any other use is not permitted by their EULA. The product names, logos, brands, and other trademarks referred to within this project are the property of their respective trademark holders. This project is not affiliated, sponsored, or endorsed by Synology, Inc.*
 
 [build_url]: https://github.com/vdsm/virtual-dsm/
 [hub_url]: https://hub.docker.com/r/vdsm/virtual-dsm
 [tag_url]: https://hub.docker.com/r/vdsm/virtual-dsm/tags
+[pkg_url]: https://github.com/vdsm/virtual-dsm/pkgs/container/virtual-dsm
 
 [Build]: https://github.com/vdsm/virtual-dsm/actions/workflows/build.yml/badge.svg
 [Size]: https://img.shields.io/docker/image-size/vdsm/virtual-dsm/latest?color=066da5&label=size
-[Pulls]: https://img.shields.io/docker/pulls/kroese/virtual-dsm.svg?style=flat&label=pulls&logo=docker
+[Pulls]: https://img.shields.io/docker/pulls/vdsm/virtual-dsm.svg?style=flat&label=pulls&logo=docker
 [Version]: https://img.shields.io/docker/v/vdsm/virtual-dsm/latest?arch=amd64&sort=semver&color=066da5
+[Package]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fipitio.github.io%2Fbackage%2Fvdsm%2Fvirtual-dsm%2Fvirtual-dsm.json&query=%24.downloads&logo=github&style=flat&color=066da5&label=pulls

src/check.sh

@@ -1,25 +1,37 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
-: ${VM_NET_DEV:='eth0'}
+cd /run
+. utils.sh      # Load functions
 
-[ ! -f "/run/qemu.pid" ] && echo "QEMU not running yet.." && exit 0
+: "${DHCP:="N"}"
-[ -f "/run/qemu.count" ] && echo "QEMU is shutting down.." && exit 1
+: "${NETWORK:="Y"}"
 
-file="/run/dsm.url"
+[ -f "/run/shm/qemu.end" ] && echo "QEMU is shutting down..." && exit 1
-[ ! -f  "$file" ] && echo "DSM has not enabled networking yet.." && exit 1
+[ ! -s "/run/shm/qemu.pid" ] && echo "QEMU is not running yet..." && exit 0
+disabled "$NETWORK" && echo "Networking is disabled." && exit 0
 
-location=$(cat "$file")
+file="/run/shm/dsm.url"
+address="/run/shm/qemu.ip"
+gateway="/run/shm/qemu.gw"
+
+# dsm.url is written only after the guest agent reports both the DSM
+# address and its configured HTTP port.
+[ ! -s  "$file" ] && echo "DSM has not enabled networking yet..." && exit 0
+
+location=$(<"$file")
 
 if ! curl -m 20 -ILfSs "http://$location/" > /dev/null; then
 
-  if [[ "$location" == "20.20"* ]]; then
+  # In DHCP mode the firewall must allow the container address; with port
-    ip="20.20.20.1"
+  # forwarding it must allow the internal gateway used to reach the guest.
+  if enabled "$DHCP"; then
+    ip=$(<"$address")
+    echo "Failed to reach DSM at http://$location"
+  else
+    ip=$(<"$gateway")
     port="${location##*:}"
     echo "Failed to reach DSM at port $port"
-  else
-    echo "Failed to reach DSM at http://$location"
-    ip=$(ip address show dev "$VM_NET_DEV" | grep inet | awk '/inet / { print $2 }' | cut -f1 -d/)
   fi
 
   echo "You might need to whitelist IP $ip in the DSM firewall." && exit 1

src/config.sh

@@ -1,20 +1,74 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
-DEF_OPTS="-nographic -nodefaults -boot strict=on -display none"
+DEF_OPTS="-nodefaults -boot strict=on"
-RAM_OPTS=$(echo "-m $RAM_SIZE" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+DEV_OPTS=""
-CPU_OPTS="-cpu $CPU_MODEL -smp $CPU_CORES,sockets=1,dies=1,cores=$CPU_CORES,threads=1"
-MAC_OPTS="-machine type=q35,usb=off,dump-guest-core=off,hpet=off${KVM_OPTS}"
-EXTRA_OPTS="-device virtio-balloon-pci,id=balloon0,bus=pcie.0,addr=0x4"
-EXTRA_OPTS="$EXTRA_OPTS -object rng-random,id=objrng0,filename=/dev/urandom"
-EXTRA_OPTS="$EXTRA_OPTS -device virtio-rng-pci,rng=objrng0,id=rng0,bus=pcie.0,addr=0x1c"
 
-if [[ "$GPU" == [Yy1]* ]] && [[ "$ARCH" == "amd64" ]]; then
+configureProcessor() {
-  DEF_OPTS="-nodefaults -boot strict=on -display egl-headless,rendernode=/dev/dri/renderD128"
-  DEF_OPTS="$DEF_OPTS -device virtio-vga,id=video0,max_outputs=1,bus=pcie.0,addr=0x1"
-fi
 
-ARGS="$DEF_OPTS $CPU_OPTS $RAM_OPTS $MAC_OPTS $MON_OPTS $SERIAL_OPTS $NET_OPTS $DISK_OPTS $EXTRA_OPTS $ARGUMENTS"
+  # Expose one thread per core in a single socket; DSM licensing and topology
-ARGS=$(echo "$ARGS" | sed 's/\t/ /g' | tr -s ' ')
+  # reporting are more predictable with this fixed layout.
+  CPU_OPTS="-cpu $CPU_FLAGS"
+  CPU_OPTS+=" -smp $CPU_CORES,sockets=1,dies=1,cores=$CPU_CORES,threads=1"
+
+  return 0
+}
+
+configureMemory() {
+
+  RAM_OPTS=$(echo "-m ${RAM_SIZE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+
+  return 0
+}
+
+configureMonitor() {
+
+  MON_OPTS="-name $PROCESS,process=$PROCESS,debug-threads=on"
+  MON_OPTS+=" -pidfile $QEMU_PID"
+
+  return 0
+}
+
+configureMachine() {
+
+  # Disable firmware and chipset features that Virtual DSM does not use and
+  # that can introduce extra devices or timing differences.
+  MAC_OPTS="-machine type=$MACHINE,smm=off,usb=off"
+  MAC_OPTS+=",vmport=off,dump-guest-core=off,hpet=off${KVM_OPTS}"
+
+  return 0
+}
+
+configureVirtioDevices() {
+
+  local bus
+  bus=$(getPciBus)
+
+  DEV_OPTS="-device virtio-balloon-pci,id=balloon0,bus=$bus,addr=0x4"
+  DEV_OPTS+=" -object rng-random,id=objrng0,filename=/dev/urandom"
+  DEV_OPTS+=" -device virtio-rng-pci,rng=objrng0,id=rng0,bus=$bus,addr=0x1c"
+
+  return 0
+}
+
+buildArguments() {
+
+  ARGS="$DEF_OPTS $CPU_OPTS $RAM_OPTS $MAC_OPTS $DISPLAY_OPTS $MON_OPTS $SERIAL_OPTS $NET_OPTS $DISK_OPTS $DEV_OPTS $ARGUMENTS"
+  # Collapse whitespace after optional argument groups are assembled so empty
+  # features cannot leave malformed spacing in the final QEMU command.
+  ARGS=$(echo "$ARGS" | sed 's/\t/ /g' | tr -s ' ')
+
+  return 0
+}
+
+finalizeMemory
+
+configureMemory
+configureMonitor
+configureMachine
+configureProcessor
+configureVirtioDevices
+
+buildArguments
 
 return 0

src/cpu.sh

@@ -1,61 +0,0 @@
-#!/usr/bin/env bash
-set -Eeuo pipefail
-
-# Docker environment variables
-
-: ${HOST_CPU:=''}
-: ${CPU_MODEL:='host'}
-: ${CPU_FEATURES:='+ssse3,+sse4.1,+sse4.2'}
-
-KVM_ERR=""
-KVM_OPTS=""
-
-if [[ "$ARCH" == "amd64" && "$KVM" != [Nn]* ]]; then
-
-  if [ -e /dev/kvm ] && sh -c 'echo -n > /dev/kvm' &> /dev/null; then
-    if ! grep -q -e vmx -e svm /proc/cpuinfo; then
-      KVM_ERR="(vmx/svm disabled)"
-    fi
-  else
-    [ -e /dev/kvm ] && KVM_ERR="(no write access)" || KVM_ERR="(device file missing)"
-  fi
-
-  if [ -n "$KVM_ERR" ]; then
-    error "KVM acceleration not detected $KVM_ERR, this will cause a major loss of performance."
-    error "See the FAQ on how to enable it, or skip this error by setting KVM=N (not recommended)."
-    [[ "$DEBUG" != [Yy1]* ]] && exit 88
-    [[ "$CPU_MODEL" == "host"* ]] && CPU_MODEL="max,$CPU_FEATURES"
-  else
-    KVM_OPTS=",accel=kvm -enable-kvm"
-  fi
-
-  if [ -n "$KVM_OPTS" ]; then
-    if ! grep -qE '^flags.* (sse4_2)' /proc/cpuinfo; then
-      error "Your host CPU does not have the SSE4.2 instruction set that Virtual DSM requires to boot."
-      error "Disable KVM by setting KVM=N to emulate a compatible CPU, at the cost of performance."
-      [[ "$DEBUG" != [Yy1]* ]] && exit 89
-    fi
-  fi
-
-else
-
-  [[ "$CPU_MODEL" == "host"* ]] && CPU_MODEL="max,$CPU_FEATURES"
-
-fi
-
-if [ -z "$HOST_CPU" ]; then
-  HOST_CPU=$(lscpu | grep 'Model name' | cut -f 2 -d ":" | awk '{$1=$1}1' | sed 's# @.*##g' | sed s/"(R)"//g | sed 's/[^[:alnum:] ]\+/ /g' | sed 's/  */ /g')
-fi
-
-if [ -n "$HOST_CPU" ]; then
-  HOST_CPU="${HOST_CPU%%,*},,"
-else
-  HOST_CPU="QEMU, Virtual CPU,"
-  if [ "$ARCH" == "amd64" ]; then
-    HOST_CPU="$HOST_CPU X86_64"
-  else
-    HOST_CPU="$HOST_CPU $ARCH"
-  fi
-fi
-
-return 0

src/display.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Docker environment variables
+
+: "${GPU:="N"}"         # GPU passthrough
+: "${VGA:="virtio"}"    # VGA adaptor
+: "${DISPLAY:="none"}"  # Display type
+: "${LOSSY:="N"}"       # Lossy VNC compression
+: "${RENDERNODE:="/dev/dri/renderD128"}"  # Render node
+
+# Sanitize variables
+VGA=$(strip "$VGA")
+LOSSY=$(strip "$LOSSY")
+DISPLAY=$(strip "$DISPLAY")
+RENDERNODE=$(strip "$RENDERNODE")
+
+CPU_VENDOR=$(lscpu | awk '/Vendor ID/{print $3}')
+
+# The accelerated Intel render-node path is restricted to x86 Intel hosts;
+# other platforms retain the normal QEMU display backend.
+if ! enabled "$GPU" || isAmdCpu || [[ "$ARCH" != "amd64" ]]; then
+
+  # A disabled frontend also removes the emulated VGA device to keep the guest
+  # hardware layout headless.
+  [[ "${DISPLAY,,}" == "none" ]] && VGA="none"
+
+  if enabled "$LOSSY" && [[ "${DISPLAY,,}" == vnc=* ]]; then
+    DISPLAY+=",lossy=on"
+  fi
+
+  DISPLAY_OPTS="-display ${DISPLAY} -vga ${VGA}"
+  return 0
+
+fi
+
+msg="Configuring display drivers..."
+html "$msg"
+enabled "$DEBUG" && echo "$msg"
+
+DISPLAY_OPTS="-display egl-headless,rendernode=${RENDERNODE}"
+DISPLAY_OPTS+=" -vga $VGA"
+
+[ ! -d /dev/dri ] && mkdir -m 755 /dev/dri
+
+# Extract the card number from the render node
+# Linux renderD128 corresponds to card0; derive both device minors because
+# container device bindings may expose only the render node.
+CARD_NUMBER=$(echo "$RENDERNODE" | grep -oP '(?<=renderD)\d+')
+CARD_DEVICE="/dev/dri/card$((CARD_NUMBER - 128))"
+
+if [ ! -c "$CARD_DEVICE" ]; then
+  if mknod "$CARD_DEVICE" c 226 $((CARD_NUMBER - 128)); then
+    chmod 666 "$CARD_DEVICE"
+  fi
+fi
+
+if [ ! -c "$RENDERNODE" ]; then
+  if mknod "$RENDERNODE" c 226 "$CARD_NUMBER"; then
+    chmod 666 "$RENDERNODE"
+  fi
+fi
+
+if [ ! -c "$RENDERNODE" ] || [ ! -r "$RENDERNODE" ] || [ ! -w "$RENDERNODE" ]; then
+  warn "render device '${RENDERNODE}' is unavailable or inaccessible."
+fi
+
+# Install acceleration packages lazily so non-GPU deployments keep the base
+# image small and do not require OpenGL modules.
+addPackage "xserver-xorg-video-intel" "Intel GPU drivers"
+addPackage "qemu-system-modules-opengl" "OpenGL module"
+
+return 0

src/entry.sh

@@ -1,34 +1,49 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
-echo "❯ Starting Virtual DSM for Docker v$(</run/version)..."
+: "${PLATFORM:="x64"}"
-echo "❯ For support visit https://github.com/vdsm/virtual-dsm/"
+: "${APP:="Virtual DSM"}"
+: "${SUPPORT:="https://github.com/vdsm/virtual-dsm"}"
 
 cd /run
 
-. reset.sh      # Initialize system
+. start.sh      # Startup hook
+. utils.sh      # Load functions
+. init.sh       # Initialize system
+. memory.sh     # Check memory
+. server.sh     # Start webserver
 . install.sh    # Run installation
 . disk.sh       # Initialize disks
+. display.sh    # Initialize graphics
 . network.sh    # Initialize network
-. gpu.sh        # Initialize graphics
+. proc.sh       # Initialize processor
-. cpu.sh        # Initialize processor
 . serial.sh     # Initialize serialport
 . power.sh      # Configure shutdown
 . config.sh     # Configure arguments
+. finish.sh     # Finish initialization
 
 trap - ERR
 
-if [[ "$CONSOLE" == [Yy]* ]]; then
+cmd=(qemu-system-x86_64)
-  exec qemu-system-x86_64 -pidfile "$QEMU_PID" ${ARGS:+ $ARGS}
+version=$("${cmd[@]}" --version | awk 'NR==1 { print $4 }')
-  exit $?
+info "Booting $APP using QEMU v$version..." && echo
+
+if ! enabled "$SHUTDOWN"; then
+  exec "${cmd[@]}" ${ARGS:+ $ARGS}
 fi
 
-set -m
+if ! interactive; then
-(
+  "${cmd[@]}" ${ARGS:+ $ARGS} &
-  [[ "$DEBUG" == [Yy1]* ]] && info "$VERS" && set -x
+else
-  qemu-system-x86_64 ${ARGS:+ $ARGS} & echo $! > "$QEMU_PID"
+  startConsole
-  { set +x; } 2>/dev/null
+  startQemu "${cmd[@]}" ${ARGS:+ $ARGS}
-)
+fi
-set +m
 
-tail --pid "$(cat "$QEMU_PID")" --follow /dev/null & wait $!
+pid=$!
+rc=0
+
+wait "$pid" || rc=$?
+[ -f "$QEMU_END" ] && exit "$rc"
+
+sleep 1 & wait $!
+finish "$rc"

src/finish.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+if enabled "$DEBUG"; then
+  printf "QEMU arguments:\n\n    %s\n\n" "${ARGS// -/$'\n    -'}"
+fi
+
+# Must always remain the very last command
+enableTrap
+
+return 0

src/gpu.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-set -Eeuo pipefail
-
-if [[ "$GPU" != [Yy1]* ]] || [[ "$ARCH" != "amd64" ]]; then
-  return 0
-fi
-
-[ ! -d /dev/dri ] && mkdir -m 755 /dev/dri
-
-if [ ! -c /dev/dri/card0 ]; then
-  mknod /dev/dri/card0 c 226 0
-fi
-
-if [ ! -c /dev/dri/renderD128 ]; then
-  mknod /dev/dri/renderD128 c 226 128
-fi
-
-chmod 666 /dev/dri/card0
-chmod 666 /dev/dri/renderD128
-
-addPackage "xserver-xorg-video-intel" "Intel GPU drivers"
-addPackage "qemu-system-modules-opengl" "OpenGL module"
-
-return 0

src/init.sh

@@ -0,0 +1,296 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+trap 'error "Status $? while: $BASH_COMMAND (line $LINENO/$BASH_LINENO)"' ERR
+enabled "${TRACE:-}" && set -o functrace && trap 'echo "# $BASH_COMMAND" >&2' DEBUG
+
+[ ! -f "/run/entry.sh" ] && error "Script must be run inside the container!" && exit 11
+[ "$(id -u)" -ne "0" ] && error "Script must be executed with root privileges." && exit 12
+
+# Docker environment variables
+
+: "${TZ:=""}"              # System timezone
+: "${KVM:="Y"}"            # KVM acceleration
+: "${DEBUG:="N"}"          # Disable debugging mode
+: "${COUNTRY:=""}"         # Country code for mirror
+: "${MACHINE:="q35"}"      # Machine type selection
+: "${ALLOCATE:=""}"        # Preallocate diskspace
+: "${ARGUMENTS:=""}"       # Extra QEMU parameters
+: "${CPU_CORES:="2"}"      # Amount of CPU cores
+: "${RAM_SIZE:="2G"}"      # Maximum RAM amount
+: "${RAM_CHECK:="Y"}"      # Check available RAM
+: "${DISK_SIZE:="16G"}"    # Initial data disk size
+: "${STORAGE:="/storage"}" # Storage folder location
+
+detectEngine() {
+
+  if [ -f "/run/.containerenv" ]; then
+    ENGINE="${container:-}"
+
+    if [[ "${ENGINE,,}" == *"podman"* ]]; then
+      ENGINE="Podman"
+    else
+      [ -z "$ENGINE" ] && ENGINE="Kubernetes"
+    fi
+  elif [ -f "/.dockerenv" ]; then
+    ENGINE="Docker"
+  fi
+
+  return 0
+}
+
+detectRootless() {
+
+  local uid_map
+
+  # A full identity UID map indicates a rootful container; any remapping is
+  # treated as rootless even though the process itself runs as UID 0.
+  uid_map=$(awk '{$1=$1; print}' /proc/self/uid_map 2>/dev/null || true)
+
+  if [[ "$uid_map" == "0 0 4294967295" ]]; then
+    ROOTLESS="N"
+  else
+    ROOTLESS="Y"
+  fi
+
+  return 0
+}
+
+checkPrivileged() {
+
+  local cap_bnd
+  local last_cap
+  # Get the capability bounding set
+  cap_bnd=$(grep '^CapBnd:' /proc/$$/status | awk '{print $2}')
+  cap_bnd=$(printf "%d" "0x${cap_bnd}")
+
+  # Get the last capability number
+  last_cap=$(cat /proc/sys/kernel/cap_last_cap)
+
+  # Calculate the maximum capability value
+  # Compare the bounding set with every capability supported by this kernel;
+  # checking only a few known capabilities would misclassify newer kernels.
+  local max_cap=$(((1 << (last_cap + 1)) - 1))
+
+  if [ "$cap_bnd" -eq "$max_cap" ]; then
+    PRIVILEGED="Y"
+  fi
+
+  return 0
+}
+
+checkCores() {
+
+  CPU_CORES=$(strip "$CPU_CORES")
+  [ -z "$CPU_CORES" ] && CPU_CORES=2
+  [[ "${CPU_CORES,,}" == "max" ]] && CPU_CORES="$CORES"
+  [[ "${CPU_CORES,,}" == "half" ]] && CPU_CORES=$(( CORES / 2 ))
+  [ -z "${CPU_CORES##*[!0-9]*}" ] && error "Invalid amount of CPU_CORES: $CPU_CORES" && exit 15
+  [ "$CPU_CORES" -lt "1" ] && CPU_CORES=1
+
+  if [ "$CPU_CORES" -gt "$CORES" ]; then
+    warn "The amount for CPU_CORES (${CPU_CORES}) exceeds the amount of logical cores available (${CORES}) and will be limited."
+    CPU_CORES="$CORES"
+  fi
+
+  return 0
+}
+
+checkSockets() {
+
+  local lscpu_out
+  lscpu_out=$(lscpu 2>/dev/null || true)
+
+  if grep -qi "socket(s)" <<< "$lscpu_out"; then
+    SOCKETS=$(grep -m 1 -i 'socket(s)' <<< "$lscpu_out" | awk '{print $2}')
+    [ -z "${SOCKETS##*[!0-9]*}" ] && SOCKETS=1
+    [ "$SOCKETS" -lt "1" ] && SOCKETS=1
+  fi
+
+  return 0
+}
+
+checkStorage() {
+
+  # Check system
+
+  QEMU_DIR="/run/shm"
+
+  if [ ! -d "/dev/shm" ]; then
+    error "Directory /dev/shm not found!" && exit 14
+  else
+    # Keep runtime sockets and PID files on shared memory even on images where
+    # /run/shm is absent but /dev/shm is available.
+    [ ! -d "$QEMU_DIR" ] && ln -s /dev/shm "$QEMU_DIR"
+  fi
+
+  QEMU_PID="$QEMU_DIR/qemu.pid"
+
+  # Check folder
+
+  if [[ "${STORAGE,,}" != "/storage" ]]; then
+    if ! mkdir -p -- "$STORAGE"; then
+      error "Cannot create storage folder ($STORAGE)!" && exit 13
+    fi
+  fi
+
+  if [ ! -d "$STORAGE" ]; then
+    error "Storage folder ($STORAGE) not found!" && exit 13
+  fi
+
+  if [ ! -w "$STORAGE" ]; then
+    msg="Storage folder ($STORAGE) is not writeable!"
+    msg+=" If SELinux is active, you need to add the \":Z\" flag to the bind mount."
+    error "$msg" && exit 13
+  fi
+
+  return 0
+}
+
+checkHost() {
+
+  # Check filesystem
+  if [[ "${FS,,}" == "ecryptfs" || "${FS,,}" == "tmpfs" ]]; then
+    DISK_IO="threads"
+    DISK_CACHE="writeback"
+  fi
+
+  return 0
+}
+
+checkKvm() {
+
+  # Check KVM support
+
+  if [[ "${PLATFORM,,}" == "x64" ]]; then
+    TARGET="amd64"
+  else
+    TARGET="arm64"
+  fi
+
+  if disabled "$KVM"; then
+    warn "KVM acceleration is disabled, this will cause the machine to run about 10 times slower!"
+  else
+    # KVM accelerates only matching host and guest instruction sets; cross-
+    # architecture execution must fall back to software emulation.
+    if [[ "${ARCH,,}" != "$TARGET" ]]; then
+      KVM="N"
+      warn "your CPU architecture is ${ARCH^^} and cannot provide KVM acceleration for ${PLATFORM^^} instructions, so the machine will run about 10 times slower."
+    fi
+  fi
+
+  if ! disabled "$KVM"; then
+
+    KVM_ERR=""
+
+    if [ ! -e /dev/kvm ]; then
+      KVM_ERR="(/dev/kvm is missing)"
+    else
+      if ! sh -c 'echo -n > /dev/kvm' &> /dev/null; then
+        KVM_ERR="(/dev/kvm is unwriteable)"
+      else
+        if [[ "${PLATFORM,,}" == "x64" ]]; then
+          flags=$(sed -ne '/^flags/s/^.*: //p' /proc/cpuinfo)
+          if ! grep -qw "vmx\|svm" <<< "$flags"; then
+            KVM_ERR="(not enabled in BIOS)"
+          fi
+          if ! grep -qw "sse4_2" <<< "$flags"; then
+            error "Your CPU does not have the SSE4 instruction set that Virtual DSM requires!"
+            enabled "$DEBUG" || exit 88
+          fi
+        fi
+      fi
+    fi
+
+    if [ -n "$KVM_ERR" ]; then
+      KVM="N"
+      if [[ "$OSTYPE" =~ ^darwin ]]; then
+        warn "you are using macOS which has no KVM support, so the machine will run about 10 times slower."
+      else
+        kernel=$(uname -a)
+        case "${kernel,,}" in
+          *"microsoft"* )
+            error "Please bind '/dev/kvm' as a volume in the optional container settings when using Docker Desktop." ;;
+          *"synology"* )
+            error "Please make sure that Synology VMM (Virtual Machine Manager) is installed and that '/dev/kvm' is binded to this container." ;;
+          *)
+            error "KVM acceleration is not available $KVM_ERR, this will cause the machine to run about 10 times slower."
+            error "See the FAQ for possible causes, or disable acceleration by adding the \"KVM=N\" variable (not recommended)." ;;
+        esac
+        enabled "$DEBUG" || exit 88
+      fi
+    fi
+
+  fi
+
+  return 0
+}
+
+# Sanitize variables
+TZ=$(strip "$TZ")
+STORAGE=$(strip "$STORAGE")
+COUNTRY=$(strip "$COUNTRY")
+MACHINE=$(strip "${MACHINE,,}")
+DISK_SIZE=$(strip "$DISK_SIZE")
+
+# Helper variables
+ROOTLESS="N"
+PRIVILEGED="N"
+ENGINE="Docker"
+PROCESS="${APP,,}"
+PROCESS="${PROCESS// /-}"
+
+detectEngine
+detectRootless
+
+echo "❯ Starting $APP for $ENGINE v$(</etc/version)..."
+echo "❯ For support visit $SUPPORT"
+
+checkPrivileged
+
+INFO="/run/shm/msg.html"
+PAGE="/run/shm/index.html"
+TEMPLATE="/var/www/index.html"
+FOOTER1="$APP for $ENGINE v$(</etc/version)"
+FOOTER2="<a href='$SUPPORT'>$SUPPORT</a>"
+
+SOCKETS=1
+CPU=$(cpu)
+SYS=$(uname -r)
+ARCH=$(dpkg --print-architecture)
+CORES=$(grep -c '^processor' /proc/cpuinfo)
+IFS=. read -r KERNEL MINOR _ <<< "$SYS"
+
+checkSockets
+checkCores
+checkStorage
+getMemoryInfo
+
+# Print system info
+SYS="${SYS/-generic/}"
+FS=$(stat -f -c %T "$STORAGE")
+FS="${FS/UNKNOWN //}"
+FS="${FS/ext2\/ext3/ext4}"
+FS=$(echo "$FS" | sed 's/[)(]//g')
+SPACE=$(df --output=avail -B 1 "$STORAGE" | tail -n 1)
+SPACE_GB=$(formatBytes "$SPACE" "down")
+AVAIL_MEM=$(formatBytes "$RAM_AVAIL" "down")
+TOTAL_MEM=$(formatBytes "$RAM_TOTAL" "up")
+
+echo "❯ CPU: ${CPU} | RAM: ${AVAIL_MEM/ GB/}/$TOTAL_MEM | DISK: $SPACE_GB (${FS}) | KERNEL: ${SYS}"
+echo
+
+checkHost
+checkKvm
+
+# Runtime state is intentionally discarded at each container start; persistent
+# machine and disk identity lives under STORAGE instead.
+# Cleanup files
+rm -f "$QEMU_DIR"/dsm.url
+rm -f "$QEMU_DIR"/{qemu.*,*.{pid,sock,pipe}}
+
+# Cleanup dirs
+rm -rf /tmp/dsm
+rm -rf "$STORAGE/tmp"
+
+return 0

src/install.sh

@@ -1,23 +1,60 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
-: ${URL:=''}    # URL of the PAT file to be downloaded.
+: "${URL:=""}"    # URL of the PAT file to be downloaded.
 
-if [ -f "$STORAGE"/dsm.ver ]; then
+# Persist the exact PAT base name so future starts reopen the matching boot,
-  BASE=$(cat "$STORAGE/dsm.ver")
+# system, and cached installation files.
+if [ -f "$STORAGE/dsm.ver" ]; then
+  BASE=$(<"$STORAGE/dsm.ver")
+  BASE="${BASE//[![:print:]]/}"
+  [ -z "$BASE" ] && BASE="DSM_VirtualDSM_69057"
 else
   # Fallback for old installs
   BASE="DSM_VirtualDSM_42962"
 fi
 
-[ -n "$URL" ] && BASE=$(basename "$URL" .pat)
+FN="boot.pat"
+DIR=$(find / -maxdepth 1 -type d -iname "$FN" -print -quit)
+[ ! -d "$DIR" ] && DIR=$(find "$STORAGE" -maxdepth 1 -type d -iname "$FN" -print -quit)
 
-if [[ -f "$STORAGE/$BASE.boot.img" ]] && [[ -f "$STORAGE/$BASE.system.img" ]]; then
+# A boot.pat directory bind represents already extracted boot and system
+# images and therefore takes precedence over PAT file or URL discovery.
+if [ -d "$DIR" ]; then
+  BASE="DSM_VirtualDSM" && URL="file://$DIR"
+  if [[ ! -s "$STORAGE/$BASE.boot.img" || ! -s "$STORAGE/$BASE.system.img" ]]; then
+    error "The bind $DIR maps to a file that does not exist!" && exit 65
+  fi
+fi
+
+FILE=$(find / -maxdepth 1 -type f -iname "$FN" -print -quit)
+[ ! -s "$FILE" ] && FILE=$(find "$STORAGE" -maxdepth 1 -type f -iname "$FN" -print -quit)
+[ -s "$FILE" ] && BASE="DSM_VirtualDSM" && URL="file://$FILE"
+
+URL=$(strip "$URL")
+
+# Derive a filesystem-safe identity from the URL only when no local boot.pat
+# source was supplied; preserve an existing system image identity if present.
+if [ -n "$URL" ] && [ ! -s "$FILE" ] && [ ! -d "$DIR" ]; then
+  BASE=$(basename "$URL" .pat)
+  if [ ! -s "$STORAGE/$BASE.system.img" ]; then
+    BASE=$(basename "${URL%%\?*}" .pat)
+    printf -v BASE '%b' "${BASE//%/\\x}"
+    BASE="${BASE//[!A-Za-z0-9._-]/_}"
+  fi
+  if [[ "${URL,,}" != "http"* && "${URL,,}" != "file:"* ]]; then
+    [ ! -s "$STORAGE/$BASE.pat" ] && error "Invalid URL:  $URL" && exit 65
+    URL="file://$STORAGE/$BASE.pat"
+  fi
+fi
+
+# A complete matching image pair is the installation marker; the cached PAT
+# itself is optional after installation.
+if [[ -s "$STORAGE/$BASE.boot.img" && -s "$STORAGE/$BASE.system.img" ]]; then
   return 0  # Previous installation found
 fi
 
-# Display wait message
+html "Please wait while Virtual DSM is being installed..."
-/run/server.sh 5000 install &
 
 DL=""
 DL_CHINA="https://cndl.synology.cn/download/DSM"
@@ -26,310 +63,311 @@ DL_GLOBAL="https://global.synologydownload.com/download/DSM"
 [[ "${URL,,}" == *"cndl.synology"* ]] && DL="$DL_CHINA"
 [[ "${URL,,}" == *"global.synology"* ]] && DL="$DL_GLOBAL"
 
+# Honor an explicitly selected Synology mirror first, otherwise choose the
+# China or global endpoint from the detected country.
 if [ -z "$DL" ]; then
   [ -z "$COUNTRY" ] && setCountry
   [ -z "$COUNTRY" ] && info "Warning: could not detect country to select mirror!"
   [[ "${COUNTRY^^}" == "CN" ]] && DL="$DL_CHINA" || DL="$DL_GLOBAL"
 fi
 
-[ -z "$URL" ] && URL="$DL/release/7.2.1/69057-1/DSM_VirtualDSM_69057.pat"
+if [ -z "$URL" ]; then
+  URL="$DL/release/7.2.2/72806/DSM_VirtualDSM_72806.pat"
+fi
 
-BASE=$(basename "$URL" .pat)
+if [ ! -s "$FILE" ]; then
+  BASE=$(basename "${URL%%\?*}" .pat)
+  printf -v BASE '%b' "${BASE//%/\\x}"
+  BASE="${BASE//[!A-Za-z0-9._-]/_}"
+fi
 
 if [[ "$URL" != "file://$STORAGE/$BASE.pat" ]]; then
-  rm -f "$STORAGE"/"$BASE".pat
+  rm -f "$STORAGE/$BASE.pat"
 fi
 
-rm -f "$STORAGE"/"$BASE".agent
+rm -f "$STORAGE/$BASE.agent"
-rm -f "$STORAGE"/"$BASE".boot.img
+rm -f "$STORAGE/$BASE.boot.img"
-rm -f "$STORAGE"/"$BASE".system.img
+rm -f "$STORAGE/$BASE.system.img"
-
-[[ "$DEBUG" == [Yy1]* ]] && set -x
 
 # Check filesystem
-MIN_ROOT=471859200
-MIN_SPACE=6442450944
 FS=$(stat -f -c %T "$STORAGE")
 
-if [[ "${FS,,}" == "overlay"* ]]; then
+if [[ "${FS,,}" == "overlay"* && "${ENGINE,,}" == "docker" ]]; then
-  info "Warning: the filesystem of $STORAGE is OverlayFS, this usually means it was binded to an invalid path!"
+  warn "the filesystem of $STORAGE is OverlayFS, this usually means it was binded to an invalid path!"
 fi
 
-if [[ "${FS,,}" != "fat"* && "${FS,,}" != "vfat"* && "${FS,,}" != "exfat"* && \
+if [[ "${FS,,}" == "fuse"* ]]; then
-        "${FS,,}" != "ntfs"* && "${FS,,}" != "fuse"* && "${FS,,}" != "msdos"* ]]; then
+  warn "the filesystem of $STORAGE is FUSE, this extra layer will negatively affect performance!"
+fi
+
+if [[ "${FS,,}" == "ecryptfs" || "${FS,,}" == "tmpfs" ]]; then
+  warn "the filesystem of $STORAGE is $FS, which does not support O_DIRECT mode, adjusting settings..."
+fi
+
+if [[ "${FS,,}" == "fat"* || "${FS,,}" == "vfat"* || "${FS,,}" == "msdos"* ]]; then
+  error "Unable to install on $FS filesystems, please use a different filesystem for /storage." && exit 61
+fi
+
+# Extract beside storage on Unix filesystems to avoid container-space limits;
+# use /tmp for filesystems that cannot safely host the installer workspace.
+if [[ "${FS,,}" != "exfat"* && "${FS,,}" != "ntfs"* && "${FS,,}" != "unknown"* ]]; then
   TMP="$STORAGE/tmp"
+  rm -rf "$TMP"
+  if ! makeDir "$TMP"; then
+    error "Failed to create directory \"$TMP\" !" && exit 93
+  fi
 else
   TMP="/tmp/dsm"
+  TMP_SPACE=2147483648
   SPACE=$(df --output=avail -B 1 /tmp | tail -n 1)
-  if (( MIN_SPACE > SPACE )); then
+  SPACE_MB=$(formatBytes "$SPACE")
-    error "The ${FS^^} filesystem of $STORAGE does not support UNIX permissions, and no space left in container!" && exit 93
+  if (( TMP_SPACE > SPACE )); then
+    error "Not enough free space inside the container, have $SPACE_MB available but need at least 2 GB." && exit 93
   fi
+  rm -rf "$TMP" && mkdir -p "$TMP"
 fi
 
-rm -rf "$TMP" && mkdir -p "$TMP"
-
 # Check free diskspace
+ROOT_SPACE=536870912
 SPACE=$(df --output=avail -B 1 / | tail -n 1)
-(( MIN_ROOT > SPACE )) && error "Not enough free space in container root, need at least 450 MB available." && exit 96
+SPACE_MB=$(formatBytes "$SPACE" "down")
+(( ROOT_SPACE > SPACE )) && error "Not enough free space inside the container, have $SPACE_MB available but need at least 500 MB." && exit 96
 
+MIN_SPACE=15032385536
 SPACE=$(df --output=avail -B 1 "$STORAGE" | tail -n 1)
-SPACE_GB=$(( (SPACE + 1073741823)/1073741824 ))
+SPACE_GB=$(formatBytes "$SPACE")
-(( MIN_SPACE > SPACE )) && error "Not enough free space for installation in $STORAGE, have $SPACE_GB GB available but need at least 6 GB." && exit 94
+(( MIN_SPACE > SPACE )) && error "Not enough free space for installation in $STORAGE, have $SPACE_GB available but need at least 14 GB." && exit 94
 
-# Check if output is to interactive TTY
+if [[ "$URL" == "file://"* ]]; then
-if [ -t 1 ]; then
+  MSG="Copying DSM"
-  PROGRESS="--progress=bar:noscroll"
+  ERR="Failed to copy ${URL:7}"
+  info "Install: Copying installation image..."
 else
-  PROGRESS="--progress=dot:giga"
+  MSG="Downloading DSM"
+  ERR="Failed to download $URL"
+  info "Install: Downloading $BASE.pat..."
 fi
 
-# Download the required files from the Synology website
+html "$MSG..."
-
-ROOT="Y"
-RDC="$STORAGE/dsm.rd"
-
-if [ ! -f "$RDC" ]; then
-
-  info "Install: Downloading installer..."
-
-  RD="$TMP/rd.gz"
-  POS="65627648-71021835"
-  VERIFY="b4215a4b213ff5154db0488f92c87864"
-  LOC="$DL/release/7.0.1/42218/DSM_VirtualDSM_42218.pat"
-
-  { curl -r "$POS" -sfk -S -o "$RD" "$LOC"; rc=$?; } || :
-  (( rc != 0 )) && error "Failed to download $LOC, reason: $rc" && exit 60
-
-  SUM=$(md5sum "$RD" | cut -f 1 -d " ")
-
-  if [ "$SUM" != "$VERIFY" ]; then
-
-    PAT="/install.pat"
-    rm "$RD"
-    rm -f "$PAT"
-
-    { wget "$LOC" -O "$PAT" -q --no-check-certificate --show-progress "$PROGRESS"; rc=$?; } || :
-    (( rc != 0 )) && error "Failed to download $LOC, reason: $rc" && exit 60
-
-    tar --extract --file="$PAT" --directory="$(dirname "$RD")"/. "$(basename "$RD")"
-    rm "$PAT"
-
-  fi
-
-  cp "$RD" "$RDC"
-
-fi
-
-if [ -f "$RDC" ]; then
-
-  { xz -dc <"$RDC" >"$TMP/rd" 2>/dev/null; rc=$?; } || :
-  (( rc != 1 )) && error "Failed to unxz $RDC, reason $rc" && exit 91
-
-  { (cd "$TMP" && cpio -idm <"$TMP/rd" 2>/dev/null); rc=$?; } || :
-
-  if (( rc != 0 )); then
-    ROOT="N"
-    { (cd "$TMP" && fakeroot cpio -idmu <"$TMP/rd" 2>/dev/null); rc=$?; } || :
-    (( rc != 0 )) && error "Failed to extract $RDC, reason $rc" && exit 92
-  fi
-
-  mkdir -p /run/extract
-  for file in $TMP/usr/lib/libcurl.so.4 \
-              $TMP/usr/lib/libmbedcrypto.so.5 \
-              $TMP/usr/lib/libmbedtls.so.13 \
-              $TMP/usr/lib/libmbedx509.so.1 \
-              $TMP/usr/lib/libmsgpackc.so.2 \
-              $TMP/usr/lib/libsodium.so \
-              $TMP/usr/lib/libsynocodesign-ng-virtual-junior-wins.so.7 \
-              $TMP/usr/syno/bin/scemd; do
-    cp "$file" /run/extract/
-  done
-
-  if [ "$ARCH" != "amd64" ]; then
-    mkdir -p /lib64/
-    cp "$TMP/usr/lib/libc.so.6" /lib64/
-    cp "$TMP/usr/lib/libpthread.so.0" /lib64/
-    cp "$TMP/usr/lib/ld-linux-x86-64.so.2" /lib64/
-  fi
-
-  mv /run/extract/scemd /run/extract/syno_extract_system_patch
-  chmod +x /run/extract/syno_extract_system_patch
-
-fi
-
-rm -rf "$TMP" && mkdir -p "$TMP"
-
-info "Install: Downloading $(basename "$URL")..."
 
 PAT="/$BASE.pat"
 rm -f "$PAT"
 
 if [[ "$URL" == "file://"* ]]; then
 
+  if [ ! -f "${URL:7}" ]; then
+    error "File '${URL:7}' does not exist!" && exit 65
+  fi
+
   cp "${URL:7}" "$PAT"
 
 else
 
-  { wget "$URL" -O "$PAT" -q --no-check-certificate --show-progress "$PROGRESS"; rc=$?; } || :
+  SIZE=0
-  (( rc != 0 )) && error "Failed to download $URL, reason: $rc" && exit 69
+  REASON=""
+  PROGRESS=()
+  OUTPUT=""
+  LOG=$(mktemp)
+
+  [[ "${URL,,}" == *"_72806.pat" ]] && SIZE=361010261
+  [[ "${URL,,}" == *"_69057.pat" ]] && SIZE=363837333
+  [[ "${URL,,}" == *"_42218.pat" ]] && SIZE=379637760
+
+  # Use Wget's progress bar in a terminal and progress.sh in container logs.
+  if [ -t 1 ]; then
+    PROGRESS=( --show-progress --progress=bar:noscroll )
+  else
+    OUTPUT="log"
+  fi
+
+  /run/progress.sh "$PAT" "$SIZE" "$MSG ([P])..." "$OUTPUT" 52428800 &
+
+  {
+    LC_ALL=C wget "$URL" -O "$PAT" --no-verbose --no-check-certificate \
+      --timeout=30 --no-http-keep-alive "${PROGRESS[@]}" \
+      --output-file="$LOG"
+    rc=$?
+  } || :
+
+  fKill "progress.sh"
+
+  if (( rc != 0 )); then
+    REASON=$(sed -n \
+      -e 's/^wget: //p' \
+      -e 's/^[0-9-]\{10\} [0-9:]\{8\} ERROR //p' \
+      "$LOG" | tail -n 1)
+  fi
+
+  rm -f "$LOG"
+
+  if (( rc == 3 )); then
+    error "$ERR because the file could not be written (disk full?)."
+    exit 69
+  elif (( rc != 0 )); then
+    if [ -n "$REASON" ]; then
+      error "$ERR: ${REASON%.}."
+    else
+      error "$ERR with exit status $rc."
+    fi
+    exit 69
+  fi
 
 fi
 
-[ ! -f "$PAT" ] && error "Failed to download $URL" && exit 69
+[ ! -s "$PAT" ] && error "$ERR" && exit 69
 
 SIZE=$(stat -c%s "$PAT")
 
+# Full Virtual DSM PAT files are substantially larger than update packs;
+# reject undersized inputs before attempting destructive image preparation.
 if ((SIZE<250000000)); then
   error "The specified PAT file is probably an update pack as it's too small." && exit 62
 fi
 
-info "Install: Extracting downloaded image..."
+MSG="Extracting installation image..."
+info "Install: $MSG" && html "$MSG"
 
+# Newer PAT files are normal tar archives; older encrypted/proprietary forms
+# require the bundled extractor as a compatibility fallback.
 if { tar tf "$PAT"; } >/dev/null 2>&1; then
 
   tar xpf "$PAT" -C "$TMP/."
 
 else
 
-  export LD_LIBRARY_PATH="/run/extract"
+  { (cd "$TMP" && python3 /run/extract.py -i "$PAT" -d 2>/run/extract.log); rc=$?; } || :
 
-  if [ "$ARCH" == "amd64" ]; then
+  if (( rc != 0 )); then
-    { /run/extract/syno_extract_system_patch "$PAT" "$TMP/."; rc=$?; } || :
+    cat /run/extract.log
-  else
+    error "Failed to extract PAT file, reason $rc" && exit 63
-    { qemu-x86_64 /run/extract/syno_extract_system_patch "$PAT" "$TMP/."; rc=$?; } || :
   fi
 
-  export LD_LIBRARY_PATH=""
-
-  (( rc != 0 )) && error "Failed to extract PAT file, reason $rc" && exit 63
-
 fi
 
+MSG="Preparing system partition..."
+info "Install: $MSG" && html "$MSG"
+
+# The PAT boot archive becomes the persistent QEMU boot disk after its
+# companion system partition has been assembled.
+BOOT=$(find "$TMP" -name "*.bin.zip" -print -quit)
+[ -z "$BOOT" ] && error "The PAT file contains no boot image." && exit 67
+[ ! -s "$BOOT" ] && error "The PAT boot image archive is empty." && exit 67
+
+unzip -q -o "$BOOT" -d "$TMP"
+BOOT="${BOOT%.zip}"
+
+SYSTEM="$STORAGE/$BASE.system.img"
+rm -f "$SYSTEM"
+
+# Check free diskspace
+SYSTEM_SIZE=10738466816
+SPACE=$(df --output=avail -B 1 "$STORAGE" | tail -n 1)
+SPACE_MB=$(formatBytes "$SPACE")
+
+if (( SYSTEM_SIZE > SPACE )); then
+  error "Not enough free space in $STORAGE to create a 10 GB system disk, have only $SPACE_MB available." && exit 97
+fi
+
+if ! touch "$SYSTEM"; then
+  error "Could not create file $SYSTEM for the system disk." && exit 98
+fi
+
+setOwner "$SYSTEM" || warn "failed to set the owner for \"$SYSTEM\" !"
+
+if [[ "${FS,,}" == "btrfs" ]]; then
+  { chattr +C "$SYSTEM"; } || :
+  FA=$(lsattr "$SYSTEM")
+  if [[ "$FA" != *"C"* ]]; then
+    error "Failed to disable COW for system image $SYSTEM on ${FS^^} filesystem."
+  fi
+fi
+
+if ! fallocate -l "$SYSTEM_SIZE" "$SYSTEM" &>/dev/null; then
+  if ! fallocate -l -x "$SYSTEM_SIZE" "$SYSTEM"; then
+    if ! truncate -s "$SYSTEM_SIZE" "$SYSTEM"; then
+      rm -f "$SYSTEM"
+      error "Could not allocate file $SYSTEM for the system disk." && exit 98
+    fi
+  fi
+fi
+
+# Recreate Synology's expected DOS partition layout inside the fixed 10 GiB
+# system image before populating the ext4 root partition.
+PART="$TMP/partition.fdisk"
+
+{
+  echo "label: dos"
+  echo "label-id: 0x6f9ee2e9"
+  echo "device: $SYSTEM"
+  echo "unit: sectors"
+  echo "sector-size: 512"
+  echo ""
+  echo "${SYSTEM}1 : start=        2048, size=    16777216, type=83"
+  echo "${SYSTEM}2 : start=    16779264, size=     4194304, type=82"
+} > "$PART"
+
+sfdisk -q "$SYSTEM" < "$PART"
+
+MOUNT="$TMP/system"
+rm -rf "$MOUNT"
+
+if ! makeDir "$MOUNT"; then
+  error "Failed to create directory \"$MOUNT\" !" && exit 93
+fi
+
+MSG="Extracting system partition..."
+info "Install: $MSG" && html "$MSG"
+
 HDA="$TMP/hda1"
 IDB="$TMP/indexdb"
 PKG="$TMP/packages"
 HDP="$TMP/synohdpack_img"
 
-[ ! -f "$HDA.tgz" ] && error "The PAT file contains no OS image." && exit 64
+[ ! -s "$HDA.tgz" ] && error "The PAT file contains no OS image." && exit 64
-
-BOOT=$(find "$TMP" -name "*.bin.zip")
-[ ! -f "$BOOT" ] && error "The PAT file contains no boot image." && exit 67
-
-BOOT=$(echo "$BOOT" | head -c -5)
-unzip -q -o "$BOOT".zip -d "$TMP"
-
-SYSTEM="$TMP/sys.img"
-SYSTEM_SIZE=4954537983
-rm -f "$SYSTEM"
-
-# Check free diskspace
-SPACE=$(df --output=avail -B 1 "$TMP" | tail -n 1)
-SPACE_GB=$(( (SPACE + 1073741823)/1073741824 ))
-(( SYSTEM_SIZE > SPACE )) && error "Not enough free space to create a 4 GB system disk, have only $SPACE_GB GB available." && exit 97
-
-if ! touch "$SYSTEM"; then
-  error "Could not create file $SYSTEM for the system disk." && exit 98
-fi
-  
-if [[ "${FS,,}" == "xfs" || "${FS,,}" == "zfs" || "${FS,,}" == "btrfs" || "${FS,,}" == "bcachefs" ]]; then
-  { chattr +C "$SYSTEM"; } || :
-  FA=$(lsattr "$SYSTEM")
-  if [[ "$FA" != *"C"* ]]; then
-    error "Failed to disable COW for system image $SYSTEM on ${FS^^} filesystem (returned $FA)"
-  fi
-fi
-
-if ! fallocate -l "$SYSTEM_SIZE" "$SYSTEM"; then
-  if ! truncate -s "$SYSTEM_SIZE" "$SYSTEM"; then
-    rm -f "$SYSTEM"
-    error "Could not allocate file $SYSTEM for the system disk." && exit 98
-  fi
-fi
-
-# Check if file exists
-[ ! -f "$SYSTEM" ] && error "System disk does not exist ($SYSTEM)" && exit 99
-
-# Check the filesize
-SIZE=$(stat -c%s "$SYSTEM")
-
-if [[ SIZE -ne SYSTEM_SIZE ]]; then
-  rm -f "$SYSTEM"
-  error "System disk has the wrong size: $SIZE vs $SYSTEM_SIZE" && exit 90
-fi
-
-PART="$TMP/partition.fdisk"
-
-{       echo "label: dos"
-        echo "label-id: 0x6f9ee2e9"
-        echo "device: $SYSTEM"
-        echo "unit: sectors"
-        echo "sector-size: 512"
-        echo ""
-        echo "${SYSTEM}1 : start=        2048, size=     4980480, type=83"
-        echo "${SYSTEM}2 : start=     4982528, size=     4194304, type=82"
-} > "$PART"
-
-sfdisk -q "$SYSTEM" < "$PART"
-
-info "Install: Extracting system partition..."
-
-LABEL="1.44.1-42218"
-OFFSET="1048576" # 2048 * 512
-NUMBLOCKS="622560" # (4980480 * 512) / 4096
-
-MOUNT="$TMP/system"
-rm -rf "$MOUNT" && mkdir -p "$MOUNT"
-
 mv "$HDA.tgz" "$HDA.txz"
 
-if [[ "$ROOT" != [Nn]* ]]; then
-
-  tar xpfJ "$HDA.txz" --absolute-names -C "$MOUNT/"
-
-fi
-
 [ -d "$PKG" ] && mv "$PKG/" "$MOUNT/.SynoUpgradePackages/"
 rm -f "$MOUNT/.SynoUpgradePackages/ActiveInsight-"*
 
-[ -f "$HDP.txz" ] && tar xpfJ "$HDP.txz" --absolute-names -C "$MOUNT/"
+INDEX_DB="$MOUNT/usr/syno/synoman/indexdb"
 
-if [ -f "$IDB.txz" ]; then
+if [ -s "$IDB.txz" ]; then
-  INDEX_DB="$MOUNT/usr/syno/synoman/indexdb/"
   mkdir -p "$INDEX_DB"
-  tar xpfJ "$IDB.txz" --absolute-names -C "$INDEX_DB"
 fi
 
-if [[ "$ROOT" != [Nn]* ]]; then
+LABEL="1.44.1-42218"
+OFFSET="1048576"    # 2048 * 512
+NUMBLOCKS="2097152" # (16777216 * 512) / 4096
+MSG="Installing system partition..."
 
-  info "Install: Installing system partition..."
+# Build the ext4 filesystem directly from the extracted tree under fakeroot,
-
+# preserving archive ownership without mounting a loop device.
-  mke2fs -q -t ext4 -b 4096 -d "$MOUNT/" -L "$LABEL" -F -E "offset=$OFFSET" "$SYSTEM" "$NUMBLOCKS"
+fakeroot -- bash -c "set -Eeu;\
-
+  [ -s $HDP.txz ] && tar xpfJ $HDP.txz --absolute-names -C $MOUNT/;\
-else
+  [ -s $IDB.txz ] && tar xpfJ $IDB.txz --absolute-names -C $INDEX_DB/;\
-
+  tar xpfJ $HDA.txz --absolute-names --skip-old-files -C $MOUNT/;\
-  fakeroot -- bash -c "set -Eeu;\
+  printf '%b%s%b' '\E[1;34m❯ \E[1;36m' 'Install: $MSG' '\E[0m\n';\
-        tar xpfJ $HDA.txz --absolute-names --skip-old-files -C $MOUNT/;\
+  mke2fs -q -t ext4 -b 4096 -d $MOUNT/ -L $LABEL -F -E offset=$OFFSET $SYSTEM $NUMBLOCKS"
-        printf '%b%s%b' '\E[1;34m❯ \E[1;36m' 'Install: Installing system partition...' '\E[0m\n';\
-        mke2fs -q -t ext4 -b 4096 -d $MOUNT/ -L $LABEL -F -E offset=$OFFSET $SYSTEM $NUMBLOCKS"
-
-fi
 
 rm -rf "$MOUNT"
+echo "$BASE" > "$STORAGE/dsm.ver"
+setOwner "$STORAGE/dsm.ver" || warn "failed to set the owner for \"$STORAGE/dsm.ver\" !"
 
-echo "$BASE" > "$STORAGE"/dsm.ver
+# Do not keep a second copy when the source PAT already lives in storage;
-
+# downloaded or externally mounted sources are cached for later reuse.
 if [[ "$URL" == "file://$STORAGE/$BASE.pat" ]]; then
   rm -f "$PAT"
 else
-  mv -f "$PAT" "$STORAGE"/"$BASE".pat
+  mv -f "$PAT" "$STORAGE/$BASE.pat"
 fi
 
-mv -f "$BOOT" "$STORAGE"/"$BASE".boot.img
+if [ -f "$STORAGE/$BASE.pat" ]; then
-mv -f "$SYSTEM" "$STORAGE"/"$BASE".system.img
+  setOwner "$STORAGE/$BASE.pat" || warn "failed to set the owner for \"$STORAGE/$BASE.pat\" !"
+fi
+
+mv -f "$BOOT" "$STORAGE/$BASE.boot.img"
+setOwner "$STORAGE/$BASE.boot.img" || warn "failed to set the owner for \"$STORAGE/$BASE.boot.img\" !"
 
 rm -rf "$TMP"
 
-{ set +x; } 2>/dev/null
-[[ "$DEBUG" == [Yy1]* ]] && echo
-
 return 0

src/memory.sh

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+normalizeMemory() {
+
+  local wanted
+
+  RAM_SPARE=500000000
+  RAM_MINIMUM="${RAM_MINIMUM:-1073741824}"
+
+  RAM_MINIMUM=$(strip "$RAM_MINIMUM")
+  RAM_MINIMUM="${RAM_MINIMUM// /}"
+  RAM_MINIMUM=$(echo "${RAM_MINIMUM^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+  numfmt --from=iec "$RAM_MINIMUM" &>/dev/null || {
+    error "Invalid RAM_MINIMUM: $RAM_MINIMUM"
+    exit 16
+  }
+  RAM_MINIMUM=$(numfmt --from=iec "$RAM_MINIMUM")
+
+  RAM_SIZE=$(strip "$RAM_SIZE")
+  RAM_SIZE="${RAM_SIZE// /}"
+  [ -z "$RAM_SIZE" ] && RAM_SIZE="2G"
+
+  if [[ "${RAM_SIZE,,}" != "max" && "${RAM_SIZE,,}" != "half" ]]; then
+
+    # Bare values below 130 are interpreted as GiB for convenience; larger bare
+    # values are treated as MiB to preserve historical configurations.
+    if [ -z "${RAM_SIZE//[0-9. ]}" ]; then
+      [ "${RAM_SIZE%%.*}" -lt "130" ] && RAM_SIZE="${RAM_SIZE}G" || RAM_SIZE="${RAM_SIZE}M"
+    fi
+
+    RAM_SIZE=$(echo "${RAM_SIZE^^}" | sed 's/MB/M/g;s/GB/G/g;s/TB/T/g')
+    numfmt --from=iec "$RAM_SIZE" &>/dev/null || {
+      error "Invalid RAM_SIZE: $RAM_SIZE"
+      exit 16
+    }
+
+    wanted=$(numfmt --from=iec "$RAM_SIZE")
+
+    if [ "$wanted" -lt "$RAM_MINIMUM" ]; then
+      error "$(app) requires at least $(formatBytes "$RAM_MINIMUM") of RAM, but RAM_SIZE is set to $(formatBytes "$wanted")."
+      exit 16
+    fi
+
+    # QEMU requires a whole-number memory value, so convert decimal sizes to MiB.
+    if [[ "$RAM_SIZE" == *.* ]]; then
+      RAM_SIZE="$(( wanted / 1048576 ))M"
+    fi
+
+  fi
+
+  return 0
+}
+
+checkConfiguredMemory() {
+
+  local final="$1"
+
+  if disabled "$RAM_CHECK" || [[ "${RAM_SIZE,,}" == "max" || "${RAM_SIZE,,}" == "half" ]]; then
+    return 0
+  fi
+
+  local wanted avail_mem
+  wanted=$(numfmt --from=iec "$RAM_SIZE")
+  avail_mem=$(formatBytes "$RAM_AVAIL")
+
+  if (( (wanted + RAM_SPARE) > RAM_AVAIL )); then
+
+    local msg="Your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is too high for the $avail_mem of free memory available,"
+
+    # ZFS ARC can release cached memory under pressure, so this free-memory
+    # heuristic remains informational instead of rewriting RAM_SIZE.
+    if [[ "${FS,,}" == "zfs" ]]; then
+
+      enabled "$final" && info "$msg but since ZFS is active this will be ignored."
+
+    else
+
+      RAM_SIZE="max"
+      RAM_WARNING="$msg it will automatically be adjusted to a lower amount."
+
+    fi
+
+  else
+
+    if (( (wanted + (RAM_SPARE * 3)) > RAM_AVAIL )); then
+
+      local msg="your configured RAM_SIZE of ${RAM_SIZE/G/ GB} is very close to the $avail_mem of free memory available,"
+
+      if [[ "${FS,,}" == "zfs" ]]; then
+        enabled "$final" && info "$msg but since ZFS is active this will be ignored."
+      else
+        enabled "$final" && warn "$msg please consider a lower amount."
+      fi
+
+    fi
+
+  fi
+
+  return 0
+}
+
+configureHalfMemory() {
+
+  if [[ "${RAM_SIZE,,}" != "half" ]]; then
+    return 0
+  fi
+
+  if (( (RAM_AVAIL / 2) > RAM_SPARE )); then
+
+    local wanted=$(( RAM_AVAIL / 2 ))
+
+    # Divide by one byte more than a MiB to round down
+    local target=$(( wanted / 1048577 ))
+    RAM_SIZE="${target}M"
+    RAM_ALLOCATION="$wanted"
+
+  else
+
+    RAM_SIZE="max"
+
+  fi
+
+  return 0
+}
+
+configureMaxMemory() {
+
+  if [[ "${RAM_SIZE,,}" != "max" ]]; then
+    return 0
+  fi
+
+  # max keeps a host reserve when possible, but on very small systems falls back
+  # to half the available memory to avoid starving the container.
+  if (( RAM_AVAIL < (RAM_SPARE * 2) )); then
+
+    local wanted=$(( RAM_AVAIL / 2 ))
+
+  else
+
+    local wanted=$(( RAM_AVAIL - (RAM_SPARE * 3) ))
+
+    if (( wanted < (RAM_SPARE * 6) )); then
+      wanted=$(( RAM_AVAIL - RAM_SPARE ))
+    fi
+
+  fi
+
+  # Divide by one byte more than a MiB to round down
+  local target=$(( wanted / 1048577 ))
+  RAM_SIZE="${target}M"
+  RAM_ALLOCATION="$wanted"
+
+  return 0
+}
+
+showMemoryLimitHint() {
+
+  local kernel
+  kernel=$(uname -r)
+
+  if [[ "${kernel,,}" == *-wsl2* ]]; then
+    echo
+    info "Docker Desktop (WSL2) is detected, follow these instructions:"
+    info ""
+    info "Increase the memory limit in \"%UserProfile%\\.wslconfig\" by setting \"memory=<size>\" under \"[wsl2]\"."
+    info "Then run \"wsl --shutdown\" in PowerShell and restart Docker Desktop for the new limit to take effect."
+    echo
+  fi
+
+  return 0
+}
+
+checkMinimumMemory() {
+
+  local wanted
+  wanted=$(numfmt --from=iec "$RAM_SIZE")
+
+  if [ "$wanted" -lt "$RAM_MINIMUM" ]; then
+
+    error "$(app) requires at least $(formatBytes "$RAM_MINIMUM") of RAM, but only $(formatBytes "$wanted") can be allocated."
+
+    showMemoryLimitHint
+
+    exit 16
+  fi
+
+  return 0
+}
+
+checkMemoryAllocation() {
+
+  local final="${1:-N}"
+  local configured
+
+  normalizeMemory
+  configured="$RAM_SIZE"
+
+  RAM_WARNING=""
+  RAM_ALLOCATION=""
+
+  getMemoryInfo
+  checkConfiguredMemory "$final"
+
+  configureHalfMemory
+  configureMaxMemory
+  checkMinimumMemory
+
+  if enabled "$final"; then
+    [ -n "$RAM_WARNING" ] && warn "$RAM_WARNING"
+    [ -n "$RAM_ALLOCATION" ] && info "Allocated $(formatBytes "$RAM_ALLOCATION") of RAM for $(app)."
+  else
+    RAM_SIZE="$configured"
+  fi
+
+  return 0
+}
+
+checkMemoryRequirement() {
+
+  checkMemoryAllocation "N"
+
+  return 0
+}
+
+finalizeMemory() {
+
+  checkMemoryAllocation "Y"
+
+  return 0
+}
+
+checkMemoryRequirement
+
+return 0

src/power.sh

@@ -1,40 +1,256 @@
 #!/usr/bin/env bash
 set -Eeuo pipefail
 
+: "${SHUTDOWN:="Y"}"        # Graceful ACPI shutdown
+: "${TIMEOUT:="105"}"       # QEMU termination timeout
+: "${API_TIMEOUT:="90"}"    # External API call timeout
+
 # Configure QEMU for graceful shutdown
 
-QEMU_PORT=7100
+API_CMD=6
-QEMU_TIMEOUT=55
-QEMU_PID="/run/qemu.pid"
-QEMU_COUNT="/run/qemu.count"
 
-rm -f "$QEMU_PID"
+SHUTDOWN_SKIP=0
-rm -f "$QEMU_COUNT"
+SHUTDOWN_SIGNAL=0
 
-_trap(){
+QEMU_END="$QEMU_DIR/qemu.end"
-    func="$1" ; shift
+CONSOLE_PID="$QEMU_DIR/console.pid"
-    for sig ; do
+CONSOLE_SOCKET="$QEMU_DIR/console.sock"
-        trap "$func $sig" "$sig"
+QEMU_START_PID="$QEMU_DIR/qemu.start.pid"
-    done
+
+_trap() {
+
+  local func="$1"; shift
+  local sig
+
+  TRAP_PID=$BASHPID
+
+  for sig; do
+    # Capture the local callback and signal while registering the trap.
+    # shellcheck disable=SC2064
+    trap "$func $sig" "$sig"
+  done
+
+  return 0
 }
 
-_graceful_shutdown() {
+signalCode() {
 
-  set +e
+  local sig="$1"
-  local cnt response
 
-  [ ! -f "$QEMU_PID" ] && exit 130
+  case "$sig" in
-  [ -f "$QEMU_COUNT" ] && return
+    SIGHUP)  echo 129 ;;
+    SIGINT)  echo 130 ;;
+    SIGQUIT) echo 131 ;;
+    SIGABRT) echo 134 ;;
+    SIGTERM) echo 143 ;;
+    *)       echo 0 ;;
+  esac
 
-  echo 0 > "$QEMU_COUNT"
+  return 0
-  echo && info "Received $1 signal, sending shutdown command..."
+}
 
+displayReason() {
+
+  local reason="$1"
+
+  case "$reason" in
+    129 ) echo "SIGHUP" ;;
+    130 ) echo "SIGINT" ;;
+    131 ) echo "SIGQUIT" ;;
+    134 ) echo "SIGABRT" ;;
+    143 ) echo "SIGTERM" ;;
+    * )   echo "$reason" ;;
+  esac
+
+  return 0
+}
+
+readQemuPid() {
+
+  # Interactive startup uses a wrapper-created PID file before QEMU writes its
+  # own pidfile, so accept either during startup and shutdown races.
+  readPidFile "$1" "$QEMU_START_PID" && return 0
+  readPidFile "$1" "$QEMU_PID"
+}
+
+qemuPidFile() {
+
+  local -n _file="$1"
+
+  _file="$QEMU_PID"
+  [ -s "$QEMU_START_PID" ] && _file="$QEMU_START_PID"
+
+  return 0
+}
+
+waitQemuExit() {
+
+  local timeout="${1:-10}"
+  local file
+
+  qemuPidFile file
+  waitPidFile "$file" "$timeout"
+}
+
+waitQemuPid() {
+
+  local cnt=0
+
+  while ! readQemuPid "$1"; do
+    sleep 0.02
+    cnt=$((cnt + 1))
+    (( cnt >= 50 )) && return 1
+  done
+
+  return 0
+}
+
+forceKillQemu() {
+
+  local reason="$1"
+  local pid display
+
+  readQemuPid pid || return 0
+  isAlive "$pid" || return 0
+
+  display=$(displayReason "$reason")
+  error "Forcefully terminating $(app), reason: $display..."
+  { disown "$pid" || :; kill -9 -- "$pid" || :; } 2>/dev/null
+
+  return 0
+}
+
+cleanupHelpers() {
+
+  local pids=( "${HOST_PID:-}" "${WSD_PID:-}" "${CONSOLE_PID:-}" \
+               "${WEB_PID:-}" "${PASST_PID:-}" "${DNSMASQ_PID:-}" )
+
+  mKill "${pids[@]}"
+  fKill "print.sh"
+
+  rm -f -- "$HOST_API_SOCKET" "$HOST_AGENT_SOCKET"
+
+  closeNetwork
+  return 0
+}
+
+startConsole() {
+
+  local output="${1:-/dev/tty}"
+  local cnt=0
+
+  rm -f -- "$CONSOLE_SOCKET" "$CONSOLE_PID"
+
+  if ! stty -icanon -echo isig -ixon min 1 time 0 </dev/tty; then
+    error "Failed to configure serial console terminal!"
+    return 1
+  fi
+
+  (
+    trap '' INT QUIT
+    exec nc -lU "$CONSOLE_SOCKET" </dev/tty >"$output"
+  ) &
+
+  local pid="$!"
+  echo "$pid" > "$CONSOLE_PID"
+
+  while [ ! -S "$CONSOLE_SOCKET" ]; do
+
+    if ! isAlive "$pid"; then
+      rm -f -- "$CONSOLE_PID"
+      error "Serial console relay exited unexpectedly!"
+      return 1
+    fi
+
+    sleep 0.02
+    cnt=$((cnt + 1))
+
+    if (( cnt > 100 )); then
+      error "Failed to start serial console relay!"
+      return 1
+    fi
+
+  done
+
+  return 0
+}
+
+stopConsole() {
+
+  mKill "$CONSOLE_PID"
+
+  return 0
+}
+
+startQemu() {
+
+  rm -f -- "$QEMU_START_PID"
+
+  # Launch QEMU in a separate session while recording the real child PID;
+  # setsid's wrapper PID is not suitable for guest shutdown or forced cleanup.
+  (
+    trap '' INT QUIT
+
+    # shellcheck disable=SC2016
+    exec setsid -f -w sh -c '
+      file=$1
+      shift
+
+      "$@" &
+      pid=$!
+      printf "%s\n" "$pid" > "$file" || exit 1
+
+      rc=0
+      wait "$pid" 2>/dev/null || rc=$?
+      exit "$rc"
+    ' sh "$QEMU_START_PID" "$@"
+  ) </dev/null &
+
+  return 0
+}
+
+finish() {
+
+  local reason=$1 failed=0
+
+  if [ ! -f "$QEMU_END" ] && (( reason != 0 )); then
+    failed=1
+  fi
+
+  touch "$QEMU_END"
+
+  forceKillQemu "$reason"
+  cleanupHelpers
+
+  if ! waitQemuExit 10; then
+    warn "Timed out while waiting for $(app) to exit!"
+  fi
+
+  echo
+
+  if (( failed == 0 )); then
+    echo "❯ Shutdown completed!"
+  else
+    error "QEMU exited unexpectedly!"
+  fi
+
+  exit "$reason"
+}
+
+sendGuestShutdown() {
+
+  local pid="$1"
+  local response
+
+  # Virtual DSM ignores ACPI powerdown, so graceful shutdown must go through
+  # the qemu-host guest API exposed on the Unix socket.
   # Don't send the powerdown signal because vDSM ignores ACPI signals
-  # echo 'system_powerdown' | nc -q 1 -w 1 localhost "${QEMU_PORT}" > /dev/null
+  # nc -q 1 -w 1 -U "$QEMU_DIR/monitor.sock" &> /dev/null <<<'system_powerdown' || :
 
   # Send shutdown command to guest agent via serial port
-  url="http://127.0.0.1:2210/read?command=6&timeout=50"
+  API_TIMEOUT=$(strip "$API_TIMEOUT")
-  response=$(curl -sk -m 52 -S "$url" 2>&1)
+  local url="http://localhost/read?command=$API_CMD&timeout=$API_TIMEOUT"
+  response=$(curl --unix-socket "$HOST_API_SOCKET" -sk -m "$(( API_TIMEOUT+2 ))" -S "$url" 2>&1)
 
   if [[ "$response" =~ "\"success\"" ]]; then
 
@@ -43,45 +259,149 @@ _graceful_shutdown() {
   else
 
     response="${response#*message\"\: \"}"
-    echo && error "Failed to send shutdown command: ${response%%\"*}"
+    [ -z "$response" ] && response="second signal"
 
-    kill -15 "$(cat "$QEMU_PID")"
+    echo && error "Forcefully terminating because of: ${response%%\"*}"
-    pkill -f qemu-system-x86_64 || true
+    kill -15 -- "$pid" 2>/dev/null || :
 
   fi
 
-  while [ "$(cat $QEMU_COUNT)" -lt "$QEMU_TIMEOUT" ]; do
+  return 0
+}
 
-    # Try to connect to qemu
+normalizeTimeout() {
-    if ! echo 'info version'| nc -q 1 -w 1 localhost "$QEMU_PORT" >/dev/null 2>&1 ; then
+
-      break
+  # Divide the remaining timeout into guest wait, SIGTERM grace, and final
+  # cleanup instead of allowing the API call to consume the entire budget.
+  local term_grace=3      # seconds before loop ends to send SIGTERM
+  local cleanup_grace=3   # seconds reserved after the loop for cleanup
+
+  TIMEOUT=$(strip "$TIMEOUT")
+  if [[ ! "$TIMEOUT" =~ ^[0-9]+$ ]]; then
+    TIMEOUT=105
+  fi
+
+  if (( TIMEOUT >= 30 )); then
+    term_grace=5
+    cleanup_grace=5
+  elif (( TIMEOUT >= 15 )); then
+    term_grace=4
+    cleanup_grace=4
+  fi
+
+  local elapsed=$((SECONDS - start))
+  local timeout_left=$((TIMEOUT - elapsed))
+
+  local min=$((term_grace + cleanup_grace + 1))
+  (( timeout_left < min )) && timeout_left=$min
+
+  wait_until=$((timeout_left - cleanup_grace))
+  sigterm_at=$((wait_until - term_grace))
+
+  return 0
+}
+
+waitForShutdown() {
+
+  local cnt=0
+  local pid="$1"
+  local name="$APP"
+
+  while (( cnt <= wait_until && SHUTDOWN_SKIP == 0 )); do
+
+    sleep 1 &
+    local slp=$!
+
+    # Stop waiting if the process has exited
+    isAlive "$pid" || break
+
+    # The process state is authoritative, but disappearance of both pidfiles
+    # also ends the wait when a wrapper exits before process reaping completes.
+    # Workaround for stale/zombie QEMU pid file
+    [ ! -s "$QEMU_START_PID" ] && [ ! -s "$QEMU_PID" ] && break
+
+    if (( cnt == sigterm_at )); then
+      info "${name^} is still running, sending SIGTERM... ($cnt/$wait_until)"
+      kill -15 -- "$pid" 2>/dev/null || :
+    elif (( cnt > 0 )) && enabled "${DEBUG:-}"; then
+      info "Waiting for $name to shut down... ($cnt/$wait_until)"
     fi
 
-    # Increase the counter
+    wait "$slp" || :
-    cnt=$(($(cat $QEMU_COUNT)+1))
+    (( cnt++ ))
-    echo $cnt > "$QEMU_COUNT"
-
-    [[ "$DEBUG" == [Yy1]* ]] && info "Shutting down, waiting... ($cnt/$QEMU_TIMEOUT)"
 
   done
 
-  if [ "$(cat $QEMU_COUNT)" -ge "$QEMU_TIMEOUT" ]; then
+  return 0
-    echo && error "Shutdown timeout reached, forcefully quitting.."
-  else
-    echo && echo "❯ Quitting..."
-  fi
-
-  echo 'quit' | nc -q 1 -w 1 localhost "$QEMU_PORT" >/dev/null 2>&1 || true
-
-  { pkill -f print.sh || true; } 2>/dev/null
-  { pkill -f host.bin || true; } 2>/dev/null
-
-  closeNetwork
-  sleep 1
-
-  return
 }
 
-_trap _graceful_shutdown SIGTERM SIGHUP SIGINT SIGABRT SIGQUIT
+gracefulShutdown() {
 
-MON_OPTS="-monitor telnet:localhost:$QEMU_PORT,server,nowait,nodelay"
+  local sig="$1"
+  local pid code
+
+  [[ $BASHPID != "$TRAP_PID" ]] && return
+
+  code=$(signalCode "$sig")
+
+  if (( SHUTDOWN_SIGNAL != 0 )); then
+
+    # A second Ctrl-C is the explicit user request to skip the remaining
+    # graceful-shutdown wait and proceed to forced cleanup.
+    if (( code == 130 && SHUTDOWN_SIGNAL == code )); then
+      SHUTDOWN_SKIP=1
+      echo && info "Received SIGINT again, forcing shutdown..."
+      return
+    fi
+
+    echo && info "Received $sig signal while already shutting down..."
+    return
+  fi
+
+  start=$SECONDS
+  SHUTDOWN_SIGNAL=$code
+
+  # Shutdown handlers must continue through missing processes and failed cleanup
+  # commands instead of being aborted by errexit.
+  set +e
+  touch "$QEMU_END"
+
+  echo && info "Received $sig signal, sending shutdown command..."
+
+  if ! readQemuPid pid; then
+    if ! interactive || ! waitQemuPid pid; then
+      warn "QEMU PID file does not exist?"
+      finish "$code"
+    fi
+  fi
+
+  if [ -z "$pid" ] || ! isAlive "$pid"; then
+    warn "QEMU process with PID $pid does not exist?"
+    finish "$code"
+  fi
+
+  sendGuestShutdown "$pid"
+  normalizeTimeout
+  waitForShutdown "$pid"
+
+  finish "$code"
+}
+
+enableTrap() {
+
+  enabled "$SHUTDOWN" || return 0
+
+  # Keep Ctrl-C available to interactive users without installing an unnecessary
+  # SIGINT handler for background/container execution.
+  if interactive; then
+    _trap gracefulShutdown SIGINT
+  fi
+
+  _trap gracefulShutdown SIGTERM SIGHUP SIGABRT SIGQUIT
+
+  return 0
+}
+
+[ -n "${QEMU_TIMEOUT:-}" ] && TIMEOUT="$QEMU_TIMEOUT"
+
+return 0

src/print.sh

@@ -1,86 +1,226 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2329
 set -Eeuo pipefail
 
-: ${DHCP:='N'}
+: "${DHCP:="N"}"
-: ${VM_NET_DEV:='eth0'}
+: "${NETWORK:="Y"}"
+
+cd /run
+. utils.sh      # Load functions
 
 info () { printf "%b%s%b" "\E[1;34m❯ \E[1;36m" "$1" "\E[0m\n" >&2; }
+warn () { printf "%b%s%b" "\E[1;33m❯ " "WARNING: $1" "\E[0m\n" >&2; }
 error () { printf "%b%s%b" "\E[1;31m❯ " "ERROR: $1" "\E[0m\n" >&2; }
 
-file="/run/dsm.url"
+disabled "$NETWORK" && exit 0
-shutdown="/run/qemu.count"
+
-url="http://127.0.0.1:2210/read?command=10"
+file="/run/shm/dsm.url"
+msgs="/run/shm/msg.html"
+driver="/run/shm/qemu.nic"
+page="/run/shm/index.html"
+address="/run/shm/qemu.ip"
+shutdown="/run/shm/qemu.end"
+socket="/run/shm/qemu-host-api.sock"
+template="/var/www/index.html"
+url="http://localhost/read?command=10"
 
 resp_err="Guest returned an invalid response:"
+curl_err="Failed to connect to guest: curl error"
 jq_err="Failed to parse response from guest: jq error"
 
-while [ ! -f  "$file" ]
+exitIfShuttingDown() {
-do
-
-  # Check if not shutting down
-  [ -f "$shutdown" ] && exit 1
-
-  sleep 3
 
   [ -f "$shutdown" ] && exit 1
-  [ -f "$file" ] && break
 
-  # Retrieve network info from guest VM
+  return 0
-  { json=$(curl -m 20 -sk "$url"); rc=$?; } || :
+}
 
-  [ -f "$shutdown" ] && exit 1
+queryGuest() {
-  (( rc != 0 )) && error "Failed to connect to guest: curl error $rc" && continue
 
-  { result=$(echo "$json" | jq -r '.status'); rc=$?; } || :
+  # Query DSM through the qemu-host sidecar rather than the guest network,
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
+  # which may not be configured yet.
-  [[ "$result" == "null" ]] && error "$resp_err $json" && continue
+  { json=$(curl --unix-socket "$socket" -m 20 -sk "$url"); local rc=$?; } || :
 
-  if [[ "$result" != "success" ]] ; then
+  exitIfShuttingDown
-    { msg=$(echo "$json" | jq -r '.message'); rc=$?; } || :
+
-    error "Guest replied $result: $msg" && continue
+  if (( rc != 0 )); then
+    error "$curl_err $rc"
+    return 1
   fi
 
-  { port=$(echo "$json" | jq -r '.data.data.dsm_setting.data.http_port'); rc=$?; } || :
+  return 0
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
+}
-  [[ "$port" == "null" ]] && error "$resp_err $json" && continue
-  [ -z "$port" ] && continue
 
-  { ip=$(echo "$json" | jq -r '.data.data.ip.data[] | select((.name=="eth0") and has("ip")).ip'); rc=$?; } || :
+readJsonField() {
-  (( rc != 0 )) && error "$jq_err $rc ( $json )" && continue
-  [[ "$ip" == "null" ]] && error "$resp_err $json" && continue
 
-  if [ -z "$ip" ]; then
+  local query="$1"
-    [[ "$DHCP" == [Yy1]* ]] && continue
+  local result
-    ip="20.20.20.21"
+
+  { result=$(jq -r "$query" <<< "$json"); local rc=$?; } || :
+
+  if (( rc != 0 )); then
+    error "$jq_err $rc ( $json )"
+    return 1
   fi
 
-  echo "$ip:$port" > $file
+  if [[ "$result" == "null" ]]; then
+    error "$resp_err $json"
+    return 1
+  fi
 
-done
+  printf '%s\n' "$result"
+  return 0
+}
 
-[ -f "$shutdown" ] && exit 1
+readGuestStatus() {
 
-location=$(cat "$file")
+  local result msg
 
-if [[ "$location" != "20.20"* ]]; then
+  result=$(readJsonField '.status') || return 1
+
+  if [[ "$result" != "success" ]]; then
+    { msg=$(jq -r '.message // empty' <<< "$json"); local rc=$?; } || :
+
+    if (( rc != 0 )); then
+      error "$jq_err $rc ( $json )"
+      return 1
+    fi
+
+    error "Guest replied $result: $msg"
+    return 1
+  fi
+
+  return 0
+}
+
+readGuestPort() {
+
+  port=$(readJsonField '.data.data.dsm_setting.data.http_port') || return 1
+  [ -z "$port" ] && return 1
+
+  return 0
+}
+
+readGuestIp() {
+
+  ip=$(readJsonField '.data.data.ip.data[] | select(.name=="eth0" and has("ip")) | .ip | select(test("^[0-9]+\\."))') || return 1
+  [ -z "$ip" ] && return 1
+
+  return 0
+}
+
+writeDsmLocation() {
+
+  echo "$ip:$port" > "$file"
+
+  return 0
+}
+
+pollGuestLocation() {
+
+  # Keep polling until the guest reports a usable address, but stop promptly
+  # when container shutdown begins.
+  while [ ! -s "$file" ]; do
+
+    # Check if not shutting down
+    exitIfShuttingDown
+
+    sleep 3
+
+    exitIfShuttingDown
+    [ -s "$file" ] && break
+
+    # Retrieve network info from guest VM
+    queryGuest || continue
+    readGuestStatus || continue
+    readGuestPort || continue
+    readGuestIp || continue
+    writeDsmLocation
+
+  done
+
+  return 0
+}
+
+checkAddressConflict() {
+
+  local guest_ip="${location%:*}"
+  local container_ip=""
+
+  [ -s "$address" ] && container_ip=$(<"$address")
+  [ -z "$container_ip" ] && return 0
+  [[ "$guest_ip" != "$container_ip" ]] && return 0
+
+  warn "DSM is using the same IP as the container, this will cause connectivity issues."
+  warn "change the container's macvlan IP or assign DSM a different address in your router."
+
+  return 0
+}
+
+writeDhcpPage() {
+
+  local html
 
   msg="http://$location"
+  local title="<title>Virtual DSM</title>"
+  local body="The location of DSM is <a href='http://$location'>http://$location</a>"
+  local script="<script>setTimeout(function(){ window.location.assign('http://$location'); }, 3000);</script>"
 
-else
+  html=$(<"$template")
+  html="${html/\[1\]/$title}"
+  html="${html/\[2\]/$script}"
+  html="${html/\[3\]/$body}"
+  html="${html/\[4\]/}"
+  html="${html/\[5\]/}"
 
-  ip=$(ip address show dev "$VM_NET_DEV" | grep inet | awk '/inet / { print $2 }' | cut -f1 -d/)
+  echo "$html" > "$page"
-  port="${location##*:}"
+  echo "$body" > "$msgs"
 
-  if [[ "$ip" == "172."* ]]; then
+  return 0
+}
+
+buildStaticMessage() {
+
+  local nic ip
+
+  nic=$(<"$driver")
+  ip=$(<"$address")
+  local port="${location##*:}"
+
+  # NAT and user-mode networking are reached through a forwarded host port;
+  # macvlan exposes DSM directly on the container-facing LAN address.
+  if [[ "${nic,,}" != "macvlan" ]]; then
     msg="port $port"
   else
     msg="http://$ip:$port"
   fi
 
+  return 0
+}
+
+printLoginMessage() {
+
+  echo "" >&2
+  info "-----------------------------------------------------------"
+  info " You can now login to DSM at $msg"
+  info "-----------------------------------------------------------"
+  echo "" >&2
+
+  return 0
+}
+
+pollGuestLocation
+exitIfShuttingDown
+
+location=$(<"$file")
+
+if enabled "$DHCP"; then
+  checkAddressConflict
+  writeDhcpPage
+else
+  buildStaticMessage
 fi
 
-echo "" >&2
+printLoginMessage
-info "-----------------------------------------------------------"
+
-info " You can now login to DSM at $msg"
+exit 0
-info "-----------------------------------------------------------"
-echo "" >&2

src/proc.sh

@@ -0,0 +1,209 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Docker environment variables
+
+: "${HOST_CPU:=""}"
+: "${CPU_FLAGS:=""}"
+: "${CPU_MODEL:=""}"
+
+HOST_CPU=$(strip "$HOST_CPU")
+CPU_FLAGS=$(strip "$CPU_FLAGS")
+CPU_MODEL=$(strip "$CPU_MODEL")
+
+selectClocksource() {
+
+  CLOCKSOURCE="tsc"
+  [[ "${ARCH,,}" == "arm64" ]] && CLOCKSOURCE="arch_sys_counter"
+  CLOCK="/sys/devices/system/clocksource/clocksource0/current_clocksource"
+
+  return 0
+}
+
+checkClocksource() {
+
+  local result
+
+  if [ ! -f "$CLOCK" ]; then
+    warn "file \"$CLOCK\" cannot be found?"
+    return 0
+  fi
+
+  result=$(<"$CLOCK")
+  result="${result//[![:print:]]/}"
+
+  case "${result,,}" in
+    "${CLOCKSOURCE,,}" ) ;;
+    "kvm-clock" ) info "Nested KVM virtualization detected.." ;;
+    "hyperv_clocksource_tsc_page" ) info "Nested Hyper-V virtualization detected.." ;;
+    "hpet" ) warn "unsupported clock source detected: '$result'. Please set host clock source to '$CLOCKSOURCE'." ;;
+    *) warn "unexpected clock source detected: '$result'. Please set host clock source to '$CLOCKSOURCE'." ;;
+  esac
+
+  return 0
+}
+
+checkSse42() {
+
+  if ! hasFlag "sse4_2"; then
+    error "Your CPU does not have the SSE4 instruction set that Virtual DSM requires!"
+    enabled "$DEBUG" || exit 88
+  fi
+
+  return 0
+}
+
+trimSpaces() {
+
+  local value="$1"
+
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  echo "$value"
+  return 0
+}
+
+removeCpuArgument() {
+
+  # CPU configuration has dedicated variables. Remove raw -cpu arguments so
+  # option ordering cannot silently override the validated model and flags.
+  local args=" ${ARGUMENTS:-} "
+
+  while [[ "$args" =~ [[:space:]]-cpu([[:space:]][^[:space:]]+|=[^[:space:]]+)? ]]; do
+    local cpu="${BASH_REMATCH[0]}"
+    args="${args/$cpu/ }"
+    warn "Ignoring '${cpu#" "}' from ARGUMENTS, use CPU_MODEL and CPU_FLAGS instead."
+  done
+
+  ARGUMENTS=$(trimSpaces "$args")
+
+  return 0
+}
+
+configureKvmCpuModel() {
+
+  CPU_FEATURES="kvm=on,l3-cache=on,+hypervisor"
+  KVM_OPTS=",accel=kvm -enable-kvm -global kvm-pit.lost_tick_policy=discard"
+
+  if [ -z "$CPU_MODEL" ]; then
+    CPU_MODEL="host"
+    CPU_FEATURES+=",migratable=no"
+  fi
+
+  return 0
+}
+
+appendKvmInvtscFeature() {
+
+  # invtsc is safe only when the active accelerator can scale the host TSC;
+  # AMD and Intel expose that capability through different host flags.
+  if hasFlag "svm"; then
+
+    # AMD processor
+    if hasFlag "tsc_scale"; then
+      CPU_FEATURES+=",+invtsc"
+    fi
+
+  else
+
+    # Intel processor
+    local vmx
+    vmx=$(sed -ne '/^vmx flags/s/^.*: //p' /proc/cpuinfo)
+
+    if grep -qw "tsc_scaling" <<< "$vmx"; then
+      CPU_FEATURES+=",+invtsc"
+    fi
+
+  fi
+
+  return 0
+}
+
+configureKvm() {
+
+  configureKvmCpuModel
+  checkSse42
+  appendKvmInvtscFeature
+
+  return 0
+}
+
+configureTcgCpuModel() {
+
+  if [ -n "$CPU_MODEL" ]; then
+    return 0
+  fi
+
+  # TCG uses the broad max model on native x86, but qemu64 is the compatible
+  # cross-architecture fallback.
+  if [[ "$ARCH" == "amd64" ]]; then
+    CPU_MODEL="max"
+    CPU_FEATURES+=",migratable=no"
+  else
+    CPU_MODEL="qemu64"
+  fi
+
+  return 0
+}
+
+configureTcg() {
+
+  KVM_OPTS=""
+  CPU_FEATURES="l3-cache=on,+hypervisor"
+
+  if [[ "$ARCH" == "amd64" ]]; then
+    KVM_OPTS=" -accel tcg,thread=multi"
+  fi
+
+  configureTcgCpuModel
+  CPU_FEATURES+=",+ssse3,+sse4.1,+sse4.2"
+
+  return 0
+}
+
+composeCpuFlags() {
+
+  # Compose one -cpu value in precedence order: model, required features,
+  # then user-provided overrides.
+  CPU_FLAGS="${CPU_MODEL}${CPU_FEATURES:+,$CPU_FEATURES}${CPU_FLAGS:+,$CPU_FLAGS}"
+
+  return 0
+}
+
+configureHostCpuName() {
+
+  if [ -z "$HOST_CPU" ]; then
+    [[ "${CPU,,}" != "unknown" ]] && HOST_CPU="$CPU"
+  fi
+
+  if [ -n "$HOST_CPU" ]; then
+    # qemu-host expects a comma-separated CPU description with empty family
+    # and suffix fields, not QEMU's -cpu syntax.
+    HOST_CPU="${HOST_CPU%%,*},,"
+  else
+    HOST_CPU="QEMU, Virtual CPU,"
+    if [ "$ARCH" == "amd64" ]; then
+      HOST_CPU+=" X86_64"
+    else
+      HOST_CPU+=" $ARCH"
+    fi
+  fi
+
+  return 0
+}
+
+selectClocksource
+checkClocksource
+
+if ! disabled "$KVM"; then
+  configureKvm
+else
+  configureTcg
+fi
+
+removeCpuArgument
+composeCpuFlags
+configureHostCpuName
+
+return 0

src/progress.sh

@@ -0,0 +1,310 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+info="/run/shm/msg.html"
+info_tmp="${info}.${BASHPID}.tmp"
+
+escape() {
+
+  local s
+
+  s=${1//&/\&}
+  s=${s//</\&lt;}
+  s=${s//>/\&gt;}
+  s=${s//'"'/\&quot;}
+  s=${s//"'"/\&#39;}
+
+  printf '%s' "$s"
+  return 0
+}
+
+writeInfo() {
+
+  local content="$1"
+
+  # Replace the web status atomically so websocket readers never observe a
+  # partially written HTML fragment.
+  if ! printf '%s\n' "$content" > "$info_tmp"; then
+    rm -f -- "$info_tmp"
+    return 1
+  fi
+
+  if ! mv -f -- "$info_tmp" "$info"; then
+    rm -f -- "$info_tmp"
+    return 1
+  fi
+
+  return 0
+}
+
+getBytes() {
+
+  local path="$1"
+  local mode="$2"
+  local bytes="0"
+
+  if [[ "$mode" == "counter" ]]; then
+    if [ -r "$path" ]; then
+      read -r bytes < "$path" || bytes="0"
+    fi
+
+    [[ "$bytes" =~ ^[0-9]+$ ]] || bytes="0"
+    printf '%s\n' "$bytes"
+    return 0
+  fi
+
+  if [ ! -s "$path" ] && [ ! -d "$path" ]; then
+    printf '0\n'
+    return 0
+  fi
+
+  if [[ "$mode" == "allocated" ]]; then
+    bytes=$(du -sB1 -- "$path" 2>/dev/null | cut -f1) || bytes="0"
+  else
+    bytes=$(du -sb -- "$path" 2>/dev/null | cut -f1) || bytes="0"
+  fi
+
+  printf '%s\n' "$bytes"
+  return 0
+}
+
+getStatus() {
+
+  local file="$1"
+  local bytes total extra=""
+
+  [ -r "$file" ] || return 1
+  read -r bytes total extra < "$file" || return 1
+
+  if [[ ! "$bytes" =~ ^[0-9]+$ ||
+        ! "$total" =~ ^[0-9]+$ ||
+        -n "$extra" ]]; then
+    return 1
+  fi
+
+  printf '%s %s\n' "$bytes" "$total"
+  return 0
+}
+
+formatSize() {
+
+  local bytes="$1"
+  local size
+
+  size=$(numfmt --to=iec --suffix=B "$bytes" |
+    sed -r 's/([A-Z])/ \1/') ||
+    size="${bytes} bytes"
+
+  printf '%s' "$size"
+  return 0
+}
+
+printPercentProgress() {
+
+  local percent="$1"
+
+  while (( next_percent <= percent && next_percent <= 100 )); do
+    if [[ "$printed" == "Y" ]]; then
+      printf ' → %s%%' "$next_percent"
+    else
+      printf '%s%%' "$next_percent"
+    fi
+
+    printed="Y"
+    next_percent=$((next_percent + 10))
+  done
+
+  return 0
+}
+
+printCurrentSize() {
+
+  local bytes="$1"
+  local size
+
+  size=$(formatSize "$bytes")
+
+  if [[ "$printed" == "Y" ]]; then
+    printf ' → %s' "$size"
+  else
+    printf '%s' "$size"
+  fi
+
+  printed="Y"
+  return 0
+}
+
+printSizeProgress() {
+
+  local bytes="$1"
+  local size
+
+  while (( bytes >= next_bytes )); do
+    size=$(formatSize "$next_bytes")
+
+    if [[ "$printed" == "Y" ]]; then
+      printf ' → %s' "$size"
+    else
+      printf '%s' "$size"
+    fi
+
+    printed="Y"
+    next_bytes=$((next_bytes + step_bytes))
+  done
+
+  return 0
+}
+
+stopProgress() {
+
+  if [ -z "$status_file" ]; then
+    exit 0
+  fi
+
+  stopping="Y"
+  return 0
+}
+
+finishProgress() {
+
+  rm -f -- "$info_tmp"
+
+  if [[ "$output" == "log" && "$printed" == "Y" ]]; then
+    printf '\n'
+  fi
+
+  return 0
+}
+
+path="$1"
+total="$2"
+body=$(escape "$3")
+output="${4:-}"
+step_bytes="${5:-536870912}"
+mode="${6:-apparent}"
+status_file="${7:-}"
+
+if [[ -n "$total" && ! "$total" =~ ^(0|[1-9][0-9]*)$ ]]; then
+  printf 'Invalid total size: %s\n' "$total" >&2
+  exit 2
+fi
+
+if [[ ! "$step_bytes" =~ ^[1-9][0-9]*$ ]]; then
+  printf 'Invalid progress interval: %s\n' "$step_bytes" >&2
+  exit 2
+fi
+
+case "$mode" in
+  apparent | allocated | counter ) ;;
+  * )
+    printf 'Invalid progress mode: %s\n' "$mode" >&2
+    exit 2
+    ;;
+esac
+
+case "$output" in
+  "" | log ) ;;
+  * )
+    printf 'Invalid progress output: %s\n' "$output" >&2
+    exit 2
+    ;;
+esac
+
+printed="N"
+next_percent=10
+next_bytes="$step_bytes"
+log_mode="percent"
+stopping="N"
+
+if [ -z "$total" ] || [[ "$total" == "0" ]]; then
+  log_mode="size"
+fi
+
+trap finishProgress EXIT
+trap 'exit 0' HUP INT QUIT
+# SIGTERM requests one final measurement and web update rather than
+# terminating between progress samples.
+trap stopProgress TERM
+
+if [[ "$body" == *"..." ]]; then
+  body="<p class=\"loading\">${body::-3}</p>"
+fi
+
+while true; do
+
+  final_pass="${stopping:-}"
+  bytes=$(getBytes "$path" "$mode")
+  effective_total="$total"
+
+  # An external downloader may provide authoritative completed and total byte
+  # counters; use them instead of filesystem size when available.
+  if [ -n "$status_file" ] && status=$(getStatus "$status_file"); then
+    read -r status_bytes status_total <<< "$status"
+    bytes="$status_bytes"
+
+    if (( status_total > 0 )); then
+      effective_total="$status_total"
+    fi
+  fi
+
+  # A real total may become available shortly after aria2 starts.
+  if [[ "$log_mode" == "size" &&
+        "$printed" == "N" &&
+        -n "$effective_total" &&
+        "$effective_total" != "0" ]]; then
+    log_mode="percent"
+  fi
+
+  if (( bytes > 4096 )); then
+
+    write_html="Y"
+
+    if [ -z "$effective_total" ] ||
+        [[ "$effective_total" == "0" ]] ||
+        (( bytes > effective_total )); then
+      size=$(formatSize "$bytes")
+
+      if [[ "$output" == "log" ]]; then
+        if [[ "$log_mode" == "percent" ]]; then
+          printCurrentSize "$bytes"
+          next_bytes=$(((bytes / step_bytes + 1) * step_bytes))
+          log_mode="size"
+        else
+          printSizeProgress "$bytes"
+        fi
+      fi
+    else
+      # Floor the percentage rather than rounding so displayed completion
+      # never gets ahead of bytes actually written.
+      # Truncate to one decimal so progress is never reported early.
+      progress=$((bytes * 1000 / effective_total))
+      (( progress > 1000 )) && progress=1000
+
+      percent=$((progress / 10))
+
+      printf -v size '%d.%d%%' \
+        "$((progress / 10))" \
+        "$((progress % 10))"
+
+      if [[ "$output" == "log" ]]; then
+        if [[ "$log_mode" == "size" ]]; then
+          printSizeProgress "$bytes"
+        else
+          printPercentProgress "$percent"
+        fi
+      fi
+
+      # Do not update the web viewer until at least 0.1% is reached.
+      (( progress == 0 )) && write_html="N"
+    fi
+
+    if [[ "$write_html" == "Y" ]]; then
+      writeInfo "${body//(\[P\])/($size)}"
+    fi
+  fi
+
+  [[ "$final_pass" == "Y" ]] && break
+
+  sleep 1 &
+  wait $! || :
+done

src/reset.sh

@@ -1,115 +0,0 @@
-#!/usr/bin/env bash
-set -Eeuo pipefail
-
-info () { printf "%b%s%b" "\E[1;34m❯ \E[1;36m" "$1" "\E[0m\n"; }
-error () { printf "%b%s%b" "\E[1;31m❯ " "ERROR: $1" "\E[0m\n" >&2; }
-
-trap 'error "Status $? while: $BASH_COMMAND (line $LINENO/$BASH_LINENO)"' ERR
-
-[ ! -f "/run/entry.sh" ] && error "Script must run inside Docker container!" && exit 11
-[ "$(id -u)" -ne "0" ] && error "Script must be executed with root privileges." && exit 12
-
-# Docker environment variables
-
-: ${TZ:=''}             # System local timezone
-: ${GPU:='N'}           # Disable GPU passthrough
-: ${KVM:='Y'}           # Enable KVM acceleration
-: ${DEBUG:='N'}         # Disable debugging mode
-: ${COUNTRY:=''}        # Country code for mirror
-: ${CONSOLE:='N'}       # Disable console mode
-: ${ALLOCATE:='Y'}      # Preallocate diskspace
-: ${ARGUMENTS:=''}      # Extra QEMU parameters
-: ${CPU_CORES:='1'}     # Amount of CPU cores
-: ${RAM_SIZE:='1G'}     # Maximum RAM amount
-: ${DISK_SIZE:='16G'}   # Initial data disk size
-
-# Helper variables
-
-KERNEL=$(uname -r | cut -b 1)
-MINOR=$(uname -r | cut -d '.' -f2)
-ARCH=$(dpkg --print-architecture)
-VERS=$(qemu-system-x86_64 --version | head -n 1 | cut -d '(' -f 1)
-
-# Check folder
-
-STORAGE="/storage"
-[ ! -d "$STORAGE" ] && error "Storage folder ($STORAGE) not found!" && exit 13
-
-# Cleanup files
-
-rm -f /run/dsm.url
-rm -f /run/qemu.pid
-rm -f /run/qemu.count
-
-# Cleanup dirs
-
-rm -rf /tmp/dsm
-rm -f /tmp/server.*
-rm -rf "$STORAGE/tmp"
-
-# Helper functions
-
-getCountry () {
-
-  local url=$1
-  local query=$2
-  local rc json result
-
-  { json=$(curl -m 5 -H "Accept: application/json" -sfk "$url"); rc=$?; } || :
-  (( rc != 0 )) && return 0
-
-  { result=$(echo "$json" | jq -r "$query" 2> /dev/null); rc=$?; } || :
-  (( rc != 0 )) && return 0
-
-  [[ ${#result} -ne 2 ]] && return 0
-  [[ "${result^^}" == "XX" ]] && return 0
-
-  COUNTRY="${result^^}"
-
-  return 0
-}
-
-setCountry () {
-
-  [[ "${TZ,,}" == "asia/harbin" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/beijing" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/urumqi" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/kashgar" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/shanghai" ]] && COUNTRY="CN"
-  [[ "${TZ,,}" == "asia/chongqing" ]] && COUNTRY="CN"
-
-  [ -z "$COUNTRY" ] && getCountry "https://api.ipapi.is" ".location.country_code"
-  [ -z "$COUNTRY" ] && getCountry "https://ifconfig.co/json" ".country_iso"
-  [ -z "$COUNTRY" ] && getCountry "https://ipinfo.io/json" ".country"
-  [ -z "$COUNTRY" ] && getCountry "https://api.myip.com" ".cc"
-
-  return 0
-}
-
-addPackage () {
-
-  local pkg=$1
-  local desc=$2
-
-  if apt-mark showinstall | grep -qx "$pkg"; then
-    return 0
-  fi
-
-  info "Installing $desc..."
-
-  export DEBCONF_NOWARNINGS="yes"
-  export DEBIAN_FRONTEND="noninteractive"
-
-  [ -z "$COUNTRY" ] && setCountry
-
-  if [[ "${COUNTRY^^}" == "CN" ]]; then
-    sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
-  fi
-
-  apt-get -qq update
-  apt-get -qq --no-install-recommends -y install "$pkg" > /dev/null
-
-  return 0
-}
-
-return 0

src/serial.sh

@@ -3,55 +3,151 @@ set -Eeuo pipefail
 
 # Docker environment variables
 
-: ${HOST_MAC:=''}
+: "${HOST_MAC:=""}"
-: ${HOST_DEBUG:=''}
+: "${HOST_DEBUG:=""}"
-: ${HOST_SERIAL:=''}
+: "${HOST_MODEL:=""}"
-: ${HOST_MODEL:=''}
+: "${HOST_SERIAL:=""}"
-: ${GUEST_SERIAL:=''}
+: "${GUEST_SERIAL:=""}"
 
-HOST_ARGS=()
+# Sanitize variables
-HOST_ARGS+=("-cpu=$CPU_CORES")
+HOST_MAC=$(strip "$HOST_MAC")
-HOST_ARGS+=("-cpu_arch=$HOST_CPU")
+HOST_MODEL=$(strip "$HOST_MODEL")
+HOST_SERIAL=$(strip "$HOST_SERIAL")
+GUEST_SERIAL=$(strip "$GUEST_SERIAL")
 
-[ -n "$HOST_MAC" ] && HOST_ARGS+=("-mac=$HOST_MAC")
+HOST_PID="$QEMU_DIR/host.pid"
-[ -n "$HOST_MODEL" ] && HOST_ARGS+=("-model=$HOST_MODEL")
+HOST_API_SOCKET="$QEMU_DIR/qemu-host-api.sock"
-[ -n "$HOST_SERIAL" ] && HOST_ARGS+=("-hostsn=$HOST_SERIAL")
+HOST_AGENT_SOCKET="$QEMU_DIR/qemu-host-agent.sock"
-[ -n "$GUEST_SERIAL" ] && HOST_ARGS+=("-guestsn=$GUEST_SERIAL")
 
-if [[ "$HOST_DEBUG" == [Yy1]* ]]; then
+validateHostMac() {
-  set -x
+  local m
-  ./host.bin "${HOST_ARGS[@]}" &
-  { set +x; } 2>/dev/null
-  echo
-else
-  ./host.bin "${HOST_ARGS[@]}" >/dev/null &
-fi
 
-cnt=0
+  if [ -z "$HOST_MAC" ]; then
-sleep 0.2
+    return 0
+  fi
 
-while ! nc -z -w2 127.0.0.1 2210 > /dev/null 2>&1; do
+  HOST_MAC="${HOST_MAC//-/:}"
-  sleep 0.1
-  cnt=$((cnt + 1))
-  (( cnt > 50 )) && error "Failed to connect to qemu-host.." && exit 58
-done
 
-cnt=0
+  if [[ ${#HOST_MAC} == 12 ]]; then
+    m="$HOST_MAC"
+    HOST_MAC="${m:0:2}:${m:2:2}:${m:4:2}:${m:6:2}:${m:8:2}:${m:10:2}"
+  fi
 
-while ! nc -z -w2 127.0.0.1 12345 > /dev/null 2>&1; do
+  if [[ ${#HOST_MAC} != 17 ]]; then
-  sleep 0.1
+    error "Invalid HOST_MAC address: '$HOST_MAC', should be 12 or 17 digits long!" && exit 28
-  cnt=$((cnt + 1))
+  fi
-  (( cnt > 50 )) && error "Failed to connect to qemu-host.." && exit 59
-done
 
-# Configure serial ports
+  return 0
+}
 
-SERIAL_OPTS="\
+buildHostArguments() {
-        -serial mon:stdio \
+
-        -device virtio-serial-pci,id=virtio-serial0,bus=pcie.0,addr=0x3 \
+  # qemu-host is a sidecar that bridges DSM's proprietary serial agent to
-        -chardev pty,id=charserial0 \
+  # Unix sockets used by shutdown and post-boot discovery helpers.
-        -device isa-serial,chardev=charserial0,id=serial0 \
+  HOST_ARGS=()
-        -chardev socket,id=charchannel0,host=127.0.0.1,port=12345,reconnect=10 \
+  HOST_ARGS+=("-cpu=$CPU_CORES")
+  HOST_ARGS+=("-cpu_arch=$HOST_CPU")
+  HOST_ARGS+=("-api=$HOST_API_SOCKET")
+  HOST_ARGS+=("-addr=$HOST_AGENT_SOCKET")
+
+  [ -n "$HOST_MAC" ] && HOST_ARGS+=("-mac=$HOST_MAC")
+  [ -n "$HOST_MODEL" ] && HOST_ARGS+=("-model=$HOST_MODEL")
+  [ -n "$HOST_SERIAL" ] && HOST_ARGS+=("-hostsn=$HOST_SERIAL")
+  [ -n "$GUEST_SERIAL" ] && HOST_ARGS+=("-guestsn=$GUEST_SERIAL")
+
+  return 0
+}
+
+startHostBinary() {
+
+  local pid
+
+  # Remove stale sockets and pid state before starting the sidecar; a Unix
+  # socket path cannot be rebound while an old filesystem entry remains.
+  rm -f -- "$HOST_PID" "$HOST_API_SOCKET" "$HOST_AGENT_SOCKET" || return 1
+
+  if enabled "$HOST_DEBUG"; then
+    set -x
+    ./host.bin "${HOST_ARGS[@]}" &
+    { set +x; } 2>/dev/null
+    pid=$!
+    echo
+  else
+    ./host.bin "${HOST_ARGS[@]}" >/dev/null &
+    pid=$!
+  fi
+
+  printf '%s\n' "$pid" > "$HOST_PID"
+
+  return 0
+}
+
+waitForSocket() {
+
+  local socket="$1"
+  local exit_code="$2"
+  local timeout=5 pid
+  local deadline=$((SECONDS + timeout))
+
+  # Do not start QEMU until both sidecar sockets are ready; otherwise the
+  # VirtIO serial channel or API client may race initial creation.
+  while [ ! -S "$socket" ]; do
+
+    if ! readPidFile pid "$HOST_PID" || ! isAlive "$pid"; then
+      error "qemu-host exited unexpectedly!"
+      exit "$exit_code"
+    fi
+
+    if (( SECONDS >= deadline )); then
+      error "Failed to create qemu-host socket: $socket"
+      exit "$exit_code"
+    fi
+
+    sleep 0.1
+  done
+
+  return 0
+}
+
+configureSerialPorts() {
+
+  local bus
+  bus=$(getPciBus)
+
+  # Managed interactive mode separates the console and QEMU monitor into
+  # reconnecting sockets; other runs keep the simple combined stdio monitor.
+  if enabled "${SHUTDOWN:-Y}" && interactive; then
+
+    CONSOLE_SOCKET="$QEMU_DIR/console.sock"
+    MONITOR_SOCKET="$QEMU_DIR/monitor.sock"
+
+    SERIAL_OPTS="-chardev socket,id=console0,path=$CONSOLE_SOCKET,reconnect-ms=1000 \
+          -serial chardev:console0 \
+          -chardev socket,id=monitor0,path=$MONITOR_SOCKET,server=on,wait=off \
+          -mon chardev=monitor0,mode=readline"
+
+  else
+
+    SERIAL_OPTS="-serial mon:stdio"
+
+  fi
+
+  SERIAL_OPTS+=" \
+        -device virtio-serial-pci,id=virtio-serial0,bus=$bus,addr=0x3 \
+        -chardev socket,id=charchannel0,path=$HOST_AGENT_SOCKET,reconnect-ms=1000 \
         -device virtserialport,bus=virtio-serial0.0,nr=1,chardev=charchannel0,id=channel0,name=vchannel"
 
+  return 0
+}
+
+validateHostMac
+
+buildHostArguments
+startHostBinary
+
+waitForSocket "$HOST_API_SOCKET" 58
+waitForSocket "$HOST_AGENT_SOCKET" 59
+
+configureSerialPorts
+
 return 0

src/server.sh

@@ -1,66 +1,185 @@
 #!/usr/bin/env bash
-set -eu
+set -Eeuo pipefail
 
-TMP_FILE=$(mktemp -q /tmp/server.XXXXXX)
+: "${WEB_PORT:="5000"}"    # Webserver port
 
-stop() {
+# Sanitize port variables
-  trap - SIGINT EXIT
+WEB_PORT=$(strip "$WEB_PORT")
-  { pkill -f socat || true; } 2>/dev/null
+
-  [ -f "$TMP_FILE" ] && rm -f "$TMP_FILE"
+WEB_PID="/run/nginx.pid"
+WSD_LOG="/var/log/websocketd.log"
+WSD_PID="$QEMU_DIR/websocketd.pid"
+WSD_SOCKET="$QEMU_DIR/status-ws.sock"
+
+prepareWebFiles() {
+
+  cp -r /var/www/* "$QEMU_DIR" || return 1
+  rm -f -- "$WSD_PID" "$WSD_SOCKET" "$WEB_PID" "$WSD_LOG" || return 1
+
+  return 0
 }
 
-trap 'stop' EXIT SIGINT SIGTERM SIGHUP
+configureWebPorts() {
 
-html()
+  if ! sed -i \
-{
+    -e "s|listen 5000 default_server;|listen $WEB_PORT default_server;|g" \
-    local h="<!DOCTYPE html><HTML><HEAD><TITLE>VirtualDSM</TITLE>"
+    /etc/nginx/sites-enabled/web.conf; then
-    h="$h<STYLE>body { color: white; background-color: #125bdb; font-family: Verdana,"
+    error "Failed to configure webserver port!"
-    h="$h Arial,sans-serif; } a, a:hover, a:active, a:visited { color: white; }</STYLE></HEAD>"
+    return 1
-    h="$h<BODY><BR><BR><H1><CENTER>$1</CENTER></H1></BODY></HTML>"
-
-    echo "$h"
-}
-
-if [[ "$2" != "/"* ]]; then
-
-  BODY="$2"
-
-  if [[ "$BODY" == "install" ]]; then
-    BODY="Please wait while Virtual DSM is being installed..."
-    BODY="$BODY<script>setTimeout(() => { document.location.reload(); }, 9999);</script>"
   fi
 
-  HTML=$(html "$BODY")
+  return 0
-  printf '%b' "HTTP/1.1 200 OK\nContent-Length: ${#HTML}\nConnection: close\n\n$HTML" > "$TMP_FILE"
+}
 
-  socat TCP4-LISTEN:80,reuseaddr,fork,crlf SYSTEM:"cat $TMP_FILE" 2> /dev/null &
+configureIpv6Listen() {
-  socat TCP4-LISTEN:"${1:-5000}",reuseaddr,fork,crlf SYSTEM:"cat $TMP_FILE" 2> /dev/null & wait $!
 
-  exit
+  # Use one dual-stack listener when IPv6 is active, avoiding separate IPv4
+  # and IPv6 sockets that can conflict on the same port.
+  if [ -f /proc/net/if_inet6 ] && [[ "$(cat /proc/sys/net/ipv6/conf/all/disable_ipv6 2>/dev/null)" != "1" ]]; then
 
+    if ! sed -i \
+      "s/listen $WEB_PORT default_server;/listen [::]:$WEB_PORT default_server ipv6only=off;/g" \
+      /etc/nginx/sites-enabled/web.conf; then
+      error "Failed to configure IPv6 webserver listener!"
+      return 1
+    fi
+
+  fi
+
+  return 0
+}
+
+configureNginx() {
+
+  mkdir -p /etc/nginx/sites-enabled || return 1
+  rm -f /etc/nginx/sites-enabled/default || return 1
+
+  # TODO: Use setfacl to grant www-data access to the Unix sockets
+  # and restore unprivileged nginx workers.
+  if ! sed -i \
+    -e 's/^user .*/user root;/' \
+    -e 's/^worker_processes.*/worker_processes 1;/' \
+    /etc/nginx/nginx.conf; then
+    error "Failed to configure nginx!"
+    return 1
+  fi
+
+  if ! cp /etc/nginx/default.conf /etc/nginx/sites-enabled/web.conf; then
+    error "Failed to copy nginx config!"
+    return 1
+  fi
+
+  return 0
+}
+
+configureWebServer() {
+
+  configureNginx || return 1
+  configureWebPorts || return 1
+  configureIpv6Listen || return 1
+
+  return 0
+}
+
+stopWebServer() {
+
+  local pid
+
+  if readPidFile pid "$WEB_PID"; then
+    pKill "$pid" 2
+
+    # Escalate only after the normal termination grace period; stale nginx
+    # processes would otherwise keep the configured web port occupied.
+    if isAlive "$pid"; then
+      kill -9 -- "$pid" 2>/dev/null || :
+    fi
+  fi
+
+  rm -f -- "$WEB_PID"
+  return 0
+}
+
+startWebServer() {
+
+  # Start webserver
+  nginx -e stderr || return 1
+
+  return 0
+}
+
+stopWebsocketServer() {
+
+  local pid
+
+  if readPidFile pid "$WSD_PID"; then
+    pKill "$pid" 2
+
+    if isAlive "$pid"; then
+      kill -9 -- "$pid" 2>/dev/null || :
+    fi
+  fi
+
+  rm -f -- "$WSD_PID" "$WSD_SOCKET"
+  return 0
+}
+
+startWebsocketServer() {
+
+  # Start websocket server
+  websocketd \
+    --unixsocket="$WSD_SOCKET" \
+    /run/socket.sh \
+    >"$WSD_LOG" 2>&1 &
+
+  local pid=$!
+
+  if ! echo "$pid" > "$WSD_PID"; then
+    kill "$pid" 2>/dev/null || :
+    rm -f -- "$WSD_PID"
+    return 1
+  fi
+
+  local i
+  for (( i = 1; i <= 50; i++ )); do
+
+    if ! isAlive "$pid"; then
+      rm -f -- "$WSD_PID" "$WSD_SOCKET"
+      [ -s "$WSD_LOG" ] && cat "$WSD_LOG" >&2
+      error "Failed to start websocket server!"
+      return 1
+    fi
+
+    [ -S "$WSD_SOCKET" ] && return 0
+
+    sleep 0.1
+
+  done
+
+  pKill "$pid" 2
+
+  if isAlive "$pid"; then
+    kill -9 -- "$pid" 2>/dev/null || :
+  fi
+
+  rm -f -- "$WSD_PID" "$WSD_SOCKET"
+  [ -s "$WSD_LOG" ] && cat "$WSD_LOG" >&2
+  error "Websocket server did not create its socket!"
+  return 1
+}
+
+prepareWebFiles
+
+html "Starting $APP for $ENGINE..."
+
+disabled "${WEB:-}" && return 0
+
+configureWebServer
+
+if startWebServer && startWebsocketServer; then
+  return 0
 fi
 
-if [[ "$2" != "/run/ip.sh" ]]; then
+stopWebsocketServer || :
+stopWebServer || :
 
-  cp "$2" "$TMP_FILE"
+return 1
-
-else
-
-  BODY="The location of DSM is <a href='http://\$LOCATION'>http://\$LOCATION</a><script>"
-  BODY="$BODY setTimeout(function(){ window.location.assign('http://\$LOCATION'); }, 3000);</script>"
-  WAIT="Please wait while discovering IP...<script>setTimeout(() => { document.location.reload(); }, 4999);</script>"
-
-  HTML=$(html "xxx")
-
-  { echo "#!/bin/bash"
-    echo "[ -f \"/run/dsm.url\" ] && LOCATION=\$(cat \"/run/dsm.url\")"
-    echo "HTML=\"$HTML\"; [ -z \"\$LOCATION\" ] && BODY=\"$WAIT\" || BODY=\"$BODY\"; HTML=\${HTML/xxx/\$BODY}"
-    echo "printf '%b' \"HTTP/1.1 200 OK\\nContent-Length: \${#HTML}\\nConnection: close\\n\\n\$HTML\""
-  } > "$TMP_FILE"
-
-fi
-
-chmod +x "$TMP_FILE"
-  
-socat TCP4-LISTEN:80,reuseaddr,fork,crlf SYSTEM:"$TMP_FILE" 2> /dev/null &
-socat TCP4-LISTEN:"${1:-5000}",reuseaddr,fork,crlf SYSTEM:"$TMP_FILE" 2> /dev/null & wait $!

src/socket.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+lastmsg=""
+path="/run/shm/msg.html"
+dir=$(dirname -- "$path")
+name=$(basename -- "$path")
+
+refresh() {
+
+  [ ! -f "$path" ] && return 0
+  [ ! -s "$path" ] && return 0
+
+  msg=$(< "$path") || return 0
+  msg="${msg%$'\n'}"
+
+  [ -z "$msg" ] && return 0
+  [[ "$msg" == "$lastmsg" ]] && return 0
+
+  lastmsg="$msg"
+  # websocketd clients interpret s: as a status update and c: as a command;
+  # suppress unchanged status to avoid redundant browser work.
+  echo "s: $msg"
+
+  return 0
+}
+
+refresh
+
+inotifywait \
+  -m -q \
+  -e close_write,moved_to,delete \
+  --format '%e %f' \
+  "$dir" |
+  while read -r event file; do
+
+    [[ "$file" == "$name" ]] || continue
+
+    case "${event,,}" in
+      "delete"* )
+        echo "c: vnc" ;;
+      # moved_to covers the atomic replacement used by html()/writeAtomic(),
+      # while close_write handles direct writers.
+      "close_write"* | "moved_to"* )
+        refresh ;;
+    esac
+
+  done

src/start.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# You can override this hook to execute a script before startup!
+
+return 0

src/utils.sh

@@ -0,0 +1,646 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Helper functions
+
+info () { printf "%b%s%b" "\E[1;34m❯ \E[1;36m" "${1:-}" "\E[0m\n"; }
+error () { printf "%b%s%b" "\E[1;31m❯ " "ERROR: ${1:-}" "\E[0m\n" >&2; }
+warn () { printf "%b%s%b" "\E[1;31m❯ " "Warning: ${1:-}" "\E[0m\n" >&2; }
+
+app() {
+
+  echo "Virtual DSM"
+  return 0
+}
+
+readPidFile() {
+
+  local -n _pid="$1"
+  _pid=""
+
+  if ! _pid=$(cat -- "$2" 2>/dev/null); then
+    _pid=""
+    return 1
+  fi
+
+  # Reject empty, zero, or nonnumeric pidfiles so cleanup can never signal an
+  # unintended process group.
+  if [[ ! "$_pid" =~ ^[1-9][0-9]*$ ]]; then
+    _pid=""
+    return 1
+  fi
+
+  return 0
+}
+
+hasFlag() {
+
+  # Match a whitespace-delimited token in /proc/cpuinfo
+  grep -m1 '^flags[[:space:]]*:' /proc/cpuinfo | grep -Fqw -- "$1"
+
+}
+
+hasFeature() {
+
+  # Match a whitespace-delimited token in /proc/cpuinfo
+  grep -m1 '^Features[[:space:]]*:' /proc/cpuinfo | grep -Fqw -- "$1"
+
+}
+
+isAmdCpu() {
+
+  local vendor
+  vendor=$(awk -F ': *' '/^vendor_id/{print $2; exit}' /proc/cpuinfo)
+
+  [[ "$vendor" == "AuthenticAMD" ]]
+}
+
+getPciBus() {
+
+  local machine="${1:-${MACHINE:-q35}}"
+
+  if [ -n "${PCI_BUS:-}" ]; then
+    echo "$PCI_BUS"
+    return 0
+  fi
+
+  case "${machine,,}" in
+    pc|pc-i440fx*) echo "pci.0" ;;
+    *)             echo "pcie.0" ;;
+  esac
+
+  return 0
+}
+
+interactive() {
+
+  # A TTY on stdin is insufficient when /dev/tty is unavailable; require both
+  # before enabling interactive console handling.
+  [ -t 0 ] && : 2>/dev/null </dev/tty >/dev/tty
+
+}
+
+strip() {
+
+  local value="${1:-}"
+
+  # Remove surrounding whitespace
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  # Remove leading/trailing single/double quotes
+  value="${value%\"}"
+  value="${value#\"}"
+  value="${value%\'}"
+  value="${value#\'}"
+
+  # Remove surrounding whitespace again
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  printf '%s' "$value"
+}
+
+enabled() {
+
+  local value
+  value=$(strip "${1:-}")
+
+  case "${value,,}" in
+    y|yes|true|1|on|enable|enabled) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+disabled() {
+
+  local value
+  value=$(strip "${1:-}")
+
+  case "${value,,}" in
+    n|no|none|false|0|off|disable|disabled) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+formatBytes() {
+
+  local result
+
+  if ! result=$(numfmt --to=iec --suffix=B "$1" | sed -r 's/([A-Z])/ \1/' | sed 's/ B/ bytes/g;'); then
+    return 1
+  fi
+
+  local unit="${result//[0-9. ]}"
+  result="${result//[a-zA-Z ]/}"
+
+  if [[ "${2:-}" == "up" ]]; then
+    if [[ "$result" == *"."* ]]; then
+      result="${result%%.*}"
+      result=$((result+1))
+    fi
+  else
+    if [[ "${2:-}" == "down" ]]; then
+      result="${result%%.*}"
+    fi
+  fi
+
+  echo "$result $unit"
+  return 0
+}
+
+isAlive() {
+
+  local pid="$1"
+  [ -z "$pid" ] && return 1
+
+  if kill -0 "$pid" 2>/dev/null; then
+    return 0
+  fi
+
+  return 1
+}
+
+waitPid() {
+
+  local pid="$1"
+  local timeout="${2:-10}"
+  local deadline=$((SECONDS + timeout))
+
+  while [ -n "$pid" ] && isAlive "$pid"; do
+    (( SECONDS >= deadline )) && return 1
+    sleep 0.2
+  done
+
+  return 0
+}
+
+waitPidFile() {
+
+  local pid
+  local file="$1"
+  local timeout="${2:-10}"
+  local deadline=$((SECONDS + timeout))
+
+  readPidFile pid "$file" || return 0
+
+  while [ -s "$file" ] && isAlive "$pid"; do
+    (( SECONDS >= deadline )) && return 1
+    sleep 0.2
+  done
+
+  rm -f -- "$file"
+  return 0
+}
+
+pKill() {
+
+  local pid="$1"
+  local timeout="${2:-10}"
+
+  { kill -15 -- "$pid" || :; } 2>/dev/null
+
+  if ! waitPid "$pid" "$timeout"; then
+    warn "Timed out while waiting for PID $pid"
+  fi
+
+  return 0
+}
+
+fWait() {
+
+  local name="$1"
+  local timeout="${2:-10}"
+  local deadline=$((SECONDS + timeout))
+
+  [ -z "$name" ] && return 0
+
+  while pgrep -f -l "$name" >/dev/null; do
+    if (( SECONDS >= deadline )); then
+      warn "Timed out while waiting for process: $name"
+      break
+    fi
+
+    sleep 0.2
+  done
+
+  return 0
+}
+
+fKill() {
+
+  local name="$1"
+  local timeout="${2:-10}"
+
+  [ -z "$name" ] && return 0
+
+  { pkill -f "$name" || :; } 2>/dev/null
+  fWait "$name" "$timeout"
+
+  return 0
+}
+
+sKill() {
+
+  local pid
+  local file="$1"
+
+  readPidFile pid "$file" || return 0
+
+  if isAlive "$pid"; then
+    { kill -15 -- "$pid" || :; } 2>/dev/null
+  fi
+
+  return 0
+}
+
+mKill() {
+
+  local timeout=10
+  local files=("$@")
+
+  for file in "${files[@]}"; do
+    sKill "$file"
+  done
+
+  for file in "${files[@]}"; do
+    if ! waitPidFile "$file" "$timeout"; then
+      warn "Timed out while waiting for PID file: $file"
+    fi
+  done
+
+  return 0
+}
+
+setOwner() {
+
+  local file="$1"
+  local dir uid gid
+
+  [ ! -f "$file" ] && return 1
+
+  # Match generated files to the owner of their bind-mounted parent directory
+  # instead of assuming a fixed container or host UID.
+  dir=$(dirname -- "$file")
+  uid=$(stat -c '%u' "$dir") || return 1
+  gid=$(stat -c '%g' "$dir") || return 1
+
+  chown "$uid:$gid" "$file" || return 1
+
+  return 0
+}
+
+makeDir() {
+
+  local path="$1"
+  local dir uid gid
+
+  [ -d "$path" ] && return 0
+  mkdir -p "$path" || return 1
+
+  dir=$(dirname -- "$path")
+
+  if ! uid=$(stat -c '%u' "$dir") || ! gid=$(stat -c '%g' "$dir"); then
+    warn "failed to determine the owner for \"$path\"."
+    return 0
+  fi
+
+  if ! chown "$uid:$gid" "$path"; then
+    warn "failed to set the owner for \"$path\"."
+    return 0
+  fi
+
+  return 0
+}
+
+finiteMemoryLimit() {
+
+  local limit="$1"
+  # cgroup v1 commonly reports this enormous sentinel for an unlimited memory
+  # limit; compare as decimal strings to avoid shell integer overflow.
+  local sentinel="4611686018427387904"
+  local i
+
+  [[ "$limit" =~ ^[0-9]+$ ]] || return 1
+
+  (( ${#limit} < ${#sentinel} )) && return 0
+  (( ${#limit} > ${#sentinel} )) && return 1
+
+  for (( i=0; i<${#sentinel}; i++ )); do
+    local left="${limit:i:1}"
+    local right="${sentinel:i:1}"
+
+    (( left < right )) && return 0
+    (( left > right )) && return 1
+  done
+
+  return 1
+}
+
+getMemoryInfo() {
+
+  local host_total
+  local host_avail
+  local limit=""
+  local current=""
+
+  host_total=$(free -b | awk '/^Mem:/ {print $2; exit}')
+  host_avail=$(free -b | awk '/^Mem:/ {print $7; exit}')
+
+  RAM_TOTAL="$host_total"
+  RAM_AVAIL="$host_avail"
+
+  if [ -r /sys/fs/cgroup/memory.max ] && [ -r /sys/fs/cgroup/memory.current ]; then
+    limit=$(< /sys/fs/cgroup/memory.max)
+    current=$(< /sys/fs/cgroup/memory.current)
+  elif [ -r /sys/fs/cgroup/memory/memory.limit_in_bytes ] && [ -r /sys/fs/cgroup/memory/memory.usage_in_bytes ]; then
+    limit=$(< /sys/fs/cgroup/memory/memory.limit_in_bytes)
+    current=$(< /sys/fs/cgroup/memory/memory.usage_in_bytes)
+  fi
+
+  # Use the tighter of host availability and the container's remaining cgroup
+  # allowance so RAM sizing cannot exceed either boundary.
+  if finiteMemoryLimit "$limit" && [[ "$current" =~ ^[0-9]+$ ]]; then
+    (( limit < RAM_TOTAL )) && RAM_TOTAL="$limit"
+
+    local available=$(( limit - current ))
+    (( available < 0 )) && available=0
+    (( available < RAM_AVAIL )) && RAM_AVAIL="$available"
+  fi
+
+  return 0
+}
+
+stateFile() {
+
+  local name="$1"
+  local prefix="${2:-$PROCESS}"
+
+  [[ "$name" == */* ]] && printf '%s\n' "$name" && return 0
+
+  printf '%s/%s.%s\n' "$STORAGE" "$prefix" "$name"
+  return 0
+}
+
+writeFile() {
+
+  local txt="$1"
+  local path="$2"
+
+  if ! printf '%s\n' "$txt" > "$path"; then
+    error "Failed to write file \"$path\" !"
+    return 1
+  fi
+
+  if ! setOwner "$path"; then
+    warn "failed to set the owner for \"$path\"."
+  fi
+
+  return 0
+}
+
+writeAtomic() {
+
+  local path="$1"
+  local content="$2"
+  # Use a per-process temporary file and rename so readers see either the old
+  # complete value or the new complete value.
+  local tmp="${path}.${BASHPID}.tmp"
+
+  if ! printf '%s\n' "$content" > "$tmp"; then
+    rm -f -- "$tmp"
+    return 1
+  fi
+
+  if ! mv -f -- "$tmp" "$path"; then
+    rm -f -- "$tmp"
+    return 1
+  fi
+
+  return 0
+}
+
+readFile() {
+
+  local path="$1"
+  local value
+
+  [ -s "$path" ] || return 0
+
+  value=$(<"$path") || return 1
+  value="${value//[![:print:]]/}"
+
+  printf '%s\n' "$value"
+  return 0
+}
+
+writeState() {
+
+  local name="$1"
+  local value="$2"
+  local prefix="${3:-$PROCESS}"
+  local path
+
+  [ -z "$value" ] && return 0
+
+  path=$(stateFile "$name" "$prefix") || return 1
+  writeFile "$value" "$path"
+
+  return $?
+}
+
+readState() {
+
+  local name="$1"
+  local prefix="${2:-$PROCESS}"
+  local path
+
+  path=$(stateFile "$name" "$prefix") || return 1
+  readFile "$path"
+
+  return $?
+}
+
+restoreState() {
+
+  local var="$1"
+  local name="$2"
+  local force="${3:-N}"
+  local prefix="${4:-$PROCESS}"
+  local value
+
+  # Persistent state fills only unset variables unless force is requested,
+  # preserving explicit environment overrides.
+  if ! enabled "$force"; then
+    [ -z "${!var:-}" ] || return 0
+  fi
+
+  value=$(readState "$name" "$prefix") || return 1
+  [ -n "$value" ] || return 0
+
+  printf -v "$var" '%s' "$value" || return 1
+  return 0
+}
+
+escape () {
+
+  local s=${1//&/\&amp;}
+  s=${s//</\&lt;}
+  s=${s//>/\&gt;}
+  s=${s//'"'/\&quot;}
+
+  printf -- %s "$s"
+
+  return 0
+}
+
+escapeXML() {
+
+  printf '%s' "$1" | sed \
+    -e 's/&/\&amp;/g' \
+    -e 's/</\&lt;/g' \
+    -e 's/>/\&gt;/g' \
+    -e 's/"/\&quot;/g' \
+    -e "s/'/\&apos;/g"
+
+  return 0
+}
+
+html() {
+
+  local title
+  local body
+  local script="${2:-}"
+  local footer
+
+  title=$(escape "$APP")
+  title="<title>$title</title>"
+  footer=$(escape "$FOOTER1")
+
+  body=$(escape "$1")
+  if [[ "$body" == *"..." ]]; then
+    body="<p class=\"loading\">${body/.../}</p>"
+  fi
+
+  local HTML
+  HTML=$(<"$TEMPLATE")
+  HTML="${HTML/\[1\]/$title}"
+  HTML="${HTML/\[2\]/$script}"
+  HTML="${HTML/\[3\]/$body}"
+  HTML="${HTML/\[4\]/$footer}"
+  HTML="${HTML/\[5\]/$FOOTER2}"
+
+  # Publish both the full page and websocket fragment atomically because nginx
+  # and websocketd may read them concurrently.
+  writeAtomic "$PAGE" "$HTML" || return 1
+  writeAtomic "$INFO" "$body" || return 1
+
+  return 0
+}
+
+cpu() {
+
+  local ret
+  local cpu=""
+
+  ret=$(lscpu)
+
+  if grep -qi "model name" <<< "$ret"; then
+    cpu=$(echo "$ret" | grep -m 1 -i 'model name' | cut -f 2 -d ":" | awk '{$1=$1}1' | sed 's# @.*##g' | sed s/"(R)"//g | sed 's/[^[:alnum:] ]\+/ /g' | sed 's/  */ /g')
+  fi
+
+  if [ -z "${cpu// /}" ] && grep -qi "model:" <<< "$ret"; then
+    cpu=$(echo "$ret" | grep -m 1 -i 'model:' | cut -f 2 -d ":" | awk '{$1=$1}1' | sed 's# @.*##g' | sed s/"(R)"//g | sed 's/[^[:alnum:] ]\+/ /g' | sed 's/  */ /g')
+  fi
+
+  cpu="${cpu// CPU/}"
+  cpu="${cpu// [0-9][0-9][0-9] Core}"
+  cpu="${cpu// [0-9][0-9] Core}"
+  cpu="${cpu// [0-9] Core}"
+  cpu="${cpu//[0-9][0-9]th Gen }"
+  cpu="${cpu//[0-9]th Gen }"
+  cpu="${cpu// Processor/}"
+  cpu="${cpu// Quad core/}"
+  cpu="${cpu// Dual core/}"
+  cpu="${cpu// Octa core/}"
+  cpu="${cpu// Hexa core/}"
+  cpu="${cpu// Core TM/ Core}"
+  cpu="${cpu// with Radeon Graphics/}"
+  cpu="${cpu// with Radeon Vega Graphics/}"
+  cpu="${cpu// with Radeon Vega Mobile Gfx/}"
+  cpu="${cpu// w Radeon [0-9][0-9][0-9]M Graphics/}"
+
+  [ -z "${cpu// /}" ] && cpu="Unknown"
+
+  echo "$cpu"
+  return 0
+}
+
+getCountry() {
+
+  local url=$1
+  local query=$2
+  local json result
+
+  { json=$(curl -m 5 -H "Accept: application/json" -sfk "$url"); local rc=$?; } || :
+  (( rc != 0 )) && return 0
+
+  { result=$(echo "$json" | jq -r "$query" 2> /dev/null); rc=$?; } || :
+  (( rc != 0 )) && return 0
+
+  [[ ${#result} -ne 2 ]] && return 0
+  [[ "${result^^}" == "XX" ]] && return 0
+
+  COUNTRY="${result^^}"
+
+  return 0
+}
+
+setCountry() {
+
+  [[ "${TZ,,}" == "asia/harbin" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/beijing" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/urumqi" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/kashgar" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/shanghai" ]] && COUNTRY="CN"
+  [[ "${TZ,,}" == "asia/chongqing" ]] && COUNTRY="CN"
+
+  # Country detection is best-effort and tries independent services in order;
+  # failure leaves mirror selection at its global default.
+  [ -z "$COUNTRY" ] && getCountry "https://api.ipapi.is" ".location.country_code"
+  [ -z "$COUNTRY" ] && getCountry "https://ifconfig.co/json" ".country_iso"
+  [ -z "$COUNTRY" ] && getCountry "https://api.ip2location.io" ".country_code"
+  [ -z "$COUNTRY" ] && getCountry "https://ipinfo.io/json" ".country"
+  [ -z "$COUNTRY" ] && getCountry "https://api.ipquery.io/?format=json" ".location.country_code" 
+  [ -z "$COUNTRY" ] && getCountry "https://api.myip.com" ".cc"
+
+  return 0
+}
+
+addPackage() {
+
+  local pkg=$1
+  local desc=$2
+
+  if apt-mark showinstall | grep -qx "$pkg"; then
+    return 0
+  fi
+
+  MSG="Installing $desc..."
+  info "$MSG" && html "$MSG"
+
+  [ -z "$COUNTRY" ] && setCountry
+
+  # Use a mainland mirror only for on-demand package installation, avoiding
+  # slow or inaccessible Debian endpoints in that region.
+  if [[ "${COUNTRY^^}" == "CN" ]]; then
+    sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
+  fi
+
+  DEBIAN_FRONTEND=noninteractive apt-get -qq update || return 1
+  DEBIAN_FRONTEND=noninteractive apt-get -qq --no-install-recommends -y install "$pkg" > /dev/null || return 1
+
+  return 0
+}
+
+return 0

web/conf/nginx.conf

@@ -0,0 +1,44 @@
+server {
+    listen 5000 default_server;
+
+    autoindex on;
+    tcp_nodelay on;
+    server_tokens off;
+    absolute_redirect off;
+
+    error_log /dev/null;
+    access_log /dev/null;
+
+    include /etc/nginx/mime.types;
+
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 5;
+    gzip_min_length 500;
+    gzip_disable "msie6";
+    gzip_types text/css text/javascript text/xml text/plain text/x-component application/javascript application/json application/xml application/rss+xml font/truetype font/opentype application/vnd.ms-fontobject image/svg+xml;
+
+    add_header Cache-Control "no-cache";
+
+    location / {
+
+      root /run/shm;
+      index index.html;
+
+    }
+
+    location /status {
+
+      proxy_http_version 1.1;
+
+      proxy_set_header Connection 'upgrade';
+      proxy_set_header Upgrade $http_upgrade;
+
+      proxy_buffering off;
+      proxy_read_timeout 3600s;
+      proxy_send_timeout 3600s;
+
+      proxy_pass http://unix:/run/shm/status-ws.sock:/;
+    }
+}

web/css/style.css

@@ -0,0 +1,167 @@
+body {
+	color: white;
+	background-color: #125bdb;
+	font-smoothing: antialiased;
+	-webkit-font-smoothing: antialiased;
+	-moz-osx-font-smoothing: grayscale;
+	font-family: Verdana, Geneva, sans-serif;
+}
+
+#info {
+	text-shadow: 1px 1px 1px rgba(0, 0, 0, 0.25);
+}
+
+#content {
+	text-align: center;
+	padding: 20px;
+	margin-top: 50px;
+}
+
+footer {
+	width: 98%;
+	position: fixed;
+	bottom: 0px;
+	height: 40px;
+	text-align: center;
+	color: #0c8aeb;
+	text-shadow: 0 0 1px #0c8aeb;
+}
+
+#empty {
+	height: 40px;
+	/* Same height as footer */
+}
+
+a,
+a:hover,
+a:active,
+a:visited {
+	color: white;
+}
+
+footer a:link,
+footer a:visited,
+footer a:active {
+	color: #0c8aeb;
+}
+
+footer a:hover {
+	color: #73e6ff;
+}
+
+.loading:after {
+	content: " .";
+	animation: dots 1s steps(5, end) infinite;
+}
+
+@keyframes dots {
+
+	0%,
+	20% {
+		color: rgba(0, 0, 0, 0);
+		text-shadow: 0.25em 0 0 rgba(0, 0, 0, 0), 0.5em 0 0 rgba(0, 0, 0, 0);
+	}
+
+	40% {
+		color: white;
+		text-shadow: 0.25em 0 0 rgba(0, 0, 0, 0), 0.5em 0 0 rgba(0, 0, 0, 0);
+	}
+
+	60% {
+		text-shadow: 0.25em 0 0 white, 0.5em 0 0 rgba(0, 0, 0, 0);
+	}
+
+	80%,
+	100% {
+		text-shadow: 0.25em 0 0 white, 0.5em 0 0 white;
+	}
+}
+
+.spinner_LWk7 {
+	animation: spinner_GWy6 1.2s linear infinite, spinner_BNNO 1.2s linear infinite
+}
+
+.spinner_yOMU {
+	animation: spinner_GWy6 1.2s linear infinite, spinner_pVqn 1.2s linear infinite;
+	animation-delay: .15s
+}
+
+.spinner_KS4S {
+	animation: spinner_GWy6 1.2s linear infinite, spinner_6uKB 1.2s linear infinite;
+	animation-delay: .3s
+}
+
+.spinner_zVee {
+	animation: spinner_GWy6 1.2s linear infinite, spinner_Qw4x 1.2s linear infinite;
+	animation-delay: .45s
+}
+
+@keyframes spinner_GWy6 {
+
+	0%,
+	50% {
+		width: 9px;
+		height: 9px
+	}
+
+	10% {
+		width: 11px;
+		height: 11px
+	}
+}
+
+@keyframes spinner_BNNO {
+
+	0%,
+	50% {
+		x: 1.5px;
+		y: 1.5px
+	}
+
+	10% {
+		x: .5px;
+		y: .5px
+	}
+}
+
+@keyframes spinner_pVqn {
+
+	0%,
+	50% {
+		x: 13.5px;
+		y: 1.5px
+	}
+
+	10% {
+		x: 12.5px;
+		y: .5px
+	}
+}
+
+@keyframes spinner_6uKB {
+
+	0%,
+	50% {
+		x: 13.5px;
+		y: 13.5px
+	}
+
+	10% {
+		x: 12.5px;
+		y: 12.5px
+	}
+}
+
+@keyframes spinner_Qw4x {
+
+	0%,
+	50% {
+		x: 1.5px;
+		y: 13.5px
+	}
+
+	10% {
+		x: .5px;
+		y: 12.5px
+	}
+}

web/img/favicon.svg

@@ -0,0 +1 @@
+<svg id="Capa_1" enable-background="new 0 0 511.962 511.962" height="512" viewBox="0 0 511.962 511.962" width="512" xmlns="http://www.w3.org/2000/svg"><g><path d="m489.965 120.063c0-5.77-3.31-11.028-8.512-13.524l-218.984-105.063c-4.102-1.967-8.875-1.967-12.977 0l-218.985 105.063c-5.202 2.496-8.511 7.755-8.511 13.524l-.003 271.834c0 5.77 3.31 11.028 8.512 13.524l218.989 105.064c2.051.983 4.27 1.476 6.488 1.476 2.219 0 4.438-.492 6.488-1.476l218.989-105.064c5.202-2.496 8.512-7.755 8.512-13.524z" fill="#4e6ba6"/><path d="m489.965 120.063c0-5.77-3.31-11.028-8.512-13.524l-218.984-105.063c-2.051-.984-4.269-1.476-6.488-1.476v511.962c2.219 0 4.438-.492 6.488-1.476l218.989-105.064c5.202-2.496 8.512-7.755 8.512-13.524z" fill="#28487a"/><path d="m425.812 160.441c0-2.27-.519-4.457-1.457-6.432l-336.701-.095c-.967 1.999-1.504 4.22-1.504 6.526l-.002 191.081c0 5.769 3.31 11.028 8.512 13.524l154.833 74.285c2.051.983 4.27 1.476 6.488 1.476 2.219 0 4.438-.492 6.488-1.476l154.834-74.285c5.202-2.496 8.512-7.755 8.512-13.524z" fill="#8dc2eb"/><path d="m424.354 154.009h-168.373v286.798c2.219 0 4.438-.492 6.488-1.476l154.834-74.285c5.202-2.496 8.512-7.755 8.512-13.524l-.003-191.081c0-2.27-.52-4.458-1.458-6.432z" fill="#5e9ff6"/><path d="m417.3 146.916-154.831-74.284c-4.102-1.967-8.875-1.967-12.977 0l-154.831 74.284c-3.122 1.498-5.555 3.996-7.007 6.998l168.328 80.812 168.374-80.717c-1.448-3.044-3.9-5.579-7.056-7.093z" fill="#ecf9fd"/><path d="m417.3 146.916-154.831-74.284c-2.051-.983-4.27-1.476-6.488-1.476v163.569l168.374-80.717c-1.447-3.043-3.899-5.578-7.055-7.092z" fill="#d9f3fc"/></g></svg>

web/index.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+
+    <head>
+        [1]
+        <meta http-equiv="Cache-Control" content="no-cache" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <link rel="stylesheet" type="text/css" href="css/style.css" />
+        <link rel="icon" href="img/favicon.svg" type="image/x-icon">
+        [2]
+    </head>
+
+    <body>
+        <div id="page">
+            <div id="content">
+                <svg id="spinner" width="64" height="64" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                    <rect class="spinner_LWk7" fill="#0c8aeb" x="1.5" y="1.5" rx="1" width="9" height="9"/>
+                    <rect class="spinner_yOMU" fill="#0c8aeb" x="13.5" y="1.5" rx="1" width="9" height="9"/>
+                    <rect class="spinner_KS4S" fill="#0c8aeb" x="13.5" y="13.5" rx="1" width="9" height="9"/>
+                    <rect class="spinner_zVee" fill="#0c8aeb" x="1.5" y="13.5" rx="1" width="9" height="9"/>
+                </svg>
+                <h1 id="info">[3]</h1>
+            </div>
+            <div id="empty">
+            </div>
+            <footer id="footer">
+                [4]<br />
+                [5]
+            </footer>
+        </div>
+        <script type="text/javascript" src="js/script.js"></script>
+    </body>
+
+</html>

web/js/script.js

@@ -0,0 +1,248 @@
+var timer;
+var request;
+var booting = false;
+var interval = 1000;
+
+function abortRequest() {
+
+    if (!request) {
+        return false;
+    }
+
+    request.onreadystatechange = null;
+    request.abort();
+    request = null;
+
+    return true;
+}
+
+function getInfo() {
+
+    var url = "msg.html";
+
+    try {
+        abortRequest();
+
+        if (window.XMLHttpRequest) {
+            request = new XMLHttpRequest();
+        } else {
+            throw new Error("XMLHttpRequest not available!");
+        }
+
+        request.onreadystatechange = processInfo;
+        request.open("GET", url, true);
+        request.send();
+
+    } catch (e) {
+        setError("Error: " + e.message);
+    }
+}
+
+function getURL() {
+
+    var protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    var path = window.location.pathname.replace(/[^/]*$/, '').replace(/\/$/, '');
+
+    return protocol + "//" + window.location.host + path;
+}
+
+function processMsg(msg) {
+
+    if (msg.toLowerCase().indexOf("href=") !== -1) {
+        var div = document.createElement("div");
+        div.innerHTML = msg;
+        var url = div.querySelector("a").href;
+        setTimeout(() => {
+            window.location.assign(url);
+        }, 3000);
+    }
+
+    setInfo(msg);
+    return true;
+}
+
+function processInfo() {
+    try {
+
+        if (request.readyState != 4) {
+            return true;
+        }
+
+        var response = request;
+        request = null;
+
+        var status = response.status;
+
+        if (status == 502 || status == 503 || status == 504) {
+            schedule();
+            return true;
+        }
+
+        var msg = response.responseText;
+        if (msg == null || msg.length == 0) {
+
+            if (booting) {
+                schedule();
+                return true;
+            }
+
+            window.location.reload();
+            return false;
+        }
+
+        var notFound = (status == 404);
+
+        if (status == 200) {
+            if (msg.toLowerCase().indexOf("<html>") !== -1) {
+                notFound = true;
+            } else {
+                processMsg(msg);
+                if (msg.toLowerCase().indexOf("href=") == -1) {
+                    schedule();
+                }
+                return true;
+            }
+        }
+
+        if (notFound) {
+            setInfo("Connecting to web portal", true);
+            reload();
+            return true;
+        }
+
+        setError("Error: Received statuscode " + status);
+        return false;
+
+    } catch (e) {
+        setError("Error: " + e.message);
+        return false;
+    }
+}
+
+function extractContent(s) {
+    var span = document.createElement('span');
+    span.innerHTML = s;
+    return span.textContent || span.innerText;
+};
+
+function setInfo(msg, loading, error) {
+    try {
+
+        if (msg == null || msg.length == 0) {
+            return false;
+        }
+
+        if (msg.includes("Booting ")) {
+            booting = true;
+        }
+
+        var el = document.getElementById("info");
+
+        if (el.innerText == msg || el.innerHTML == msg) {
+            return true;
+        }
+
+        var spin = document.getElementById("spinner");
+
+        error = !!error;
+        if (!error) {
+            spin.style.visibility = 'visible';
+        } else {
+            spin.style.visibility = 'hidden';
+        }
+
+        var p = "<p class=\"loading\">";
+        loading = !!loading;
+        if (loading) {
+            msg = p + msg + "</p>";
+        }
+
+        if (msg.includes(p)) {
+            if (el.innerHTML.includes(p)) {
+                el.getElementsByClassName('loading')[0].textContent = extractContent(msg);
+                return true;
+            }
+        }
+
+        el.innerHTML = msg;
+        return true;
+
+    } catch (e) {
+        console.log("Error: " + e.message);
+        return false;
+    }
+}
+
+function setError(text) {
+    console.warn(text);
+    return setInfo(text, false, true);
+}
+
+function schedule() {
+
+    clearTimeout(timer);
+    timer = setTimeout(getInfo, interval);
+}
+
+function reload() {
+    setTimeout(() => {
+        window.location.reload();
+    }, 3000);
+}
+
+function connect() {
+
+    var wsUrl = getURL() + "/status";
+    var ws = new WebSocket(wsUrl);
+
+    ws.onmessage = function(e) {
+
+        var pos = e.data.indexOf(":");
+        var cmd = e.data.substring(0, pos);
+        var msg = e.data.substring(pos + 2);
+
+        switch (cmd) {
+            case "s":
+
+                var aborted = abortRequest();
+
+                processMsg(msg);
+
+                if (aborted &&
+                    msg.toLowerCase().indexOf("href=") == -1) {
+                    schedule();
+                }
+
+                break;
+
+            case "e":
+
+                if (abortRequest()) {
+                    schedule();
+                }
+
+                setError(msg);
+                break;
+
+            default:
+                console.warn("Unknown event: " + cmd);
+                break;
+        }
+    };
+
+    ws.onclose = function(e) {
+        setTimeout(function() {
+            connect();
+        }, interval);
+    };
+
+    ws.onerror = function(e) {
+        ws.close();
+        if (!booting) {
+            window.location.reload();
+        }
+    };
+}
+
+schedule();
+connect();