Fix: clear IP data when VPN is stopped

- Check target IP matches a server for Wireguard since we need the public key
- Streamline connection picking for all providers

.devcontainer/.dockerignore

@@ -0,0 +1,5 @@
+.dockerignore
+devcontainer.json
+docker-compose.yml
+Dockerfile
+README.md

.devcontainer/Dockerfile

@@ -0,0 +1,2 @@
+FROM qmcgaw/godevcontainer
+RUN apk add wireguard-tools

.devcontainer/README.md

@@ -0,0 +1,69 @@
+# Development container
+
+Development container that can be used with VSCode.
+
+It works on Linux, Windows and OSX.
+
+## Requirements
+
+- [VS code](https://code.visualstudio.com/download) installed
+- [VS code remote containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) installed
+- [Docker](https://www.docker.com/products/docker-desktop) installed and running
+    - If you don't use Linux or WSL 2, share your home directory `~/` and the directory of your project with Docker Desktop
+- [Docker Compose](https://docs.docker.com/compose/install/) installed
+- Ensure your host has the following and that they are accessible by Docker:
+    - `~/.ssh` directory
+    - `~/.gitconfig` file (can be empty)
+
+## Setup
+
+1. Open the command palette in Visual Studio Code (CTRL+SHIFT+P).
+1. Select `Remote-Containers: Open Folder in Container...` and choose the project directory.
+1. For Docker running on Windows HyperV, if you want to use SSH keys, bind mount them at `/tmp/.ssh` by changing the `volumes` section in the [docker-compose.yml](docker-compose.yml).
+
+## Customization
+
+### Customize the image
+
+You can make changes to the [Dockerfile](Dockerfile) and then rebuild the image. For example, your Dockerfile could be:
+
+```Dockerfile
+FROM qmcgaw/godevcontainer
+USER root
+RUN apk add curl
+USER vscode
+```
+
+Note that you may need to use `USER root` to build as root, and then change back to `USER vscode`.
+
+To rebuild the image, either:
+
+- With VSCode through the command palette, select `Remote-Containers: Rebuild and reopen in container`
+- With a terminal, go to this directory and `docker-compose build`
+
+### Customize VS code settings
+
+You can customize **settings** and **extensions** in the [devcontainer.json](devcontainer.json) definition file.
+
+### Entrypoint script
+
+You can bind mount a shell script to `/home/vscode/.welcome.sh` to replace the [current welcome script](shell/.welcome.sh).
+
+### Publish a port
+
+To access a port from your host to your development container, publish a port in [docker-compose.yml](docker-compose.yml).
+
+### Run other services
+
+1. Modify [docker-compose.yml](docker-compose.yml) to launch other services at the same time as this development container, such as a test database:
+
+    ```yml
+      database:
+        image: postgres
+        restart: always
+        environment:
+          POSTGRES_PASSWORD: password
+    ```
+
+1. In [devcontainer.json](devcontainer.json), change the line `"runServices": ["vscode"],` to `"runServices": ["vscode", "database"],`.
+1. In the VS code command palette, rebuild the container.

.devcontainer/devcontainer.json

@@ -1,62 +1,81 @@
 {
-    "name": "pia-dev",
-    "dockerComposeFile": ["docker-compose.yml"],
+    "name": "gluetun-dev",
+    "dockerComposeFile": [
+        "docker-compose.yml"
+    ],
     "service": "vscode",
-    "runServices": ["vscode"],
+    "runServices": [
+        "vscode"
+    ],
     "shutdownAction": "stopCompose",
-    // "postCreateCommand": "go mod download",
+    "postCreateCommand": "source ~/.windows.sh && go mod download && go mod tidy",
     "workspaceFolder": "/workspace",
     "extensions": [
-        "ms-vscode.go",
-        "IBM.output-colorizer",
-        "eamodio.gitlens",
-        "mhutchie.git-graph",
+        "golang.go",
+        "eamodio.gitlens", // IDE Git information
         "davidanson.vscode-markdownlint",
-        "shardulm94.trailing-spaces",
-        "alefragnani.Bookmarks",
-        "Gruntfuggly.todo-tree",
-        "mohsen1.prettify-json",
-        "quicktype.quicktype",
-        "spikespaz.vscode-smoothtype",
-        "stkb.rewrap",
-        "vscode-icons-team.vscode-icons"
+        "ms-azuretools.vscode-docker", // Docker integration and linting
+        "shardulm94.trailing-spaces", // Show trailing spaces
+        "Gruntfuggly.todo-tree", // Highlights TODO comments
+        "bierner.emojisense", // Emoji sense for markdown
+        "stkb.rewrap", // rewrap comments after n characters on one line
+        "vscode-icons-team.vscode-icons", // Better file extension icons
+        "github.vscode-pull-request-github", // Github interaction
+        "redhat.vscode-yaml", // Kubernetes, Drone syntax highlighting
+        "bajdzis.vscode-database", // Supports connections to mysql or postgres, over SSL, socked
+        "IBM.output-colorizer", // Colorize your output/test logs
+        "mohsen1.prettify-json", // Prettify JSON data
     ],
     "settings": {
-        // General settings
         "files.eol": "\n",
-        // Docker
         "remote.extensionKind": {
             "ms-azuretools.vscode-docker": "workspace"
         },
-        // Golang general settings
+        "editor.codeActionsOnSaveTimeout": 3000,
         "go.useLanguageServer": true,
+        "[go]": {
+            "editor.formatOnSave": true,
+            "editor.codeActionsOnSave": {
+                "source.organizeImports": true,
+            },
+            // Optional: Disable snippets, as they conflict with completion ranking.
+            "editor.snippetSuggestions": "none"
+        },
+        "[go.mod]": {
+            "editor.formatOnSave": true,
+            "editor.codeActionsOnSave": {
+                "source.organizeImports": true,
+            },
+        },
+        "gopls": {
+            "usePlaceholders": false,
+            "staticcheck": true
+        },
         "go.autocompleteUnimportedPackages": true,
         "go.gotoSymbol.includeImports": true,
         "go.gotoSymbol.includeGoroot": true,
-        "gopls": {
-            "completeUnimported": true,
-            "deepCompletion": true,
-            "usePlaceholders": false
-        },
-        // Golang on save
-        "go.buildOnSave": "package",
-        "go.lintOnSave": "package",
-        "go.vetOnSave": "package",
+        "go.lintTool": "golangci-lint",
+        "go.buildOnSave": "workspace",
+        "go.lintOnSave": "workspace",
+        "go.vetOnSave": "workspace",
         "editor.formatOnSave": true,
-        "[go]": {
-            "editor.codeActionsOnSave": {
-                "source.organizeImports": true
-            }
-        },
-        // Golang testing
         "go.toolsEnvVars": {
-            "GOFLAGS": "-tags=integration"
+            "GOFLAGS": "-tags=",
+            // "CGO_ENABLED": 1 // for the race detector
         },
         "gopls.env": {
-            "GOFLAGS": "-tags=integration"
+            "GOFLAGS": "-tags="
         },
-        "go.testEnvVars": {},
-        "go.testFlags": ["-v"],
-        "go.testTimeout": "600s"
+        "go.testEnvVars": {
+            "": ""
+        },
+        "go.testFlags": [
+            "-v",
+            // "-race"
+        ],
+        "go.testTimeout": "10s",
+        "go.coverOnSingleTest": true,
+        "go.coverOnSingleTestFile": true,
+        "go.coverOnTestPackage": true
     }
 }

.devcontainer/docker-compose.yml

@@ -2,14 +2,32 @@ version: "3.7"
 
 services:
   vscode:
-    image: qmcgaw/godevcontainer
+    build: .
+    image: godevcontainer
+    devices:
+      - /dev/net/tun:/dev/net/tun
     volumes:
       - ../:/workspace
-      - ~/.ssh:/home/vscode/.ssh:ro
-      - ~/.ssh:/root/.ssh:ro
+      # Docker socket to access Docker server
       - /var/run/docker.sock:/var/run/docker.sock
+      # Docker configuration
+      - ~/.docker:/root/.docker:z
+      # SSH directory for Linux, OSX and WSL
+      - ~/.ssh:/root/.ssh:z
+      # For Windows without WSL, a copy will be made
+      # from /tmp/.ssh to ~/.ssh to fix permissions
+      #- ~/.ssh:/tmp/.ssh:ro
+      # Shell history persistence
+      - ~/.zsh_history:/root/.zsh_history:z
+      # Git config
+      - ~/.gitconfig:/root/.gitconfig:z
+    environment:
+      - TZ=
     cap_add:
-      - SYS_PTRACE
+      # For debugging with dlv
+      # - SYS_PTRACE
+      - NET_ADMIN
     security_opt:
+      # For debugging with dlv
       - seccomp:unconfined
     entrypoint: zsh -c "while sleep 1000; do :; done"

.dockerignore

@@ -1,10 +1,9 @@
+.devcontainer
 .git
-.vscode
-readme
-.gitignore
-.travis.yml
-ci.sh
+.github
+doc
 docker-compose.yml
+Dockerfile
 LICENSE
 README.md
-Dockerfile
+title.svg

.github/CODEOWNERS

@@ -0,0 +1 @@
+@qdm12

.github/CONTRIBUTING.md

@@ -0,0 +1,18 @@
+# Contributing
+
+Contributions are [released](https://help.github.com/articles/github-terms-of-service/#6-contributions-under-repository-license) to the public under the [open source license of this project](../LICENSE).
+
+## Submitting a pull request
+
+1. [Fork](https://github.com/qdm12/gluetun/fork) and clone the repository
+1. Create a new branch `git checkout -b my-branch-name`
+1. Modify the code
+1. Ensure the docker build succeeds `docker build .` (you might need `export DOCKER_BUILDKIT=1`)
+1. Commit your modifications
+1. Push to your fork and [submit a pull request](https://github.com/qdm12/gluetun/compare)
+
+## Resources
+
+- [Gluetun guide on development](https://github.com/qdm12/gluetun/wiki/Development)
+- [Using Pull Requests](https://help.github.com/articles/about-pull-requests/)
+- [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)

.github/ISSUE_TEMPLATE/bug.md

@@ -0,0 +1,49 @@
+---
+name: Bug
+about: Report a bug
+title: 'Bug: FILL THIS TEXT!'
+labels: ":bug: bug"
+assignees: qdm12
+
+---
+
+<!---
+⚠️ Answer the following or I'll insta-close your issue
+-->
+
+**Is this urgent?**: No
+
+**Host OS** (approximate answer is fine too): Ubuntu 18
+
+<!---
+🚧 If this is about the Unraid template see https://github.com/qdm12/gluetun/discussions/550
+-->
+
+**CPU arch** or **device name**: amd64
+
+**What VPN provider are you using**:
+
+**What are you using to run your container?**: Docker Compose
+
+**What is the version of the program** (See the line at the top of your logs)
+
+```
+Running version latest built on 2020-03-13T01:30:06Z (commit d0f678c)
+```
+
+**What's the problem** 🤔
+
+That feature doesn't work
+
+**Share your logs... (careful to remove in example tokens)**
+
+```log
+
+PASTE YOUR LOGS
+IN THERE
+
+```
+
+<!---
+💡 You can highlight your code with https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#syntax-highlight
+-->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest a feature to add to this project
+title: 'Feature request: FILL THIS TEXT!'
+labels: ":bulb: feature request"
+assignees: qdm12
+
+---
+
+**What's the feature?** 🧐
+
+- Support this new feature because that and that
+
+**Optional extra information** 🚀
+
+- I tried `docker run something` and it doesn't work
+- That [url](https://github.com/qdm12/gluetun) is interesting

.github/ISSUE_TEMPLATE/help.md

@@ -0,0 +1,67 @@
+---
+name: Help
+about: Ask for help
+title: 'Help: FILL THIS TEXT!'
+labels: ":pray: help wanted"
+assignees:
+
+---
+
+<!---
+⚠️ If this about a Docker configuration problem or another service:
+Start a discussion at https://github.com/qdm12/gluetun/discussions/new
+OR I WILL INSTA-CLOSE YOUR ISSUE.
+-->
+
+<!---
+⚠️ Answer the following or I'll insta-close your issue
+-->
+
+**Is this urgent?**: No
+
+**Host OS** (approximate answer is fine too): Ubuntu 18
+
+**CPU arch** or **device name**: amd64
+
+**What VPN provider are you using**:
+
+**What is the version of the program** (See the line at the top of your logs)
+
+```
+Running version latest built on 2020-03-13T01:30:06Z (commit d0f678c)
+```
+
+**What's the problem** 🤔
+
+That feature doesn't work
+
+**Share your logs... (careful to remove in example tokens)**
+
+```log
+
+PASTE YOUR LOGS
+IN THERE
+
+```
+
+**What are you using to run your container?**: Docker Compose
+
+<!---
+💡 You can highlight your code with https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#syntax-highlight
+-->
+
+Please also share your configuration file:
+
+```yml
+your .yml
+content
+in here
+```
+
+or
+
+```sh
+# your docker
+# run command
+# in here
+```

.github/ISSUE_TEMPLATE/provider.md

@@ -0,0 +1,17 @@
+---
+name: Support a VPN provider
+about: Suggest a VPN provider to be supported
+title: 'VPN provider support: NAME OF THE PROVIDER'
+labels: ":bulb: New provider"
+
+---
+
+One of the following is required:
+
+- Publicly accessible URL to a zip file containing the Openvpn configuration files
+- Publicly accessible URL to a structured (JSON etc.) list of servers **and attach** an example Openvpn configuration file for both TCP and UDP
+- Publicly accessible URL to the list of servers **and attach** an example Openvpn configuration file for both TCP and UDP
+
+If the list of servers requires to login **or** is hidden behind an interactive configurator,
+you can only use a custom Openvpn configuration file.
+[The Wiki](https://github.com/qdm12/gluetun/wiki/Openvpn-file) describes how to do so.

.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: docker
+    directory: /
+    schedule:
+      interval: "daily"
+  - package-ecosystem: gomod
+    directory: /
+    schedule:
+      interval: "daily"

.github/labels.yml

@@ -0,0 +1,93 @@
+- name: "Bug :bug:"
+  color: "b60205"
+  description: ""
+- name: "Feature request :bulb:"
+  color: "0e8a16"
+  description: ""
+- name: "Help wanted :pray:"
+  color: "4caf50"
+  description: ""
+- name: "Documentation :memo:"
+  color: "c5def5"
+  description: ""
+- name: "Needs more info :thinking:"
+  color: "795548"
+  description: ""
+
+# VPN providers
+- name: ":cloud: Cyberghost"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: HideMyAss"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: IPVanish"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: IVPN"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: FastestVPN"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Mullvad"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: NordVPN"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: PIA"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Privado"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: PrivateVPN"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: ProtonVPN"
+  color: "cfe8d4"
+- name: ":cloud: PureVPN"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Surfshark"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Torguard"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: VPNUnlimited"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Vyprvpn"
+  color: "cfe8d4"
+  description: ""
+- name: ":cloud: Windscribe"
+  color: "cfe8d4"
+  description: ""
+
+# Problem category
+- name: "Openvpn"
+  color: "ffc7ea"
+  description: ""
+- name: "Wireguard"
+  color: "ffc7ea"
+  description: ""
+- name: "Unbound (DNS over TLS)"
+  color: "ffc7ea"
+  description: ""
+- name: "Firewall"
+  color: "ffc7ea"
+  description: ""
+- name: "HTTP proxy"
+  color: "ffc7ea"
+  description: ""
+- name: "Shadowsocks"
+  color: "ffc7ea"
+  description: ""
+- name: "Healthcheck server"
+  color: "ffc7ea"
+  description: ""
+- name: "Control server"
+  color: "ffc7ea"
+  description: ""

.github/workflows/ci.yml

@@ -0,0 +1,99 @@
+name: CI
+on:
+  push:
+    paths:
+      - .github/workflows/ci.yml
+      - cmd/**
+      - internal/**
+      - pkg/**
+      - .dockerignore
+      - .golangci.yml
+      - Dockerfile
+      - go.mod
+      - go.sum
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_BUILDKIT: "1"
+    steps:
+      - uses: actions/checkout@v2.3.4
+
+      - name: Linting
+        run: docker build --target lint .
+
+      - name: Go mod tidy check
+        run: docker build --target tidy .
+
+      - name: Build test image
+        run: docker build --target test -t test-container .
+
+      - name: Run tests in test container
+        run: |
+          touch coverage.txt
+          docker run --rm \
+          -v "$(pwd)/coverage.txt:/tmp/gobuild/coverage.txt" \
+          test-container
+
+      - name: Code security analysis
+        uses: snyk/actions/golang@master
+        env:
+          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+
+      - name: Build final image
+        run: docker build -t final-image .
+
+      - name: Image security analysis
+        uses: snyk/actions/docker@master
+        env:
+          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
+        with:
+          image: final-image
+
+  publish:
+    needs: [verify]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.3.4
+
+      - uses: docker/setup-qemu-action@v1
+      - uses: docker/setup-buildx-action@v1
+
+      - uses: docker/login-action@v1
+        with:
+          username: qmcgaw
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      - name: Set variables
+        id: vars
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+        run: |
+          BRANCH=${GITHUB_REF#refs/heads/}
+          TAG=${GITHUB_REF#refs/tags/}
+          echo ::set-output name=commit::$(git rev-parse --short HEAD)
+          echo ::set-output name=created::$(date -u +%Y-%m-%dT%H:%M:%SZ)
+          if [ "$TAG" != "$GITHUB_REF" ]; then
+            echo ::set-output name=version::$TAG
+            echo ::set-output name=platforms::linux/amd64,linux/386,linux/arm64,linux/arm/v6,linux/arm/v7,linux/ppc64le
+          elif [ "$BRANCH" = "master" ]; then
+            echo ::set-output name=version::latest
+            echo ::set-output name=platforms::linux/amd64,linux/386,linux/arm64,linux/arm/v6,linux/arm/v7,linux/ppc64le
+          else
+            echo ::set-output name=version::$BRANCH
+            echo ::set-output name=platforms::linux/amd64,linux/386,linux/arm64,linux/arm/v6,linux/arm/v7,linux/ppc64le
+          fi
+
+      - name: Build and push final image
+        uses: docker/build-push-action@v2.6.1
+        with:
+          platforms: ${{ steps.vars.outputs.platforms }}
+          build-args: |
+            CREATED=${{ steps.vars.outputs.created }}
+            COMMIT=${{ steps.vars.outputs.commit }}
+            VERSION=${{ steps.vars.outputs.version }}
+          tags: |
+            qmcgaw/gluetun:${{ steps.vars.outputs.version }}
+            qmcgaw/private-internet-access:${{ steps.vars.outputs.version }}
+          push: true

.github/workflows/dockerhub-description.yml

@@ -0,0 +1,21 @@
+name: Docker Hub description
+on:
+  push:
+    branches: [master]
+    paths:
+      - README.md
+      - .github/workflows/dockerhub-description.yml
+jobs:
+  dockerHubDescription:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2.3.4
+      - name: Docker Hub Description
+        uses: peter-evans/dockerhub-description@v2
+        with:
+          username: qmcgaw
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+          repository: qmcgaw/gluetun
+          short-description: Lightweight Swiss-knife VPN client to connect to several VPN providers
+          readme-filepath: README.md

.github/workflows/labels.yml

@@ -0,0 +1,15 @@
+name: labels
+on:
+  push:
+    branches: [master]
+    paths:
+      - .github/labels.yml
+      - .github/workflows/labels.yml
+jobs:
+  labeler:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.3.4
+      - uses: crazy-max/ghaction-github-labeler@v3
+        with:
+          yaml-file: .github/labels.yml

.github/workflows/misspell.yml

@@ -0,0 +1,15 @@
+name: Misspells
+on:
+  pull_request:
+    branches: [master]
+  push:
+    branches: [master]
+jobs:
+  misspell:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.3.4
+      - uses: reviewdog/action-misspell@v1
+        with:
+          locale: "US"
+          level: error

.gitignore

@@ -0,0 +1 @@
+scratch.txt

.golangci.yml

@@ -0,0 +1,88 @@
+linters-settings:
+  maligned:
+    suggest-new: true
+  misspell:
+    locale: US
+
+issues:
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - dupl
+        - maligned
+        - goerr113
+    - path: internal/server/
+      linters:
+        - dupl
+    - path: internal/configuration/
+      linters:
+        - dupl
+    - path: internal/constants/
+      linters:
+        - dupl
+    - text: "exported: exported var Err*"
+      linters:
+        - revive
+    - text: "mnd: Magic number: 0644*"
+      linters:
+        - gomnd
+    - text: "mnd: Magic number: 0400*"
+      linters:
+        - gomnd
+linters:
+  disable-all: true
+  enable:
+    - asciicheck
+    - bodyclose
+    - deadcode
+    - dogsled
+    - dupl
+    - errcheck
+    - exhaustive
+    - exportloopref
+    - gci
+    - gochecknoglobals
+    - gochecknoinits
+    - gocognit
+    - goconst
+    - gocritic
+    - gocyclo
+    - godot
+    - goerr113
+    - goheader
+    - goimports
+    - gomnd
+    - goprintffuncname
+    - gosec
+    - gosimple
+    - govet
+    - importas
+    - ineffassign
+    - lll
+    - misspell
+    - nakedret
+    - nestif
+    - nilerr
+    - noctx
+    - nolintlint
+    - prealloc
+    - predeclared
+    - revive
+    - rowserrcheck
+    - sqlclosecheck
+    - staticcheck
+    - structcheck
+    - thelper
+    - tparallel
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+    - varcheck
+    - whitespace
+
+run:
+  skip-dirs:
+    - .devcontainer
+    - .github
+    - doc

.travis.yml

@@ -1,20 +0,0 @@
-dist: xenial
-sudo: required
-git:
-  quiet: true
-  depth: 1
-env:
-  global:
-    - DOCKER_REPO=qmcgaw/private-internet-access
-before_install:
-  - curl -fsSL https://get.docker.com | sh
-  - echo '{"experimental":"enabled"}' | sudo tee /etc/docker/daemon.json
-  - mkdir -p $HOME/.docker
-  - echo '{"experimental":"enabled"}' | sudo tee $HOME/.docker/config.json
-  - sudo service docker start
-install:
-  - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-  - docker buildx create --name xbuilder --use
-script: bash ci.sh
-after_success:
-  - curl -X POST https://hooks.microbadger.com/images/$DOCKER_REPO/tQFy7AxtSUNANPe6aoVChYdsI_I= || exit 0

.vscode/extensions.json

@@ -1,8 +0,0 @@
-{
-    "recommendations": [
-        "shardulm94.trailing-spaces",
-        "ms-azuretools.vscode-docker",
-        "davidanson.vscode-markdownlint",
-        "IBM.output-colorizer"
-    ]
-}

Dockerfile

@@ -1,71 +1,176 @@
-ARG ALPINE_VERSION=3.11
-ARG GO_VERSION=1.13.7
-
-FROM golang:${GO_VERSION}-alpine${ALPINE_VERSION} AS builder
-RUN apk --update add git
-WORKDIR /tmp/gobuild
-ENV CGO_ENABLED=0
-COPY go.mod go.sum ./
-RUN go mod download 2>&1
-COPY internal/ ./internal/
-COPY cmd/main.go .
-RUN go test ./...
-RUN go build -ldflags="-s -w" -o entrypoint main.go
-
-FROM alpine:${ALPINE_VERSION}
-ARG VERSION
-ARG BUILD_DATE
-ARG VCS_REF
-ENV VERSION=$VERSION \
-    BUILD_DATE=$BUILD_DATE \
-    VCS_REF=$VCS_REF
-LABEL \
-    org.opencontainers.image.authors="quentin.mcgaw@gmail.com" \
-    org.opencontainers.image.created=$BUILD_DATE \
-    org.opencontainers.image.version=$VERSION \
-    org.opencontainers.image.revision=$VCS_REF \
-    org.opencontainers.image.url="https://github.com/qdm12/private-internet-access-docker" \
-    org.opencontainers.image.documentation="https://github.com/qdm12/private-internet-access-docker" \
-    org.opencontainers.image.source="https://github.com/qdm12/private-internet-access-docker" \
-    org.opencontainers.image.title="PIA client" \
-    org.opencontainers.image.description="VPN client to tunnel to private internet access servers using OpenVPN, IPtables, DNS over TLS and Alpine Linux"
-ENV USER= \
-    PASSWORD= \
-    ENCRYPTION=strong \
-    PROTOCOL=udp \
-    REGION="CA Montreal" \
-    DOT=on \
-    DOT_PROVIDERS=cloudflare \
-    DOT_PRIVATE_ADDRESS=127.0.0.1/8,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16,169.254.0.0/16,::1/128,fc00::/7,fe80::/10,::ffff:0:0/96 \
-    DOT_VERBOSITY=1 \
-    DOT_VERBOSITY_DETAILS=0 \
-    DOT_VALIDATION_LOGLEVEL=0 \
-    DOT_CACHING=on \
-    BLOCK_MALICIOUS=on \
-    BLOCK_SURVEILLANCE=off \
-    BLOCK_ADS=off \
-    UNBLOCK= \
-    EXTRA_SUBNETS= \
-    PORT_FORWARDING=off \
-    PORT_FORWARDING_STATUS_FILE="/forwarded_port" \
-    TINYPROXY=off \
-    TINYPROXY_LOG=Info \
-    TINYPROXY_PORT=8888 \
-    TINYPROXY_USER= \
-    TINYPROXY_PASSWORD= \
-    SHADOWSOCKS=off \
-    SHADOWSOCKS_LOG=on \
-    SHADOWSOCKS_PORT=8388 \
-    SHADOWSOCKS_PASSWORD= \
-    TZ=
-ENTRYPOINT /entrypoint
-EXPOSE 8888/tcp 8388/tcp 8388/udp
-HEALTHCHECK --interval=3m --timeout=3s --start-period=20s --retries=1 CMD /entrypoint healthcheck
-RUN apk add -q --progress --no-cache --update openvpn ca-certificates iptables unbound tinyproxy tzdata && \
-    echo "http://dl-cdn.alpinelinux.org/alpine/edge/testing" >> /etc/apk/repositories && \
-    apk add -q --progress --no-cache --update shadowsocks-libev && \
-    rm -rf /*.zip /var/cache/apk/* /etc/unbound/* /usr/sbin/unbound-anchor /usr/sbin/unbound-checkconf /usr/sbin/unbound-control /usr/sbin/unbound-control-setup /usr/sbin/unbound-host /etc/tinyproxy/tinyproxy.conf && \
-    adduser nonrootuser -D -H --uid 1000 && \
-    chown nonrootuser -R /etc/unbound /etc/tinyproxy && \
-    chmod 700 /etc/unbound /etc/tinyproxy
-COPY --from=builder --chown=1000:1000 /tmp/gobuild/entrypoint /entrypoint
+ARG ALPINE_VERSION=3.14
+ARG GO_ALPINE_VERSION=3.14
+ARG GO_VERSION=1.17
+ARG XCPUTRANSLATE_VERSION=v0.6.0
+ARG GOLANGCI_LINT_VERSION=v1.41.1
+ARG BUILDPLATFORM=linux/amd64
+
+FROM --platform=${BUILDPLATFORM} qmcgaw/xcputranslate:${XCPUTRANSLATE_VERSION} AS xcputranslate
+FROM --platform=${BUILDPLATFORM} qmcgaw/binpot:golangci-lint-${GOLANGCI_LINT_VERSION} AS golangci-lint
+
+FROM --platform=${BUILDPLATFORM} golang:${GO_VERSION}-alpine${GO_ALPINE_VERSION} AS base
+COPY --from=xcputranslate /xcputranslate /usr/local/bin/xcputranslate
+RUN apk --update add git g++
+ENV CGO_ENABLED=0
+COPY --from=golangci-lint /bin /go/bin/golangci-lint
+WORKDIR /tmp/gobuild
+COPY go.mod go.sum ./
+RUN go mod download
+COPY cmd/ ./cmd/
+COPY internal/ ./internal/
+
+FROM --platform=${BUILDPLATFORM} base AS test
+# Note on the go race detector:
+# - we set CGO_ENABLED=1 to have it enabled
+# - we installed g++ to support the race detector
+ENV CGO_ENABLED=1
+ENTRYPOINT go test -race -coverpkg=./... -coverprofile=coverage.txt -covermode=atomic ./...
+
+FROM --platform=${BUILDPLATFORM} base AS lint
+COPY .golangci.yml ./
+RUN golangci-lint run --timeout=10m
+
+FROM --platform=${BUILDPLATFORM} base AS tidy
+RUN git init && \
+    git config user.email ci@localhost && \
+    git config user.name ci && \
+    git add -A && git commit -m ci && \
+    sed -i '/\/\/ indirect/d' go.mod && \
+    go mod tidy && \
+    git diff --exit-code -- go.mod
+
+FROM --platform=${BUILDPLATFORM} base AS build
+ARG TARGETPLATFORM
+ARG VERSION=unknown
+ARG CREATED="an unknown date"
+ARG COMMIT=unknown
+RUN GOARCH="$(xcputranslate translate -field arch -targetplatform ${TARGETPLATFORM})" \
+    GOARM="$(xcputranslate translate -field arm -targetplatform ${TARGETPLATFORM})" \
+    go build -trimpath -ldflags="-s -w \
+    -X 'main.version=$VERSION' \
+    -X 'main.created=$CREATED' \
+    -X 'main.commit=$COMMIT' \
+    " -o entrypoint cmd/gluetun/main.go
+
+FROM alpine:${ALPINE_VERSION}
+ARG VERSION=unknown
+ARG CREATED="an unknown date"
+ARG COMMIT=unknown
+LABEL \
+    org.opencontainers.image.authors="quentin.mcgaw@gmail.com" \
+    org.opencontainers.image.created=$CREATED \
+    org.opencontainers.image.version=$VERSION \
+    org.opencontainers.image.revision=$COMMIT \
+    org.opencontainers.image.url="https://github.com/qdm12/gluetun" \
+    org.opencontainers.image.documentation="https://github.com/qdm12/gluetun" \
+    org.opencontainers.image.source="https://github.com/qdm12/gluetun" \
+    org.opencontainers.image.title="VPN swiss-knife like client for multiple VPN providers" \
+    org.opencontainers.image.description="VPN swiss-knife like client to tunnel to multiple VPN servers using OpenVPN, IPtables, DNS over TLS, Shadowsocks, an HTTP proxy and Alpine Linux"
+ENV VPNSP=pia \
+    VERSION_INFORMATION=on \
+    LOG_LEVEL=info \
+    VPN_TYPE=openvpn \
+    PROTOCOL=udp \
+    OPENVPN_VERSION=2.5 \
+    OPENVPN_VERBOSITY=1 \
+    OPENVPN_FLAGS= \
+    OPENVPN_ROOT=yes \
+    OPENVPN_TARGET_IP= \
+    OPENVPN_IPV6=off \
+    OPENVPN_CUSTOM_CONFIG= \
+    OPENVPN_INTERFACE=tun0 \
+    WIREGUARD_PRIVATE_KEY= \
+    WIREGUARD_PRESHARED_KEY= \
+    WIREGUARD_ADDRESS= \
+    WIREGUARD_PORT= \
+    WIREGUARD_INTERFACE=wg0 \
+    TZ= \
+    PUID= \
+    PGID= \
+    PUBLICIP_FILE="/tmp/gluetun/ip" \
+    # VPN provider settings
+    OPENVPN_USER= \
+    OPENVPN_PASSWORD= \
+    USER_SECRETFILE=/run/secrets/openvpn_user \
+    PASSWORD_SECRETFILE=/run/secrets/openvpn_password \
+    REGION= \
+    COUNTRY= \
+    CITY= \
+    PORT= \
+    SERVER_HOSTNAME= \
+    # Mullvad only:
+    ISP= \
+    OWNED=no \
+    # Private Internet Access only:
+    PIA_ENCRYPTION=strong \
+    PORT_FORWARDING=off \
+    PORT_FORWARDING_STATUS_FILE="/tmp/gluetun/forwarded_port" \
+    # Cyberghost only:
+    CYBERGHOST_GROUP="Premium UDP Europe" \
+    OPENVPN_CLIENTCRT_SECRETFILE=/run/secrets/openvpn_clientcrt \
+    OPENVPN_CLIENTKEY_SECRETFILE=/run/secrets/openvpn_clientkey \
+    # Nordvpn only:
+    SERVER_NUMBER= \
+    # NordVPN and ProtonVPN only:
+    SERVER_NAME= \
+    # ProtonVPN only:
+    FREE_ONLY= \
+    # Openvpn
+    OPENVPN_CIPHER= \
+    OPENVPN_AUTH= \
+    # Health
+    HEALTH_OPENVPN_DURATION_INITIAL=6s \
+    HEALTH_OPENVPN_DURATION_ADDITION=5s \
+    HEALTH_SERVER_ADDRESS=127.0.0.1:9999 \
+    # DNS over TLS
+    DOT=on \
+    DOT_PROVIDERS=cloudflare \
+    DOT_PRIVATE_ADDRESS=127.0.0.1/8,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16,169.254.0.0/16,::1/128,fc00::/7,fe80::/10,::ffff:7f00:1/104,::ffff:a00:0/104,::ffff:a9fe:0/112,::ffff:ac10:0/108,::ffff:c0a8:0/112 \
+    DOT_VERBOSITY=1 \
+    DOT_VERBOSITY_DETAILS=0 \
+    DOT_VALIDATION_LOGLEVEL=0 \
+    DOT_CACHING=on \
+    DOT_IPV6=off \
+    BLOCK_MALICIOUS=on \
+    BLOCK_SURVEILLANCE=off \
+    BLOCK_ADS=off \
+    UNBLOCK= \
+    DNS_UPDATE_PERIOD=24h \
+    DNS_PLAINTEXT_ADDRESS=1.1.1.1 \
+    DNS_KEEP_NAMESERVER=off \
+    # Firewall
+    FIREWALL=on \
+    FIREWALL_VPN_INPUT_PORTS= \
+    FIREWALL_INPUT_PORTS= \
+    FIREWALL_OUTBOUND_SUBNETS= \
+    FIREWALL_DEBUG=off \
+    # HTTP proxy
+    HTTPPROXY= \
+    HTTPPROXY_LOG=off \
+    HTTPPROXY_PORT=8888 \
+    HTTPPROXY_USER= \
+    HTTPPROXY_PASSWORD= \
+    HTTPPROXY_USER_SECRETFILE=/run/secrets/httpproxy_user \
+    HTTPPROXY_PASSWORD_SECRETFILE=/run/secrets/httpproxy_password \
+    # Shadowsocks
+    SHADOWSOCKS=off \
+    SHADOWSOCKS_LOG=off \
+    SHADOWSOCKS_ADDRESS=":8388" \
+    SHADOWSOCKS_PASSWORD= \
+    SHADOWSOCKS_PASSWORD_SECRETFILE=/run/secrets/shadowsocks_password \
+    SHADOWSOCKS_CIPHER=chacha20-ietf-poly1305 \
+    UPDATER_PERIOD=0
+ENTRYPOINT ["/entrypoint"]
+EXPOSE 8000/tcp 8888/tcp 8388/tcp 8388/udp
+HEALTHCHECK --interval=5s --timeout=5s --start-period=10s --retries=1 CMD /entrypoint healthcheck
+ARG TARGETPLATFORM
+RUN apk add --no-cache --update -l apk-tools && \
+    apk add --no-cache --update -X "https://dl-cdn.alpinelinux.org/alpine/v3.12/main" openvpn==2.4.11-r0 && \
+    mv /usr/sbin/openvpn /usr/sbin/openvpn2.4 && \
+    apk del openvpn && \
+    apk add --no-cache --update openvpn ca-certificates iptables ip6tables unbound tzdata && \
+    rm -rf /var/cache/apk/* /etc/unbound/* /usr/sbin/unbound-* /etc/openvpn/*.sh /usr/lib/openvpn/plugins/openvpn-plugin-down-root.so && \
+    deluser openvpn && \
+    deluser unbound && \
+    mkdir /gluetun
+COPY --from=build /tmp/gobuild/entrypoint /entrypoint

README.md

@@ -1,340 +1,122 @@
-# Private Internet Access Client
+# Gluetun VPN client
 
-*Lightweight swiss-knife-like VPN client to tunnel to private internet access servers, using OpenVPN, iptables, DNS over TLS, ShadowSocks, Tinyproxy and more*
+*Lightweight swiss-knife-like VPN client to tunnel to Cyberghost, FastestVPN,
+HideMyAss, IPVanish, IVPN, Mullvad, NordVPN, Privado, Private Internet Access, PrivateVPN,
+ProtonVPN, PureVPN, Surfshark, TorGuard, VPNUnlimited, VyprVPN and Windscribe VPN servers
+using Go, OpenVPN, iptables, DNS over TLS, ShadowSocks and an HTTP proxy*
 
-**ANNOUCEMENT**: *Total rewrite in Go: see the new features [below](#Features)* (in case something break use the image with tag `:old`)
+**ANNOUNCEMENT**: Wireguard is now supported for all providers supporting it!
 
-<a href="https://hub.docker.com/r/qmcgaw/private-internet-access">
-    <img width="100%" height="320" src="https://raw.githubusercontent.com/qdm12/private-internet-access-docker/master/title.svg?sanitize=true">
-</a>
+![Title image](https://raw.githubusercontent.com/qdm12/gluetun/master/title.svg)
 
-[![Build Status](https://travis-ci.org/qdm12/private-internet-access-docker.svg?branch=master)](https://travis-ci.org/qdm12/private-internet-access-docker)
-[![Docker Pulls](https://img.shields.io/docker/pulls/qmcgaw/private-internet-access.svg)](https://hub.docker.com/r/qmcgaw/private-internet-access)
-[![Docker Stars](https://img.shields.io/docker/stars/qmcgaw/private-internet-access.svg)](https://hub.docker.com/r/qmcgaw/private-internet-access)
+[![Build status](https://github.com/qdm12/gluetun/actions/workflows/ci.yml/badge.svg)](https://github.com/qdm12/gluetun/actions/workflows/ci.yml)
 
-[![GitHub last commit](https://img.shields.io/github/last-commit/qdm12/private-internet-access-docker.svg)](https://github.com/qdm12/private-internet-access-docker/issues)
-[![GitHub commit activity](https://img.shields.io/github/commit-activity/y/qdm12/private-internet-access-docker.svg)](https://github.com/qdm12/private-internet-access-docker/issues)
-[![GitHub issues](https://img.shields.io/github/issues/qdm12/private-internet-access-docker.svg)](https://github.com/qdm12/private-internet-access-docker/issues)
+[![Docker pulls qmcgaw/gluetun](https://img.shields.io/docker/pulls/qmcgaw/gluetun.svg)](https://hub.docker.com/r/qmcgaw/gluetun)
+[![Docker pulls qmcgaw/private-internet-access](https://img.shields.io/docker/pulls/qmcgaw/private-internet-access.svg)](https://hub.docker.com/r/qmcgaw/gluetun)
 
-[![Image size](https://images.microbadger.com/badges/image/qmcgaw/private-internet-access.svg)](https://microbadger.com/images/qmcgaw/private-internet-access)
-[![Image version](https://images.microbadger.com/badges/version/qmcgaw/private-internet-access.svg)](https://microbadger.com/images/qmcgaw/private-internet-access)
-[![Join Slack channel](https://img.shields.io/badge/slack-@qdm12-yellow.svg?logo=slack)](https://join.slack.com/t/qdm12/shared_invite/enQtOTE0NjcxNTM1ODc5LTYyZmVlOTM3MGI4ZWU0YmJkMjUxNmQ4ODQ2OTAwYzMxMTlhY2Q1MWQyOWUyNjc2ODliNjFjMDUxNWNmNzk5MDk)
+[![Docker stars qmcgaw/gluetun](https://img.shields.io/docker/stars/qmcgaw/gluetun.svg)](https://hub.docker.com/r/qmcgaw/gluetun)
+[![Docker stars qmcgaw/private-internet-access](https://img.shields.io/docker/stars/qmcgaw/private-internet-access.svg)](https://hub.docker.com/r/qmcgaw/gluetun)
 
-<details><summary>Click to show base components</summary><p>
+![Last release](https://img.shields.io/github/release/qdm12/gluetun?label=Last%20release)
+![Last Docker tag](https://img.shields.io/docker/v/qmcgaw/gluetun?sort=semver&label=Last%20Docker%20tag)
+[![Last release size](https://img.shields.io/docker/image-size/qmcgaw/gluetun?sort=semver&label=Last%20released%20image)](https://hub.docker.com/r/qmcgaw/gluetun/tags?page=1&ordering=last_updated)
+![GitHub last release date](https://img.shields.io/github/release-date/qdm12/gluetun?label=Last%20release%20date)
+![Commits since release](https://img.shields.io/github/commits-since/qdm12/gluetun/latest?sort=semver)
 
-- [Alpine 3.11](https://alpinelinux.org) for a tiny image (37MB of packages, 6.7MB of Go binary and 5.6MB for Alpine)
-- [OpenVPN 2.4.8](https://pkgs.alpinelinux.org/package/v3.11/main/x86_64/openvpn) to tunnel to PIA servers
-- [IPtables 1.8.3](https://pkgs.alpinelinux.org/package/v3.11/main/x86_64/iptables) enforces the container to communicate only through the VPN or with other containers in its virtual network (acts as a killswitch)
-- [Unbound 1.9.6](https://pkgs.alpinelinux.org/package/v3.11/main/x86_64/unbound) configured with Cloudflare's [1.1.1.1](https://1.1.1.1) DNS over TLS (configurable with 5 different providers)
-- [Files and blocking lists built periodically](https://github.com/qdm12/updated/tree/master/files) used with Unbound (see `BLOCK_MALICIOUS`, `BLOCK_SURVEILLANCE` and `BLOCK_ADS` environment variables)
-- [TinyProxy 1.10.0](https://pkgs.alpinelinux.org/package/v3.11/main/x86_64/tinyproxy)
-- [Shadowsocks 3.3.4](https://pkgs.alpinelinux.org/package/edge/testing/x86/shadowsocks-libev)
+[![Latest size](https://img.shields.io/docker/image-size/qmcgaw/gluetun/latest?label=Latest%20image)](https://hub.docker.com/r/qmcgaw/gluetun/tags)
 
-</p></details>
+[![GitHub last commit](https://img.shields.io/github/last-commit/qdm12/gluetun.svg)](https://github.com/qdm12/gluetun/commits/master)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/y/qdm12/gluetun.svg)](https://github.com/qdm12/gluetun/graphs/contributors)
+[![GitHub closed PRs](https://img.shields.io/github/issues-pr-closed/qdm12/gluetun.svg)](https://github.com/qdm12/gluetun/pulls?q=is%3Apr+is%3Aclosed)
+[![GitHub issues](https://img.shields.io/github/issues/qdm12/gluetun.svg)](https://github.com/qdm12/gluetun/issues)
+[![GitHub closed issues](https://img.shields.io/github/issues-closed/qdm12/gluetun.svg)](https://github.com/qdm12/gluetun/issues?q=is%3Aissue+is%3Aclosed)
+
+[![Lines of code](https://img.shields.io/tokei/lines/github/qdm12/gluetun)](https://github.com/qdm12/gluetun)
+![Code size](https://img.shields.io/github/languages/code-size/qdm12/gluetun)
+![GitHub repo size](https://img.shields.io/github/repo-size/qdm12/gluetun)
+![Go version](https://img.shields.io/github/go-mod/go-version/qdm12/gluetun)
+
+![Visitors count](https://visitor-badge.laobi.icu/badge?page_id=gluetun.readme)
+
+## Quick links
+
+- Problem or suggestion?
+  - [Start a discussion](https://github.com/qdm12/gluetun/discussions)
+  - [Create an issue](https://github.com/qdm12/gluetun/issues)
+  - [Check the Wiki](https://github.com/qdm12/gluetun/wiki)
+  - [Join the Slack channel](https://join.slack.com/t/qdm12/shared_invite/enQtOTE0NjcxNTM1ODc5LTYyZmVlOTM3MGI4ZWU0YmJkMjUxNmQ4ODQ2OTAwYzMxMTlhY2Q1MWQyOWUyNjc2ODliNjFjMDUxNWNmNzk5MDk)
+- Happy?
+  - Sponsor me on [github.com/sponsors/qdm12](https://github.com/sponsors/qdm12)
+  - Donate to [paypal.me/qmcgaw](https://www.paypal.me/qmcgaw)
+  - Drop me [an email](mailto:quentin.mcgaw@gmail.com)
+- Video:
+
+  [![Video Gif](https://i.imgur.com/CetWunc.gif)](https://youtu.be/0F6I03LQcI4)
 
 ## Features
 
-- **New features**
-    - Choice to block ads, malicious and surveillance at the DNS level
-    - All program output streams are merged (openvpn, unbound, shadowsocks, tinyproxy, etc.)
-    - Choice of DNS over TLS provider(s)
-    - Possibility of split horizon DNS by selecting multiple DNS over TLS providers
-    - Download block lists and cryptographic files at start instead of at build time
-    - Can work as a Kubernetes sidecar container, thanks @rorph
-    - Pick a random region if no region is given, thanks @rorph
-- <details><summary>Configure everything with environment variables</summary><p>
-
-    - [Destination region](https://www.privateinternetaccess.com/pages/network)
-    - Internet protocol
-    - Level of encryption
-    - PIA Username and password
-    - DNS over TLS
-    - DNS blocking: ads, malicious, surveillance
-    - Internal firewall
-    - Socks5 proxy
-    - Web HTTP proxy
-
-    </p></details>
-- Connect
-    - [Other containers to it](https://github.com/qdm12/private-internet-access-docker#connect-to-it)
-    - [LAN devices to it](https://github.com/qdm12/private-internet-access-docker#connect-to-it)
-- Killswitch using *iptables* to allow traffic only with needed PIA servers and LAN devices
-- Port forwarding
-- Compatible with amd64, i686 (32 bit), **ARM** 64 bit, ARM 32 bit v6 and v7, ppc64le and even that s390x 🎆
-- Sub programs drop root privileges once launched: Openvpn, Unbound, Shadowsocks, Tinyproxy
+- Based on Alpine 3.14 for a small Docker image of 31MB
+- Supports: **Cyberghost**, **FastestVPN**, **HideMyAss**, **IPVanish**, **IVPN**, **Mullvad**, **NordVPN**, **Privado**, **Private Internet Access**, **PrivateVPN**, **ProtonVPN**, **PureVPN**,  **Surfshark**, **TorGuard**, **VPNUnlimited**, **Vyprvpn**, **Windscribe** servers
+- Supports OpenVPN
+- Supports Wireguard for **Mullvad**, **Ivpn** and **Windscribe** (more in progress, see #134)
+- DNS over TLS baked in with service provider(s) of your choice
+- DNS fine blocking of malicious/ads/surveillance hostnames and IP addresses, with live update every 24 hours
+- Choose the vpn network protocol, `udp` or `tcp`
+- Built in firewall kill switch to allow traffic only with needed the VPN servers and LAN devices
+- Built in Shadowsocks proxy (protocol based on SOCKS5 with an encryption layer, tunnels TCP+UDP)
+- Built in HTTP proxy (tunnels HTTP and HTTPS through TCP)
+- [Connect other containers to it](https://github.com/qdm12/gluetun/wiki/Connect-to-gluetun)
+- [Connect LAN devices to it](https://github.com/qdm12/gluetun/wiki/Connect-to-gluetun)
+- Compatible with amd64, i686 (32 bit), **ARM** 64 bit, ARM 32 bit v6 and v7, and even ppc64le 🎆
+- VPN server side port forwarding for Private Internet Access and Vyprvpn
+- Possibility of split horizon DNS by selecting multiple DNS over TLS providers
+- Subprograms all drop root privileges once launched
+- Subprograms output streams are all merged together
+- Can work as a Kubernetes sidecar container, thanks @rorph
 
 ## Setup
 
-1. <details><summary>Requirements</summary><p>
+1. Ensure your `tun` kernel module is setup:
 
-    - A Private Internet Access **username** and **password** - [Sign up](https://www.privateinternetaccess.com/pages/buy-vpn/)
-    - Docker API 1.25 to support `init`
-    - If you use Docker Compose, docker-compose >= 1.22.0, to support `init: true`
-    - <details><summary>External firewall requirements, if you have one</summary><p>
-
-        - At start only
-            - Allow outbound TCP 443 to github.com and privateinternetaccess.com
-            - If `DOT=on`, allow outbound TCP 853 to 1.1.1.1 to allow Unbound to resolve the PIA domain name.
-            - If `DOT=off`, allow outbound UDP 53 to your DNS provider to resolve the PIA domain name.
-        - For UDP strong encryption, allow outbound UDP 1197 to the corresponding VPN server IPs
-        - For UDP normal encryption, allow outbound UDP 1198 to the corresponding VPN server IPs
-        - For TCP strong encryption, allow outbound TCP 501 to the corresponding VPN server IPs
-        - For TCP normal encryption, allow outbound TCP 502 to the corresponding VPN server IPs
-        - If `SHADOWSOCKS=on`, allow inbound TCP 8388 and UDP 8388 from your LAN
-        - If `TINYPROXY=on`, allow inbound TCP 8888 from your LAN
-
-    </p></details>
-
-    </p></details>
+    ```sh
+    sudo modprobe tun
+    # or, if you don't have modprobe, with
+    sudo insmod /lib/modules/tun.ko
+    ```
 
+1. Extra steps:
+    - [For Synology users](https://github.com/qdm12/gluetun/wiki/Synology-setup)
+    - [For 32 bit Operating systems (**Rasberry Pis**)](https://github.com/qdm12/gluetun/wiki/32-bit-setup)
 1. Launch the container with:
 
     ```bash
-    docker run -d --init --name=pia --cap-add=NET_ADMIN \
-    -e REGION="CA Montreal" -e USER=js89ds7 -e PASSWORD=8fd9s239G \
-    qmcgaw/private-internet-access
+    docker run -d --name gluetun --cap-add=NET_ADMIN \
+    -e VPNSP="private internet access" -e REGION="CA Montreal" \
+    -e OPENVPN_USER=js89ds7 -e OPENVPN_PASSWORD=8fd9s239G \
+    -v /yourpath:/gluetun \
+    qmcgaw/gluetun
     ```
 
-    or use [docker-compose.yml](https://github.com/qdm12/private-internet-access-docker/blob/master/docker-compose.yml) with:
+    or use [docker-compose.yml](https://github.com/qdm12/gluetun/blob/master/docker-compose.yml) with:
 
     ```bash
     docker-compose up -d
     ```
 
-    Note that you can:
-    - Change the many [environment variables](#environment-variables) available
-    - Use `-p 8888:8888/tcp` to access the HTTP web proxy (and put your LAN in `EXTRA_SUBNETS` environment variable)
-    - Use `-p 8388:8388/tcp -p 8388:8388/udp` to access the SOCKS5 proxy (and put your LAN in `EXTRA_SUBNETS` environment variable)
-    - Pass additional arguments to *openvpn* using Docker's command function (commands after the image name)
-1. You can update the image with `docker pull qmcgaw/private-internet-access:latest`. There are also docker tags available:
-    - `qmcgaw/private-internet-access:v1` linked to the [v1 release](https://github.com/qdm12/private-internet-access-docker/releases/tag/v1.0)
+    You should probably check the many [environment variables](https://github.com/qdm12/gluetun/wiki/Environment-variables) available to adapt the container to your needs.
 
-## Testing
+## Further setup
 
-Check the PIA IP address matches your expectations
+The following points are all optional but should give you insights on all the possibilities with this container.
 
-```sh
-docker run --rm --network=container:pia alpine:3.10 wget -qO- https://ipinfo.io
-```
-
-## Environment variables
-
-| Environment variable | Default | Description |
-| --- | --- | --- |
-| `REGION` | `CA Montreal` | One of the [PIA regions](https://www.privateinternetaccess.com/pages/network/) |
-| `PROTOCOL` | `udp` | `tcp` or `udp` |
-| `ENCRYPTION` | `strong` | `normal` or `strong` |
-| `USER` | | Your PIA username |
-| `PASSWORD` | | Your PIA password |
-| `DOT` | `on` | `on` or `off`, to activate DNS over TLS to 1.1.1.1 |
-| `DOT_PROVIDERS` | `cloudflare` | Comma delimited list of DNS over TLS providers from `cloudflare`, `google`, `quad9`, `quadrant`, `cleanbrowsing`, `securedns`, `libredns` |
-| `DOT_CACHING` | `on` | Unbound caching feature, `on` or `off` |
-| `DOT_PRIVATE_ADDRESS` | All IPv4 and IPv6 CIDRs private ranges | Comma separated list of CIDRs or single IP addresses. Note that the default setting prevents DNS rebinding |
-| `DOT_VERBOSITY` | `1` | Unbound verbosity level from `0` to `5` (full debug) |
-| `DOT_VERBOSITY_DETAILS` | `0` | Unbound details verbosity level from `0` to `4` |
-| `DOT_VALIDATION_LOGLEVEL` | `0` | Unbound validation log level from `0` to `2` |
-| `BLOCK_MALICIOUS` | `on` | `on` or `off`, blocks malicious hostnames and IPs |
-| `BLOCK_SURVEILLANCE` | `off` | `on` or `off`, blocks surveillance hostnames and IPs |
-| `BLOCK_ADS` | `off` | `on` or `off`, blocks ads hostnames and IPs |
-| `UNBLOCK` | | comma separated string (i.e. `web.com,web2.ca`) to unblock hostnames |
-| `EXTRA_SUBNETS` | | comma separated subnets allowed in the container firewall (i.e. `192.168.1.0/24,192.168.10.121,10.0.0.5/28`) |
-| `PORT_FORWARDING` | `off` | Set to `on` to forward a port on PIA server |
-| `PORT_FORWARDING_STATUS_FILE` | `/forwarded_port` | File path to store the forwarded port number |
-| `TINYPROXY` | `off` | `on` or `off`, to enable the internal HTTP proxy tinyproxy |
-| `TINYPROXY_LOG` | `Info` | `Info`, `Connect`, `Notice`, `Warning`, `Error` or `Critical` |
-| `TINYPROXY_PORT` | `8888` | `1024` to `65535` internal port for HTTP proxy |
-| `TINYPROXY_USER` | | Username to use to connect to the HTTP proxy |
-| `TINYPROXY_PASSWORD` | | Passsword to use to connect to the HTTP proxy |
-| `SHADOWSOCKS` | `off` | `on` or `off`, to enable the internal SOCKS5 proxy Shadowsocks |
-| `SHADOWSOCKS_LOG` | `on` | `on` or `off` to enable logging for Shadowsocks  |
-| `SHADOWSOCKS_PORT` | `8388` | `1024` to `65535` internal port for SOCKS5 proxy |
-| `SHADOWSOCKS_PASSWORD` | | Passsword to use to connect to the SOCKS5 proxy |
-| `TZ` | | Specify a timezone to use i.e. `Europe/London` |
-
-## Connect to it
-
-There are various ways to achieve this, depending on your use case.
-
-- <details><summary>Connect containers in the same docker-compose.yml as PIA</summary><p>
-
-    Add `network_mode: "service:pia"` to your *docker-compose.yml* (no need for `depends_on`)
-
-    </p></details>
-- <details><summary>Connect other containers to PIA</summary><p>
-
-    Add `--network=container:pia` when launching the container, provided PIA is already running
-
-    </p></details>
-- <details><summary>Connect containers from another docker-compose.yml</summary><p>
-
-    Add `network_mode: "container:pia"` to your *docker-compose.yml*, provided PIA is already running
-
-    </p></details>
-- <details><summary>Connect LAN devices through the built-in HTTP proxy *Tinyproxy* (i.e. with Chrome, Kodi, etc.)</summary><p>
-
-    You might want to use Shadowsocks instead which tunnels UDP as well as TCP, whereas Tinyproxy only tunnels TCP.
-
-    1. Setup a HTTP proxy client, such as [SwitchyOmega for Chrome](https://chrome.google.com/webstore/detail/proxy-switchyomega/padekgcemlokbadohgkifijomclgjgif?hl=en)
-    1. Ensure the PIA container is launched with:
-        - port `8888` published `-p 8888:8888/tcp`
-        - your LAN subnet, i.e. `192.168.1.0/24`, set as `-e EXTRA_SUBNETS=192.168.1.0/24`
-    1. With your HTTP proxy client, connect to the Docker host (i.e. `192.168.1.10`) on port `8888`. You need to enter your credentials if you set them with `TINYPROXY_USER` and `TINYPROXY_PASSWORD`.
-    1. If you set `TINYPROXY_LOG` to `Info`, more information will be logged in the Docker logs
-
-    </p></details>
-- <details><summary>Connect LAN devices through the built-in SOCKS5 proxy *Shadowsocks* (per app, system wide, etc.)</summary><p>
-
-    1. Setup a SOCKS5 proxy client, there is a list of [ShadowSocks clients for **all platforms**](https://shadowsocks.org/en/download/clients.html)
-        - **note** some clients do not tunnel UDP so your DNS queries will be done locally and not through PIA and its built in DNS over TLS
-        - Clients that support such UDP tunneling are, as far as I know:
-            - iOS: Potatso Lite
-            - OSX: ShadowsocksX
-            - Android: Shadowsocks by Max Lv
-    1. Ensure the PIA container is launched with:
-        - port `8388` published `-p 8388:8388/tcp -p 8388:8388/udp`
-        - your LAN subnet, i.e. `192.168.1.0/24`, set as `-e EXTRA_SUBNETS=192.168.1.0/24`
-    1. With your SOCKS5 proxy client
-        - Enter the Docker host (i.e. `192.168.1.10`) as the server IP
-        - Enter port TCP (and UDP, if available) `8388` as the server port
-        - Use the password you have set with `SHADOWSOCKS_PASSWORD`
-        - Choose the encryption method/algorithm `chacha20-ietf-poly1305`
-    1. If you set `SHADOWSOCKS_LOG` to `on`, more information will be logged in the Docker logs
-
-    </p></details>
-- <details><summary>Access ports of containers connected to PIA</summary><p>
-
-    In example, to access port `8000` of container `xyz`  and `9000` of container `abc` connected to PIA,
-    publish ports `8000` and `9000` for the PIA container and access them as you would with any other container
-
-    </p></details>
-- <details><summary>Access ports of containers connected to PIA, all in the same docker-compose.yml</summary><p>
-
-    In example, to access port `8000` of container `xyz`  and `9000` of container `abc` connected to PIA, publish port `8000` and `9000` for the PIA container.
-    The docker-compose.yml file would look like:
-
-    ```yml
-    version: '3.7'
-    services:
-      pia:
-        image: qmcgaw/private-internet-access
-        container_name: pia
-        init: true
-        cap_add:
-          - NET_ADMIN
-        environment:
-          - USER=js89ds7
-          - PASSWORD=8fd9s239G
-        ports:
-          - 8000:8000/tcp
-          - 9000:9000/tcp
-      abc:
-        image: abc
-        container_name: abc
-        network_mode: "service:pia"
-      xyz:
-        image: xyz
-        container_name: xyz
-        network_mode: "service:pia"
-    ```
-
-    </p></details>
-
-## Port forwarding
-
-By setting `PORT_FORWARDING` environment variable to `on`, the forwarded port will be read and written to the file specified in `PORT_FORWARDING_STATUS_FILE` (by default, this is set to `/forwarded_port`). If the location for this file does not exist, it will be created automatically.
-
-You can mount this file as a volume to read it from other containers.
-
-Note that not all regions support port forwarding.
-
-## For the paranoids
-
-- You can review the code which consists in:
-    - [Dockerfile](https://github.com/qdm12/private-internet-access-docker/blob/master/Dockerfile)
-    - [main.go](https://github.com/qdm12/private-internet-access-docker/blob/master/cmd/main.go), the main code entrypoint
-    - [internal package](https://github.com/qdm12/private-internet-access-docker/blob/master/internal)
-    - [github.com/qdm12/golibs](https://github.com/qdm12/golibs) dependency
-    - [github.com/qdm12/files](https://github.com/qdm12/files) for files downloaded at start (DNS root hints, block lists, etc.)
-- Build the image yourself:
-
-    ```bash
-    docker build -t qmcgaw/private-internet-access https://github.com/qdm12/private-internet-access-docker.git
-    ```
-
-- The download and parsing of all needed files is done at start (openvpn config files, Unbound files, block lists, etc.)
-- Use `-e ENCRYPTION=strong -e BLOCK_MALICIOUS=on`
-- You can test DNSSEC using [internet.nl/connection](https://www.internet.nl/connection/)
-- Check DNS leak tests with [https://www.dnsleaktest.com](https://www.dnsleaktest.com)
-- DNS Leaks tests might not work because of [this](https://github.com/qdm12/cloudflare-dns-server#verify-dns-connection) (*TLDR*: DNS server is a local caching intermediary)
-
-## Troubleshooting
-
-- If openvpn fails to start, you may need to:
-    - Install the tun kernel module on your host with `insmod /lib/modules/tun.ko` or `modprobe tun`
-    - Add `--device=/dev/net/tun` to your docker run command (equivalent for docker-compose, kubernetes, etc.)
-
-- Fallback to a previous Docker image tags:
-    - `v1` tag, stable shell scripting based (no support)
-    - `old` tag, latest shell scripting version (no support)
-    - `v2`... waiting for `latest` to become more stable
-
-- Fallback to a precise previous version
-    1. Clone the repository on your machine
-
-        ```sh
-        git clone https://github.com/qdm12/private-internet-access-docker.git pia
-        cd pia
-        ```
-
-    1. Look up which commit you want to go back to [here](https://github.com/qdm12/private-internet-access-docker/commits/master), i.e. `942cc7d4d10545b6f5f89c907b7dd1dbc39368e0`
-    1. Revert to this commit locally
-
-        ```sh
-        git reset --hard 942cc7d4d10545b6f5f89c907b7dd1dbc39368e0
-        ```
-
-    1. Build the Docker image
-
-        ```sh
-        docker build -t qmcgaw/private-internet-access .
-        ```
-
-## Development
-
-### Using VSCode and Docker
-
-1. Install [Docker](https://docs.docker.com/install)
-    - On Windows, share a drive with Docker Desktop and have the project on that partition
-1. With [Visual Studio Code](https://code.visualstudio.com/download), install the [remote containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers)
-1. In Visual Studio Code, press on `F1` and select `Remote-Containers: Open Folder in Container...`
-1. Your dev environment is ready to go!... and it's running in a container :+1:
-
-## TODOs
-
-- Support other VPN providers
-    - Mullvad
-    - Windscribe
-- Gotify support for notificactions
-- Periodic update of malicious block lists with Unbound restart
-- Improve healthcheck
-    - Check IP address belongs to selected region
-    - Check for DNS provider somehow if this is even possible
-- Support for other VPN protocols
-    - Wireguard (wireguard-go)
-- Show new versions/commits at start
-- Colors & emojis
-    - Setup
-    - Logging streams
-- More unit tests
-- Write in Go
-    - DNS over TLS to replace Unbound
-    - HTTP proxy to replace tinyproxy
-    - use [go-Shadowsocks2](https://github.com/shadowsocks/go-shadowsocks2)
-    - DNS over HTTPS, maybe use [github.com/likexian/doh-go](https://github.com/likexian/doh-go)
-    - use [iptables-go](https://github.com/coreos/go-iptables) to replace iptables
-    - wireguard-go
-    - Openvpn to replace openvpn
+- [Test your setup](https://github.com/qdm12/gluetun/wiki/Test-your-setup)
+- [How to connect other containers and devices to Gluetun](https://github.com/qdm12/gluetun/wiki/Connect-to-gluetun)
+- [How to use Wireguard](https://github.com/qdm12/gluetun/wiki/Wireguard)
+- [VPN server side port forwarding](https://github.com/qdm12/gluetun/wiki/Port-forwarding)
+- [HTTP control server](https://github.com/qdm12/gluetun/wiki/HTTP-Control-server) to automate things, restart Openvpn etc.
+- Update the image with `docker pull qmcgaw/gluetun:latest`. See this [Wiki document](https://github.com/qdm12/gluetun/wiki/Docker-image-tags) for Docker tags available.
+- Use [Docker secrets](https://github.com/qdm12/gluetun/wiki/Docker-secrets) to read your credentials instead of environment variables
 
 ## License
 
-This repository is under an [MIT license](https://github.com/qdm12/private-internet-access-docker/master/license)
+[![MIT](https://img.shields.io/github/license/qdm12/gluetun)](https://github.com/qdm12/gluetun/master/LICENSE)

ci.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-
-if [ "$TRAVIS_PULL_REQUEST" = "true" ] || [ "$TRAVIS_BRANCH" != "master" ]; then
-  docker buildx build \
-    --progress plain \
-    --platform=linux/amd64,linux/386,linux/arm64,linux/arm/v7,linux/arm/v6,linux/ppc64le,linux/s390x \
-    .
-  exit $?
-fi
-echo $DOCKER_PASSWORD | docker login -u qmcgaw --password-stdin &> /dev/null
-TAG="${TRAVIS_TAG:-latest}"
-echo "Building Docker images for \"$DOCKER_REPO:$TAG\""
-docker buildx build \
-    --progress plain \
-    --platform=linux/amd64,linux/386,linux/arm64,linux/arm/v7,linux/arm/v6,linux/ppc64le,linux/s390x \
-    --build-arg BUILD_DATE=`date -u +"%Y-%m-%dT%H:%M:%SZ"` \
-    --build-arg VCS_REF=`git rev-parse --short HEAD` \
-    --build-arg VERSION=$TAG \
-    -t $DOCKER_REPO:$TAG \
-    --push \
-    .

cmd/gluetun/main.go

@@ -0,0 +1,455 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/qdm12/dns/pkg/unbound"
+	"github.com/qdm12/gluetun/internal/alpine"
+	"github.com/qdm12/gluetun/internal/cli"
+	"github.com/qdm12/gluetun/internal/configuration"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/dns"
+	"github.com/qdm12/gluetun/internal/firewall"
+	"github.com/qdm12/gluetun/internal/healthcheck"
+	"github.com/qdm12/gluetun/internal/httpproxy"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/netlink"
+	"github.com/qdm12/gluetun/internal/openvpn"
+	"github.com/qdm12/gluetun/internal/portforward"
+	"github.com/qdm12/gluetun/internal/publicip"
+	"github.com/qdm12/gluetun/internal/routing"
+	"github.com/qdm12/gluetun/internal/server"
+	"github.com/qdm12/gluetun/internal/shadowsocks"
+	"github.com/qdm12/gluetun/internal/storage"
+	"github.com/qdm12/gluetun/internal/tun"
+	"github.com/qdm12/gluetun/internal/updater"
+	"github.com/qdm12/gluetun/internal/vpn"
+	"github.com/qdm12/golibs/command"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+	"github.com/qdm12/goshutdown"
+	"github.com/qdm12/gosplash"
+	"github.com/qdm12/updated/pkg/dnscrypto"
+)
+
+//nolint:gochecknoglobals
+var (
+	version = "unknown"
+	commit  = "unknown"
+	created = "an unknown date"
+)
+
+var (
+	errSetupRouting = errors.New("cannot setup routing")
+	errCreateUser   = errors.New("cannot create user")
+)
+
+func main() {
+	buildInfo := models.BuildInformation{
+		Version: version,
+		Commit:  commit,
+		Created: created,
+	}
+
+	background := context.Background()
+	signalCtx, stop := signal.NotifyContext(background, syscall.SIGINT, syscall.SIGTERM, os.Interrupt)
+	ctx, cancel := context.WithCancel(background)
+
+	logger := logging.New(logging.Settings{
+		Level: logging.LevelInfo,
+	})
+
+	args := os.Args
+	tun := tun.New()
+	netLinker := netlink.New()
+	cli := cli.New()
+	env := params.New()
+	cmder := command.NewCmder()
+
+	errorCh := make(chan error)
+	go func() {
+		errorCh <- _main(ctx, buildInfo, args, logger, env, tun, netLinker, cmder, cli)
+	}()
+
+	select {
+	case <-signalCtx.Done():
+		stop()
+		fmt.Println("")
+		logger.Warn("Caught OS signal, shutting down")
+		cancel()
+	case err := <-errorCh:
+		stop()
+		close(errorCh)
+		if err == nil { // expected exit such as healthcheck
+			os.Exit(0)
+		}
+		logger.Error(err.Error())
+		cancel()
+	}
+
+	const shutdownGracePeriod = 5 * time.Second
+	timer := time.NewTimer(shutdownGracePeriod)
+	select {
+	case <-errorCh:
+		if !timer.Stop() {
+			<-timer.C
+		}
+		logger.Info("Shutdown successful")
+	case <-timer.C:
+		logger.Warn("Shutdown timed out")
+	}
+
+	os.Exit(1)
+}
+
+var (
+	errCommandUnknown = errors.New("command is unknown")
+)
+
+//nolint:gocognit,gocyclo
+func _main(ctx context.Context, buildInfo models.BuildInformation,
+	args []string, logger logging.ParentLogger, env params.Interface,
+	tun tun.Interface, netLinker netlink.NetLinker, cmder command.RunStarter,
+	cli cli.CLIer) error {
+	if len(args) > 1 { // cli operation
+		switch args[1] {
+		case "healthcheck":
+			return cli.HealthCheck(ctx, env, logger)
+		case "clientkey":
+			return cli.ClientKey(args[2:])
+		case "openvpnconfig":
+			return cli.OpenvpnConfig(logger, env)
+		case "update":
+			return cli.Update(ctx, args[2:], logger)
+		default:
+			return fmt.Errorf("%w: %s", errCommandUnknown, args[1])
+		}
+	}
+
+	// TODO run this in a loop or in openvpn to reload from file without restarting
+	storageLogger := logger.NewChild(logging.Settings{Prefix: "storage: "})
+	storage, err := storage.New(storageLogger, constants.ServersData)
+	if err != nil {
+		return err
+	}
+	allServers := storage.GetServers()
+
+	var allSettings configuration.Settings
+	err = allSettings.Read(env, allServers,
+		logger.NewChild(logging.Settings{Prefix: "configuration: "}))
+	if err != nil {
+		return err
+	}
+	logger.PatchLevel(allSettings.Log.Level)
+
+	puid, pgid := allSettings.System.PUID, allSettings.System.PGID
+
+	const clientTimeout = 15 * time.Second
+	httpClient := &http.Client{Timeout: clientTimeout}
+	// Create configurators
+	alpineConf := alpine.New()
+	ovpnConf := openvpn.New(
+		logger.NewChild(logging.Settings{Prefix: "openvpn configurator: "}),
+		cmder, puid, pgid)
+	dnsCrypto := dnscrypto.New(httpClient, "", "")
+	const cacertsPath = "/etc/ssl/certs/ca-certificates.crt"
+	dnsConf := unbound.NewConfigurator(nil, cmder, dnsCrypto,
+		"/etc/unbound", "/usr/sbin/unbound", cacertsPath)
+
+	announcementExp, err := time.Parse(time.RFC3339, "2021-10-02T00:00:00Z")
+	if err != nil {
+		return err
+	}
+	splashSettings := gosplash.Settings{
+		User:         "qdm12",
+		Repository:   "gluetun",
+		Emails:       []string{"quentin.mcgaw@gmail.com"},
+		Version:      buildInfo.Version,
+		Commit:       buildInfo.Commit,
+		BuildDate:    buildInfo.Created,
+		Announcement: "Wireguard is now supported for Mullvad, IVPN and Windscribe!",
+		AnnounceExp:  announcementExp,
+		// Sponsor information
+		PaypalUser:    "qmcgaw",
+		GithubSponsor: "qdm12",
+	}
+	for _, line := range gosplash.MakeLines(splashSettings) {
+		fmt.Println(line)
+	}
+
+	err = printVersions(ctx, logger, []printVersionElement{
+		{name: "Alpine", getVersion: alpineConf.Version},
+		{name: "OpenVPN 2.4", getVersion: ovpnConf.Version24},
+		{name: "OpenVPN 2.5", getVersion: ovpnConf.Version25},
+		{name: "Unbound", getVersion: dnsConf.Version},
+		{name: "IPtables", getVersion: func(ctx context.Context) (version string, err error) {
+			return firewall.Version(ctx, cmder)
+		}},
+	})
+	if err != nil {
+		return err
+	}
+
+	logger.Info(allSettings.String())
+
+	if err := os.MkdirAll("/tmp/gluetun", 0644); err != nil {
+		return err
+	}
+	if err := os.MkdirAll("/gluetun", 0644); err != nil {
+		return err
+	}
+
+	const defaultUsername = "nonrootuser"
+	nonRootUsername, err := alpineConf.CreateUser(defaultUsername, puid)
+	if err != nil {
+		return fmt.Errorf("%w: %s", errCreateUser, err)
+	}
+	if nonRootUsername != defaultUsername {
+		logger.Info("using existing username " + nonRootUsername + " corresponding to user id " + fmt.Sprint(puid))
+	}
+	// set it for Unbound
+	// TODO remove this when migrating to qdm12/dns v2
+	allSettings.DNS.Unbound.Username = nonRootUsername
+	allSettings.VPN.OpenVPN.ProcUser = nonRootUsername
+
+	if err := os.Chown("/etc/unbound", puid, pgid); err != nil {
+		return err
+	}
+
+	firewallLogLevel := allSettings.Log.Level
+	if allSettings.Firewall.Debug {
+		firewallLogLevel = logging.LevelDebug
+	}
+	routingLogger := logger.NewChild(logging.Settings{
+		Prefix: "routing: ",
+		Level:  firewallLogLevel,
+	})
+	routingConf := routing.New(netLinker, routingLogger)
+
+	defaultInterface, defaultGateway, err := routingConf.DefaultRoute()
+	if err != nil {
+		return err
+	}
+
+	localNetworks, err := routingConf.LocalNetworks()
+	if err != nil {
+		return err
+	}
+
+	defaultIP, err := routingConf.DefaultIP()
+	if err != nil {
+		return err
+	}
+
+	firewallLogger := logger.NewChild(logging.Settings{
+		Prefix: "firewall: ",
+		Level:  firewallLogLevel,
+	})
+	firewallConf := firewall.NewConfig(firewallLogger, cmder,
+		defaultInterface, defaultGateway, localNetworks, defaultIP)
+
+	if err := routingConf.Setup(); err != nil {
+		if strings.Contains(err.Error(), "operation not permitted") {
+			logger.Warn("💡 Tip: Are you passing NET_ADMIN capability to gluetun?")
+		}
+		return fmt.Errorf("%w: %s", errSetupRouting, err)
+	}
+	defer func() {
+		logger.Info("routing cleanup...")
+		if err := routingConf.TearDown(); err != nil {
+			logger.Error("cannot teardown routing: " + err.Error())
+		}
+	}()
+
+	if err := firewallConf.SetOutboundSubnets(ctx, allSettings.Firewall.OutboundSubnets); err != nil {
+		return err
+	}
+	if err := routingConf.SetOutboundRoutes(allSettings.Firewall.OutboundSubnets); err != nil {
+		return err
+	}
+
+	if err := tun.Check(constants.TunnelDevice); err != nil {
+		logger.Info(err.Error() + "; creating it...")
+		err = tun.Create(constants.TunnelDevice)
+		if err != nil {
+			return err
+		}
+	}
+
+	if allSettings.Firewall.Enabled {
+		err := firewallConf.SetEnabled(ctx, true) // disabled by default
+		if err != nil {
+			return err
+		}
+	}
+
+	for _, vpnPort := range allSettings.Firewall.VPNInputPorts {
+		vpnIntf := allSettings.VPN.VPNInterface()
+		err = firewallConf.SetAllowedPort(ctx, vpnPort, vpnIntf)
+		if err != nil {
+			return err
+		}
+	}
+
+	for _, port := range allSettings.Firewall.InputPorts {
+		err = firewallConf.SetAllowedPort(ctx, port, defaultInterface)
+		if err != nil {
+			return err
+		}
+	} // TODO move inside firewall?
+
+	// Shutdown settings
+	const defaultShutdownTimeout = 400 * time.Millisecond
+	defaultShutdownOnSuccess := func(goRoutineName string) {
+		logger.Info(goRoutineName + ": terminated ✔️")
+	}
+	defaultShutdownOnFailure := func(goRoutineName string, err error) {
+		logger.Warn(goRoutineName + ": " + err.Error() + " ⚠️")
+	}
+	defaultGoRoutineSettings := goshutdown.GoRoutineSettings{Timeout: defaultShutdownTimeout}
+	defaultGroupSettings := goshutdown.GroupSettings{
+		Timeout:   defaultShutdownTimeout,
+		OnSuccess: defaultShutdownOnSuccess,
+	}
+
+	controlGroupHandler := goshutdown.NewGroupHandler("control", defaultGroupSettings)
+	tickersGroupHandler := goshutdown.NewGroupHandler("tickers", defaultGroupSettings)
+	otherGroupHandler := goshutdown.NewGroupHandler("other", defaultGroupSettings)
+
+	portForwardLogger := logger.NewChild(logging.Settings{Prefix: "port forwarding: "})
+	portForwardLooper := portforward.NewLoop(allSettings.VPN.Provider.PortForwarding,
+		httpClient, firewallConf, portForwardLogger)
+	portForwardHandler, portForwardCtx, portForwardDone := goshutdown.NewGoRoutineHandler(
+		"port forwarding", goshutdown.GoRoutineSettings{Timeout: time.Second})
+	go portForwardLooper.Run(portForwardCtx, portForwardDone)
+
+	unboundLogger := logger.NewChild(logging.Settings{Prefix: "dns over tls: "})
+	unboundLooper := dns.NewLoop(dnsConf, allSettings.DNS, httpClient,
+		unboundLogger)
+	dnsHandler, dnsCtx, dnsDone := goshutdown.NewGoRoutineHandler(
+		"unbound", defaultGoRoutineSettings)
+	// wait for unboundLooper.Restart or its ticker launched with RunRestartTicker
+	go unboundLooper.Run(dnsCtx, dnsDone)
+	otherGroupHandler.Add(dnsHandler)
+
+	dnsTickerHandler, dnsTickerCtx, dnsTickerDone := goshutdown.NewGoRoutineHandler(
+		"dns ticker", defaultGoRoutineSettings)
+	go unboundLooper.RunRestartTicker(dnsTickerCtx, dnsTickerDone)
+	controlGroupHandler.Add(dnsTickerHandler)
+
+	publicIPLooper := publicip.NewLoop(httpClient,
+		logger.NewChild(logging.Settings{Prefix: "ip getter: "}),
+		allSettings.PublicIP, puid, pgid)
+	pubIPHandler, pubIPCtx, pubIPDone := goshutdown.NewGoRoutineHandler(
+		"public IP", defaultGoRoutineSettings)
+	go publicIPLooper.Run(pubIPCtx, pubIPDone)
+	otherGroupHandler.Add(pubIPHandler)
+
+	pubIPTickerHandler, pubIPTickerCtx, pubIPTickerDone := goshutdown.NewGoRoutineHandler(
+		"public IP", defaultGoRoutineSettings)
+	go publicIPLooper.RunRestartTicker(pubIPTickerCtx, pubIPTickerDone)
+	tickersGroupHandler.Add(pubIPTickerHandler)
+
+	vpnLogger := logger.NewChild(logging.Settings{Prefix: "vpn: "})
+	vpnLooper := vpn.NewLoop(allSettings.VPN,
+		allServers, ovpnConf, netLinker, firewallConf, routingConf, portForwardLooper,
+		cmder, publicIPLooper, unboundLooper, vpnLogger, httpClient,
+		buildInfo, allSettings.VersionInformation)
+	vpnHandler, vpnCtx, vpnDone := goshutdown.NewGoRoutineHandler(
+		"vpn", goshutdown.GoRoutineSettings{Timeout: time.Second})
+	go vpnLooper.Run(vpnCtx, vpnDone)
+
+	updaterLooper := updater.NewLooper(allSettings.Updater,
+		allServers, storage, vpnLooper.SetServers, httpClient,
+		logger.NewChild(logging.Settings{Prefix: "updater: "}))
+	updaterHandler, updaterCtx, updaterDone := goshutdown.NewGoRoutineHandler(
+		"updater", defaultGoRoutineSettings)
+	// wait for updaterLooper.Restart() or its ticket launched with RunRestartTicker
+	go updaterLooper.Run(updaterCtx, updaterDone)
+	tickersGroupHandler.Add(updaterHandler)
+
+	updaterTickerHandler, updaterTickerCtx, updaterTickerDone := goshutdown.NewGoRoutineHandler(
+		"updater ticker", defaultGoRoutineSettings)
+	go updaterLooper.RunRestartTicker(updaterTickerCtx, updaterTickerDone)
+	controlGroupHandler.Add(updaterTickerHandler)
+
+	httpProxyLooper := httpproxy.NewLoop(
+		logger.NewChild(logging.Settings{Prefix: "http proxy: "}),
+		allSettings.HTTPProxy)
+	httpProxyHandler, httpProxyCtx, httpProxyDone := goshutdown.NewGoRoutineHandler(
+		"http proxy", defaultGoRoutineSettings)
+	go httpProxyLooper.Run(httpProxyCtx, httpProxyDone)
+	otherGroupHandler.Add(httpProxyHandler)
+
+	shadowsocksLooper := shadowsocks.NewLooper(allSettings.ShadowSocks,
+		logger.NewChild(logging.Settings{Prefix: "shadowsocks: "}))
+	shadowsocksHandler, shadowsocksCtx, shadowsocksDone := goshutdown.NewGoRoutineHandler(
+		"shadowsocks proxy", defaultGoRoutineSettings)
+	go shadowsocksLooper.Run(shadowsocksCtx, shadowsocksDone)
+	otherGroupHandler.Add(shadowsocksHandler)
+
+	controlServerAddress := ":" + strconv.Itoa(int(allSettings.ControlServer.Port))
+	controlServerLogging := allSettings.ControlServer.Log
+	httpServerHandler, httpServerCtx, httpServerDone := goshutdown.NewGoRoutineHandler(
+		"http server", defaultGoRoutineSettings)
+	httpServer := server.New(httpServerCtx, controlServerAddress, controlServerLogging,
+		logger.NewChild(logging.Settings{Prefix: "http server: "}),
+		buildInfo, vpnLooper, portForwardLooper, unboundLooper, updaterLooper, publicIPLooper)
+	go httpServer.Run(httpServerCtx, httpServerDone)
+	controlGroupHandler.Add(httpServerHandler)
+
+	healthLogger := logger.NewChild(logging.Settings{Prefix: "healthcheck: "})
+	healthcheckServer := healthcheck.NewServer(allSettings.Health, healthLogger, vpnLooper)
+	healthServerHandler, healthServerCtx, healthServerDone := goshutdown.NewGoRoutineHandler(
+		"HTTP health server", defaultGoRoutineSettings)
+	go healthcheckServer.Run(healthServerCtx, healthServerDone)
+
+	const orderShutdownTimeout = 3 * time.Second
+	orderSettings := goshutdown.OrderSettings{
+		Timeout:   orderShutdownTimeout,
+		OnFailure: defaultShutdownOnFailure,
+		OnSuccess: defaultShutdownOnSuccess,
+	}
+	orderHandler := goshutdown.NewOrder("gluetun", orderSettings)
+	orderHandler.Append(controlGroupHandler, tickersGroupHandler, healthServerHandler,
+		vpnHandler, portForwardHandler, otherGroupHandler)
+
+	// Start VPN for the first time in a blocking call
+	// until the VPN is launched
+	_, _ = vpnLooper.ApplyStatus(ctx, constants.Running) // TODO option to disable with variable
+
+	<-ctx.Done()
+
+	return orderHandler.Shutdown(context.Background())
+}
+
+type printVersionElement struct {
+	name       string
+	getVersion func(ctx context.Context) (version string, err error)
+}
+
+func printVersions(ctx context.Context, logger logging.Logger,
+	elements []printVersionElement) (err error) {
+	const timeout = 5 * time.Second
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	for _, element := range elements {
+		version, err := element.getVersion(ctx)
+		if err != nil {
+			return err
+		}
+		logger.Info(element.name + " version: " + version)
+	}
+
+	return nil
+}

cmd/main.go

@@ -1,190 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"net"
-	"os"
-	"time"
-
-	"github.com/qdm12/golibs/command"
-	"github.com/qdm12/golibs/files"
-	libhealthcheck "github.com/qdm12/golibs/healthcheck"
-	"github.com/qdm12/golibs/logging"
-	"github.com/qdm12/golibs/network"
-	"github.com/qdm12/golibs/signals"
-	"github.com/qdm12/private-internet-access-docker/internal/constants"
-	"github.com/qdm12/private-internet-access-docker/internal/dns"
-	"github.com/qdm12/private-internet-access-docker/internal/env"
-	"github.com/qdm12/private-internet-access-docker/internal/firewall"
-	"github.com/qdm12/private-internet-access-docker/internal/healthcheck"
-	"github.com/qdm12/private-internet-access-docker/internal/openvpn"
-	"github.com/qdm12/private-internet-access-docker/internal/params"
-	"github.com/qdm12/private-internet-access-docker/internal/pia"
-	"github.com/qdm12/private-internet-access-docker/internal/settings"
-	"github.com/qdm12/private-internet-access-docker/internal/shadowsocks"
-	"github.com/qdm12/private-internet-access-docker/internal/splash"
-	"github.com/qdm12/private-internet-access-docker/internal/tinyproxy"
-)
-
-const (
-	uid, gid = 1000, 1000
-)
-
-func main() {
-	logger, err := logging.NewLogger(logging.ConsoleEncoding, logging.InfoLevel, -1)
-	if err != nil {
-		panic(err)
-	}
-	if libhealthcheck.Mode(os.Args) {
-		if err := healthcheck.HealthCheck(); err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		os.Exit(0)
-	}
-	paramsReader := params.NewParamsReader(logger)
-	fmt.Println(splash.Splash(paramsReader))
-	e := env.New(logger)
-	client := network.NewClient(15 * time.Second)
-	// Create configurators
-	fileManager := files.NewFileManager()
-	ovpnConf := openvpn.NewConfigurator(logger, fileManager)
-	dnsConf := dns.NewConfigurator(logger, client, fileManager)
-	firewallConf := firewall.NewConfigurator(logger, fileManager)
-	piaConf := pia.NewConfigurator(client, fileManager, firewallConf, logger)
-	tinyProxyConf := tinyproxy.NewConfigurator(fileManager, logger)
-	shadowsocksConf := shadowsocks.NewConfigurator(fileManager, logger)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	streamMerger := command.NewStreamMerger(ctx)
-
-	e.PrintVersion("OpenVPN", ovpnConf.Version)
-	e.PrintVersion("Unbound", dnsConf.Version)
-	e.PrintVersion("IPtables", firewallConf.Version)
-	e.PrintVersion("TinyProxy", tinyProxyConf.Version)
-	e.PrintVersion("ShadowSocks", shadowsocksConf.Version)
-
-	allSettings, err := settings.GetAllSettings(paramsReader)
-	e.FatalOnError(err)
-	logger.Info(allSettings.String())
-
-	if err := ovpnConf.CheckTUN(); err != nil {
-		logger.Warn(err)
-		err = ovpnConf.CreateTUN()
-		e.FatalOnError(err)
-	}
-
-	err = ovpnConf.WriteAuthFile(allSettings.PIA.User, allSettings.PIA.Password, uid, gid)
-	e.FatalOnError(err)
-
-	// Temporarily reset chain policies allowing Kubernetes sidecar to
-	// successfully restart the container. Without this, the existing rules will
-	// pre-exist, preventing the nslookup of the PIA region address. These will
-	// simply be redundant at Docker runtime as they will already be set this way
-	// Thanks to @npawelek https://github.com/npawelek
-	err = firewallConf.AcceptAll()
-	e.FatalOnError(err)
-
-	go func() {
-		// Blocking line merging reader for all programs: openvpn, tinyproxy, unbound and shadowsocks
-		logger.Info("Launching standard output merger")
-		err = streamMerger.CollectLines(func(line string) { logger.Info(line) })
-		e.FatalOnError(err)
-	}()
-
-	if allSettings.DNS.Enabled {
-		initialDNSToUse := constants.DNSProviderMapping()[allSettings.DNS.Providers[0]]
-		dnsConf.UseDNSInternally(initialDNSToUse.IPs[0])
-		err = dnsConf.DownloadRootHints(uid, gid)
-		e.FatalOnError(err)
-		err = dnsConf.DownloadRootKey(uid, gid)
-		e.FatalOnError(err)
-		err = dnsConf.MakeUnboundConf(allSettings.DNS, uid, gid)
-		e.FatalOnError(err)
-		stream, waitFn, err := dnsConf.Start(allSettings.DNS.VerbosityDetailsLevel)
-		e.FatalOnError(err)
-		go func() {
-			e.FatalOnError(waitFn())
-		}()
-		go streamMerger.Merge("unbound", stream)
-		dnsConf.UseDNSInternally(net.IP{127, 0, 0, 1})       // use Unbound
-		err = dnsConf.UseDNSSystemWide(net.IP{127, 0, 0, 1}) // use Unbound
-		e.FatalOnError(err)
-		err = dnsConf.WaitForUnbound()
-		e.FatalOnError(err)
-	}
-
-	VPNIPs, port, err := piaConf.BuildConf(allSettings.PIA.Region, allSettings.OpenVPN.NetworkProtocol, allSettings.PIA.Encryption, uid, gid)
-	e.FatalOnError(err)
-
-	defaultInterface, defaultGateway, defaultSubnet, err := firewallConf.GetDefaultRoute()
-	e.FatalOnError(err)
-	err = firewallConf.AddRoutesVia(allSettings.Firewall.AllowedSubnets, defaultGateway, defaultInterface)
-	e.FatalOnError(err)
-	err = firewallConf.Clear()
-	e.FatalOnError(err)
-	err = firewallConf.BlockAll()
-	e.FatalOnError(err)
-	err = firewallConf.CreateGeneralRules()
-	e.FatalOnError(err)
-	err = firewallConf.CreateVPNRules(constants.TUN, VPNIPs, defaultInterface, port, allSettings.OpenVPN.NetworkProtocol)
-	e.FatalOnError(err)
-	err = firewallConf.CreateLocalSubnetsRules(defaultSubnet, allSettings.Firewall.AllowedSubnets, defaultInterface)
-	e.FatalOnError(err)
-
-	if allSettings.TinyProxy.Enabled {
-		err = tinyProxyConf.MakeConf(allSettings.TinyProxy.LogLevel, allSettings.TinyProxy.Port, allSettings.TinyProxy.User, allSettings.TinyProxy.Password, uid, gid)
-		e.FatalOnError(err)
-		err = firewallConf.AllowAnyIncomingOnPort(allSettings.TinyProxy.Port)
-		e.FatalOnError(err)
-		stream, waitFn, err := tinyProxyConf.Start()
-		e.FatalOnError(err)
-		go func() {
-			if err := waitFn(); err != nil {
-				logger.Error(err)
-			}
-		}()
-		go streamMerger.Merge("tinyproxy", stream)
-	}
-
-	if allSettings.ShadowSocks.Enabled {
-		err = shadowsocksConf.MakeConf(allSettings.ShadowSocks.Port, allSettings.ShadowSocks.Password, uid, gid)
-		e.FatalOnError(err)
-		err = firewallConf.AllowAnyIncomingOnPort(allSettings.ShadowSocks.Port)
-		e.FatalOnError(err)
-		stream, waitFn, err := shadowsocksConf.Start("0.0.0.0", allSettings.ShadowSocks.Port, allSettings.ShadowSocks.Password, allSettings.ShadowSocks.Log)
-		e.FatalOnError(err)
-		go func() {
-			if err := waitFn(); err != nil {
-				logger.Error(err)
-			}
-		}()
-		go streamMerger.Merge("shadowsocks", stream)
-	}
-
-	if allSettings.PIA.PortForwarding.Enabled {
-		time.AfterFunc(10*time.Second, func() {
-			port, err := piaConf.GetPortForward()
-			if err != nil {
-				logger.Error("port forwarding:", err)
-			}
-			if err := piaConf.WritePortForward(allSettings.PIA.PortForwarding.Filepath, port); err != nil {
-				logger.Error("port forwarding:", err)
-			}
-			if err := piaConf.AllowPortForwardFirewall(constants.TUN, port); err != nil {
-				logger.Error("port forwarding:", err)
-			}
-		})
-	}
-
-	stream, waitFn, err := ovpnConf.Start()
-	e.FatalOnError(err)
-	go streamMerger.Merge("openvpn", stream)
-	go signals.WaitForExit(func(signal string) int {
-		logger.Warn("Caught OS signal %s, shutting down", signal)
-		time.Sleep(100 * time.Millisecond) // wait for other processes to exit
-		return 0
-	})
-	e.FatalOnError(waitFn())
-}

docker-compose.yml

@@ -1,37 +1,25 @@
 version: "3.7"
 services:
-  pia:
-    build: https://github.com/qdm12/private-internet-access-docker.git
-    image: qmcgaw/private-internet-access
-    container_name: pia
+  gluetun:
+    image: qmcgaw/gluetun
+    container_name: gluetun
     cap_add:
       - NET_ADMIN
     network_mode: bridge
-    init: true
     ports:
-      - 8888:8888/tcp
-      - 8388:8388/tcp
-      - 8388:8388/udp
+      - 8888:8888/tcp # HTTP proxy
+      - 8388:8388/tcp # Shadowsocks
+      - 8388:8388/udp # Shadowsocks
+      - 8000:8000/tcp # Built-in HTTP control server
     # command:
+    volumes:
+      - /yourpath:/gluetun
     environment:
-      - USER=js89ds7
-      - PASSWORD=8fd9s239G
-      - ENCRYPTION=strong
-      - PROTOCOL=udp
-      - REGION=CA Montreal
-      - DOT=on
-      - DOT_PROVIDERS=cloudflare
-      - BLOCK_MALICIOUS=on
-      - BLOCK_SURVEILLANCE=off
-      - BLOCK_ADS=off
-      - UNBLOCK=
-      - EXTRA_SUBNETS=
-      - TINYPROXY=off
-      - TINYPROXY_LOG=Info
-      - TINYPROXY_USER=
-      - TINYPROXY_PASSWORD=
-      - SHADOWSOCKS=off
-      - SHADOWSOCKS_LOG=on
-      - SHADOWSOCKS_PORT=8388
-      - SHADOWSOCKS_PASSWORD=
+      # More variables are available, see the Wiki table
+      - OPENVPN_USER=
+      - OPENVPN_PASSWORD=
+      - VPNSP=private internet access
+      - VPN_TYPE=openvpn
+      # Timezone for accurate logs times
+      - TZ=
     restart: always

go.mod

@@ -1,10 +1,40 @@
-module github.com/qdm12/private-internet-access-docker
+module github.com/qdm12/gluetun
 
-go 1.13
+go 1.17
 
 require (
-	github.com/kyokomi/emoji v2.1.0+incompatible
-	github.com/qdm12/golibs v0.0.0-20200208153322-66b2eb719e21
-	github.com/stretchr/testify v1.4.0
-	golang.org/x/sys v0.0.0-20190412213103-97732733099d
+	github.com/fatih/color v1.12.0
+	github.com/golang/mock v1.6.0
+	github.com/qdm12/dns v1.11.0
+	github.com/qdm12/golibs v0.0.0-20210822203818-5c568b0777b6
+	github.com/qdm12/goshutdown v0.1.0
+	github.com/qdm12/gosplash v0.1.0
+	github.com/qdm12/ss-server v0.3.0
+	github.com/qdm12/updated v0.0.0-20210603204757-205acfe6937e
+	github.com/stretchr/testify v1.7.0
+	github.com/vishvananda/netlink v1.1.0
+	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c
+	golang.zx2c4.com/wireguard v0.0.0-20210805125648-3957e9b9dd19
+	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20210803171230-4253848d036c
+	inet.af/netaddr v0.0.0-20210718074554-06ca8145d722
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/google/go-cmp v0.5.5 // indirect
+	github.com/josharian/native v0.0.0-20200817173448-b6b71def0850 // indirect
+	github.com/mattn/go-colorable v0.1.8 // indirect
+	github.com/mattn/go-isatty v0.0.12 // indirect
+	github.com/mdlayher/genetlink v1.0.0 // indirect
+	github.com/mdlayher/netlink v1.4.0 // indirect
+	github.com/miekg/dns v1.1.40 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/riobard/go-bloom v0.0.0-20200614022211-cdc8013cb5b3 // indirect
+	github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df // indirect
+	go4.org/intern v0.0.0-20210108033219-3eb7198706b2 // indirect
+	go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063 // indirect
+	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 // indirect
+	golang.org/x/net v0.0.0-20210504132125-bbd867fde50d // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 )

go.sum

@@ -1,113 +1,241 @@
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/PuerkitoBio/purell v1.1.0 h1:rmGxhojJlM0tuKtfdvliR84CFHljx9ag64t2xmVkjK4=
 github.com/PuerkitoBio/purell v1.1.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
-github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M=
 github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
-github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf h1:eg0MeVzsP1G42dRafH3vf+al2vQIJU0YHX+1Tw87oco=
+github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb h1:D4uzjWwKYQ5XnAvUbuvHW93esHg7F8N/OYeBBcJoTr0=
+github.com/dvyukov/go-fuzz v0.0.0-20210103155950-6a8e9d1f2415/go.mod h1:11Gm+ccJnvAhCNLlf5+cS9KjtbaD5I5zaZpFMsTHWTw=
+github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
+github.com/fatih/color v1.12.0 h1:mRhaKNwANqRgUBGKmnI5ZxEk7QXmjQeCcuYFMX2bfcc=
+github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q=
 github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI=
-github.com/go-openapi/analysis v0.17.0 h1:8JV+dzJJiK46XqGLqqLav8ZfEiJECp8jlOFhpiCdZ+0=
 github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik=
 github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
-github.com/go-openapi/errors v0.17.2 h1:azEQ8Fnx0jmtFF2fxsnmd6I0x6rsweUF63qqSO1NmKk=
 github.com/go-openapi/errors v0.17.2/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
-github.com/go-openapi/jsonpointer v0.17.0 h1:nH6xp8XdXHx8dqveo0ZuJBluCO2qGrPbDNZ0dwoRHP0=
 github.com/go-openapi/jsonpointer v0.17.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M=
-github.com/go-openapi/jsonreference v0.17.0 h1:yJW3HCkTHg7NOA+gZ83IPHzUSnUzGXhGmsdiCcMexbA=
 github.com/go-openapi/jsonreference v0.17.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I=
-github.com/go-openapi/loads v0.17.0 h1:H22nMs3GDQk4SwAaFQ+jLNw+0xoFeCueawhZlv8MBYs=
 github.com/go-openapi/loads v0.17.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU=
 github.com/go-openapi/runtime v0.0.0-20180920151709-4f900dc2ade9/go.mod h1:6v9a6LTXWQCdL8k1AO3cvqx5OtZY/Y9wKTgaoP6YRfA=
-github.com/go-openapi/runtime v0.17.2 h1:/ZK67ikFhQAMFFH/aPu2MaGH7QjP4wHBvHYOVIzDAw0=
 github.com/go-openapi/runtime v0.17.2/go.mod h1:QO936ZXeisByFmZEO1IS1Dqhtf4QV1sYYFtIq6Ld86Q=
-github.com/go-openapi/spec v0.17.0 h1:XNvrt8FlSVP8T1WuhbAFF6QDhJc0zsoWzX4wXARhhpE=
 github.com/go-openapi/spec v0.17.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI=
-github.com/go-openapi/strfmt v0.17.0 h1:1isAxYf//QDTnVzbLAMrUK++0k1EjeLJU/gTOR0o3Mc=
 github.com/go-openapi/strfmt v0.17.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU=
-github.com/go-openapi/swag v0.17.0 h1:iqrgMg7Q7SvtbWLlltPrkMs0UBJI6oTSs79JFRUi880=
 github.com/go-openapi/swag v0.17.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg=
-github.com/go-openapi/validate v0.17.0 h1:pqoViQz3YLOGIhAmD0N4Lt6pa/3Gnj3ymKqQwq8iS6U=
 github.com/go-openapi/validate v0.17.0/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4=
+github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gotify/go-api-client/v2 v2.0.4 h1:0w8skCr8aLBDKaQDg31LKKHUGF7rt7zdRpR+6cqIAlE=
 github.com/gotify/go-api-client/v2 v2.0.4/go.mod h1:VKiah/UK20bXsr0JObE1eBVLW44zbBouzjuri9iwjFU=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/josharian/native v0.0.0-20200817173448-b6b71def0850 h1:uhL5Gw7BINiiPAo24A2sxkcDI0Jt/sqp1v5xQCniEFA=
+github.com/josharian/native v0.0.0-20200817173448-b6b71def0850/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w=
+github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
+github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
+github.com/jsimonetti/rtnetlink v0.0.0-20201009170750-9c6f07d100c1/go.mod h1:hqoO/u39cqLeBLebZ8fWdE96O7FxrAsRYhnVOdgHxok=
+github.com/jsimonetti/rtnetlink v0.0.0-20201216134343-bde56ed16391/go.mod h1:cR77jAZG3Y3bsb8hF6fHJbFoyFukLFOkQ98S0pQz3xw=
+github.com/jsimonetti/rtnetlink v0.0.0-20201220180245-69540ac93943/go.mod h1:z4c53zj6Eex712ROyh8WI0ihysb5j2ROyV42iNogmAs=
+github.com/jsimonetti/rtnetlink v0.0.0-20210122163228-8d122574c736/go.mod h1:ZXpIyOK59ZnN7J0BV99cZUPmsqDRZ3eq5X+st7u/oSA=
+github.com/jsimonetti/rtnetlink v0.0.0-20210212075122-66c871082f2b h1:c3NTyLNozICy8B4mlMXemD3z/gXgQzVXZS/HqT+i3do=
+github.com/jsimonetti/rtnetlink v0.0.0-20210212075122-66c871082f2b/go.mod h1:8w9Rh8m+aHZIG69YPGGem1i5VzoyRC8nw2kA8B+ik5U=
+github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kyokomi/emoji v2.1.0+incompatible h1:+DYU2RgpI6OHG4oQkM5KlqD3Wd3UPEsX8jamTo1Mp6o=
-github.com/kyokomi/emoji v2.1.0+incompatible/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA=
-github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329 h1:2gxZ0XQIU/5z3Z3bUBu+FXuk2pFbkN6tcwi/pjyaDic=
+github.com/kyokomi/emoji v2.2.4+incompatible/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA=
 github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mdlayher/ethtool v0.0.0-20210210192532-2b88debcdd43 h1:WgyLFv10Ov49JAQI/ZLUkCZ7VJS3r74hwFIGXJsgZlY=
+github.com/mdlayher/ethtool v0.0.0-20210210192532-2b88debcdd43/go.mod h1:+t7E0lkKfbBsebllff1xdTmyJt8lH37niI6kwFk9OTo=
+github.com/mdlayher/genetlink v1.0.0 h1:OoHN1OdyEIkScEmRgxLEe2M9U8ClMytqA5niynLtfj0=
+github.com/mdlayher/genetlink v1.0.0/go.mod h1:0rJ0h4itni50A86M2kHcgS85ttZazNt7a8H2a2cw0Gc=
+github.com/mdlayher/netlink v0.0.0-20190409211403-11939a169225/go.mod h1:eQB3mZE4aiYnlUsyGGCOpPETfdQq4Jhsgf1fk3cwQaA=
+github.com/mdlayher/netlink v1.0.0/go.mod h1:KxeJAFOFLG6AjpyDkQ/iIhxygIUKD+vcwqcnu43w/+M=
+github.com/mdlayher/netlink v1.1.0/go.mod h1:H4WCitaheIsdF9yOYu8CFmCgQthAPIWZmcKp9uZHgmY=
+github.com/mdlayher/netlink v1.1.1/go.mod h1:WTYpFb/WTvlRJAyKhZL5/uy69TDDpHHu2VZmb2XgV7o=
+github.com/mdlayher/netlink v1.2.0/go.mod h1:kwVW1io0AZy9A1E2YYgaD4Cj+C+GPkU6klXCMzIJ9p8=
+github.com/mdlayher/netlink v1.2.1/go.mod h1:bacnNlfhqHqqLo4WsYeXSqfyXkInQ9JneWI68v1KwSU=
+github.com/mdlayher/netlink v1.2.2-0.20210123213345-5cc92139ae3e/go.mod h1:bacnNlfhqHqqLo4WsYeXSqfyXkInQ9JneWI68v1KwSU=
+github.com/mdlayher/netlink v1.3.0/go.mod h1:xK/BssKuwcRXHrtN04UBkwQ6dY9VviGGuriDdoPSWys=
+github.com/mdlayher/netlink v1.4.0 h1:n3ARR+Fm0dDv37dj5wSWZXDKcy+U0zwcXS3zKMnSiT0=
+github.com/mdlayher/netlink v1.4.0/go.mod h1:dRJi5IABcZpBD2A3D0Mv/AiX8I9uDEu5oGkAVrekmf8=
+github.com/miekg/dns v1.1.40 h1:pyyPFfGMnciYUk/mXpKkVmeMQjfXqt3FAJ2hy7tPiLA=
+github.com/miekg/dns v1.1.40/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721 h1:RlZweED6sbSArvlE924+mUcZuXKLBHA35U7LN621Bws=
+github.com/mikioh/ipaddr v0.0.0-20190404000644-d465c8ab6721/go.mod h1:Ickgr2WtCLZ2MDGd4Gr0geeCH5HybhRJbonOgQpvSxc=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc=
-github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
+github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
-github.com/phayes/permbits v0.0.0-20190612203442-39d7c581d2ee h1:P6U24L02WMfj9ymZTxl7CxS73JC99x3ukk+DBkgQGQs=
+github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
 github.com/phayes/permbits v0.0.0-20190612203442-39d7c581d2ee/go.mod h1:3uODdxMgOaPYeWU7RzZLxVtJHZ/x1f/iHkBZuKJDzuY=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/qdm12/golibs v0.0.0-20200208153322-66b2eb719e21 h1:Nza/Ar6tPYhDzkiNzbaJZHl4+GUXTqbtjGXuWenkqpQ=
-github.com/qdm12/golibs v0.0.0-20200208153322-66b2eb719e21/go.mod h1:YULaFjj6VGmhjak6f35sUWwEleHUmngN5IQ3kdvd6XE=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/qdm12/dns v1.11.0 h1:jpcD5DZXXQSQe5a263PL09ghukiIdptvXFOZvyKEm6Q=
+github.com/qdm12/dns v1.11.0/go.mod h1:FmQsNOUcrrZ4UFzWAiED56AKXeNgaX3ySbmPwEfNjjE=
+github.com/qdm12/golibs v0.0.0-20210603202746-e5494e9c2ebb/go.mod h1:15RBzkun0i8XB7ADIoLJWp9ITRgsz3LroEI2FiOXLRg=
+github.com/qdm12/golibs v0.0.0-20210723175634-a75ca7fd74c2/go.mod h1:6aRbg4Z/bTbm9JfxsGXfWKHi7zsOvPfUTK1S5HuAFKg=
+github.com/qdm12/golibs v0.0.0-20210822203818-5c568b0777b6 h1:bge5AL7cjHJMPz+5IOz5yF01q/l8No6+lIEBieA8gMg=
+github.com/qdm12/golibs v0.0.0-20210822203818-5c568b0777b6/go.mod h1:6aRbg4Z/bTbm9JfxsGXfWKHi7zsOvPfUTK1S5HuAFKg=
+github.com/qdm12/goshutdown v0.1.0 h1:lmwnygdXtnr2pa6VqfR/bm8077/BnBef1+7CP96B7Sw=
+github.com/qdm12/goshutdown v0.1.0/go.mod h1:/LP3MWLqI+wGH/ijfaUG+RHzBbKXIiVKnrg5vXOCf6Q=
+github.com/qdm12/gosplash v0.1.0 h1:Sfl+zIjFZFP7b0iqf2l5UkmEY97XBnaKkH3FNY6Gf7g=
+github.com/qdm12/gosplash v0.1.0/go.mod h1:+A3fWW4/rUeDXhY3ieBzwghKdnIPFJgD8K3qQkenJlw=
+github.com/qdm12/ss-server v0.3.0 h1:BfKv4OU6dYb2KcDMYpTc7LIuO2jB73g3JCzy988GrLI=
+github.com/qdm12/ss-server v0.3.0/go.mod h1:ug+nWfuzKw/h5fxL1B6e9/OhkVuWJX4i2V1Pf0pJU1o=
+github.com/qdm12/updated v0.0.0-20210603204757-205acfe6937e h1:4q+uFLawkaQRq3yARYLsjJPZd2wYwxn4g6G/5v0xW1g=
+github.com/qdm12/updated v0.0.0-20210603204757-205acfe6937e/go.mod h1:UvJRGkZ9XL3/D7e7JiTTVLm1F3Cymd3/gFpD6frEpBo=
+github.com/riobard/go-bloom v0.0.0-20200614022211-cdc8013cb5b3 h1:f/FNXud6gA3MNr8meMVVGxhp+QBTqY91tM8HjEuMjGg=
+github.com/riobard/go-bloom v0.0.0-20200614022211-cdc8013cb5b3/go.mod h1:HgjTstvQsPGkxUsCd2KWxErBblirPizecHcpD3ffK+s=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/src-d/gcfg v1.4.0/go.mod h1:p/UMsR43ujA89BJY9duynAwIpvqEujIH/jFlfL7jWoI=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-go.uber.org/atomic v1.5.0 h1:OI5t8sDa1Or+q8AeE+yKeB/SDYioSHAgcVljj9JIETY=
-go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/multierr v1.3.0 h1:sFPn2GLc3poCkfrpIXGhBD2X0CMIo4Q/zSULXrj/+uc=
-go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
-go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.13.0 h1:nR6NoDBgAf67s68NhaXbsojM+2gxp3S1hWkHDl27pVU=
-go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/vishvananda/netlink v1.1.0 h1:1iyaYNBLmP6L0220aDnYQpo1QEV4t4hJ+xEEhhJH8j0=
+github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
+github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df h1:OviZH7qLw/7ZovXvuNyL3XQl8UFofeikI1NW1Gypu7k=
+github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
+github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0Bx9h2kr4=
+github.com/yl2chen/cidranger v1.0.2/go.mod h1:9U1yz7WPYDwf0vpNWFaeRh0bjwz5RVgRy/9UEQfHl0g=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go4.org/intern v0.0.0-20210108033219-3eb7198706b2 h1:VFTf+jjIgsldaz/Mr00VaCSswHJrI2hIjQygE/W4IMg=
+go4.org/intern v0.0.0-20210108033219-3eb7198706b2/go.mod h1:vLqJ+12kCw61iCWsPto0EOHhBS+o4rO5VIucbc9g2Cc=
+go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222175341-b30ae309168e/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
+go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063 h1:1tk03FUNpulq2cuWpXZWj649rwJpk0d20rxWiopKRmc=
+go4.org/unsafe/assume-no-moving-gc v0.0.0-20201222180813-1025295fd063/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
+golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210503195802-e9a32991a82e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 h1:/UOmuWzQfxxo9UtlXMwuQU8CMgg1eZXqTRwkSQJWKOI=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191007182048-72f939374954/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201216054612-986b41b23924/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20210504132125-bbd867fde50d h1:nTDGCTeAu2LhcsHTRzjyIUbZHCJ4QePArsm27Hka0UM=
+golang.org/x/net v0.0.0-20210504132125-bbd867fde50d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190221075227-b4e8571b14e0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190411185658-b44545bcd369/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201118182958-a01c418693c7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201218084310-7d0127a74742/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210110051926-789bb1bd4061/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210123111255-9b0068b26619/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210216163648-f7da38b97c65/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210309040221-94ec62e08169/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210503173754-0981d6026fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c h1:F1jZWGFhYfh0Ci55sIpILtKKK8p3i2/krTr0H1rg74I=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5 h1:hKsoRgsbwY1NafxrwTs+k64bikrLBkAgPir1TNCj3Zs=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190729092621-ff9f1409240a/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.zx2c4.com/wireguard v0.0.0-20210427022245-097af6e1351b/go.mod h1:a057zjmoc00UN7gVkaJt2sXVK523kMJcogDTEvPIasg=
+golang.zx2c4.com/wireguard v0.0.0-20210805125648-3957e9b9dd19 h1:ab2jcw2W91Rz07eHAb8Lic7sFQKO0NhBftjv6m/gL/0=
+golang.zx2c4.com/wireguard v0.0.0-20210805125648-3957e9b9dd19/go.mod h1:laHzsbfMhGSobUmruXWAyMKKHSqvIcrqZJMyHD+/3O8=
+golang.zx2c4.com/wireguard/wgctrl v0.0.0-20210803171230-4253848d036c h1:ADNrRDI5NR23/TUCnEmlLZLt4u9DnZ2nwRkPrAcFvto=
+golang.zx2c4.com/wireguard/wgctrl v0.0.0-20210803171230-4253848d036c/go.mod h1:+1XihzyZUBJcSc5WO9SwNA7v26puQwOEDwanaxfNXPQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98=
+gopkg.in/src-d/go-git-fixtures.v3 v3.5.0/go.mod h1:dLBcvytrw/TYZsNTWCnkNF2DSIlzWYqTe3rJR56Ac7g=
+gopkg.in/src-d/go-git.v4 v4.13.1/go.mod h1:nx5NYcxdKxq5fpltdHnPa2Exj4Sx0EclMWZQbYDu2z8=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+inet.af/netaddr v0.0.0-20210511181906-37180328850c/go.mod h1:z0nx+Dh+7N7CC8V5ayHtHGpZpxLQZZxkIaaz6HN65Ls=
+inet.af/netaddr v0.0.0-20210718074554-06ca8145d722 h1:Qws2rZnQudC58cIagVucPQDLmMi3kAXgxscsgD0v6DU=
+inet.af/netaddr v0.0.0-20210718074554-06ca8145d722/go.mod h1:z0nx+Dh+7N7CC8V5ayHtHGpZpxLQZZxkIaaz6HN65Ls=

internal/alpine/alpine.go

@@ -0,0 +1,29 @@
+// Package alpine defines a configurator to interact with the Alpine operating system.
+package alpine
+
+import (
+	"os/user"
+)
+
+var _ Alpiner = (*Alpine)(nil)
+
+type Alpiner interface {
+	UserCreater
+	VersionGetter
+}
+
+type Alpine struct {
+	alpineReleasePath string
+	passwdPath        string
+	lookupID          func(uid string) (*user.User, error)
+	lookup            func(username string) (*user.User, error)
+}
+
+func New() *Alpine {
+	return &Alpine{
+		alpineReleasePath: "/etc/alpine-release",
+		passwdPath:        "/etc/passwd",
+		lookupID:          user.LookupId,
+		lookup:            user.Lookup,
+	}
+}

internal/alpine/users.go

@@ -0,0 +1,58 @@
+package alpine
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/user"
+	"strconv"
+)
+
+var (
+	ErrUserAlreadyExists = errors.New("user already exists")
+)
+
+type UserCreater interface {
+	CreateUser(username string, uid int) (createdUsername string, err error)
+}
+
+// CreateUser creates a user in Alpine with the given UID.
+func (a *Alpine) CreateUser(username string, uid int) (createdUsername string, err error) {
+	UIDStr := strconv.Itoa(uid)
+	u, err := a.lookupID(UIDStr)
+	_, unknownUID := err.(user.UnknownUserIdError)
+	if err != nil && !unknownUID {
+		return "", err
+	}
+
+	if u != nil {
+		if u.Username == username {
+			return "", nil
+		}
+		return u.Username, nil
+	}
+
+	u, err = a.lookup(username)
+	_, unknownUsername := err.(user.UnknownUserError)
+	if err != nil && !unknownUsername {
+		return "", err
+	}
+
+	if u != nil {
+		return "", fmt.Errorf("%w: with name %s for ID %s instead of %d",
+			ErrUserAlreadyExists, username, u.Uid, uid)
+	}
+
+	file, err := os.OpenFile(a.passwdPath, os.O_APPEND|os.O_WRONLY, 0644)
+	if err != nil {
+		return "", err
+	}
+	s := fmt.Sprintf("%s:x:%d:::/dev/null:/sbin/nologin\n", username, uid)
+	_, err = file.WriteString(s)
+	if err != nil {
+		_ = file.Close()
+		return "", err
+	}
+
+	return username, file.Close()
+}

internal/alpine/version.go

@@ -0,0 +1,31 @@
+package alpine
+
+import (
+	"context"
+	"io"
+	"os"
+	"strings"
+)
+
+type VersionGetter interface {
+	Version(ctx context.Context) (version string, err error)
+}
+
+func (a *Alpine) Version(ctx context.Context) (version string, err error) {
+	file, err := os.OpenFile(a.alpineReleasePath, os.O_RDONLY, 0)
+	if err != nil {
+		return "", err
+	}
+
+	b, err := io.ReadAll(file)
+	if err != nil {
+		return "", err
+	}
+
+	if err := file.Close(); err != nil {
+		return "", err
+	}
+
+	version = strings.ReplaceAll(string(b), "\n", "")
+	return version, nil
+}

internal/cli/ci.go

@@ -0,0 +1,7 @@
+package cli
+
+import "context"
+
+func (c *CLI) CI(context context.Context) error {
+	return nil
+}

internal/cli/cli.go

@@ -0,0 +1,21 @@
+// Package cli defines an interface CLI to run command line operations.
+package cli
+
+var _ CLIer = (*CLI)(nil)
+
+type CLIer interface {
+	ClientKeyFormatter
+	HealthChecker
+	OpenvpnConfigMaker
+	Updater
+}
+
+type CLI struct {
+	repoServersPath string
+}
+
+func New() *CLI {
+	return &CLI{
+		repoServersPath: "./internal/constants/servers.json",
+	}
+}

internal/cli/clientkey.go

@@ -0,0 +1,45 @@
+package cli
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+type ClientKeyFormatter interface {
+	ClientKey(args []string) error
+}
+
+func (c *CLI) ClientKey(args []string) error {
+	flagSet := flag.NewFlagSet("clientkey", flag.ExitOnError)
+	filepath := flagSet.String("path", constants.ClientKey, "file path to the client.key file")
+	if err := flagSet.Parse(args); err != nil {
+		return err
+	}
+	file, err := os.OpenFile(*filepath, os.O_RDONLY, 0)
+	if err != nil {
+		return err
+	}
+	data, err := io.ReadAll(file)
+	if err != nil {
+		_ = file.Close()
+		return err
+	}
+	if err := file.Close(); err != nil {
+		return err
+	}
+	if err != nil {
+		return err
+	}
+	s := string(data)
+	s = strings.ReplaceAll(s, "\n", "")
+	s = strings.ReplaceAll(s, "\r", "")
+	s = strings.TrimPrefix(s, "-----BEGIN PRIVATE KEY-----")
+	s = strings.TrimSuffix(s, "-----END PRIVATE KEY-----")
+	fmt.Println(s)
+	return nil
+}

internal/cli/healthcheck.go

@@ -0,0 +1,40 @@
+package cli
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/qdm12/gluetun/internal/configuration"
+	"github.com/qdm12/gluetun/internal/healthcheck"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+)
+
+type HealthChecker interface {
+	HealthCheck(ctx context.Context, env params.Interface, logger logging.Logger) error
+}
+
+func (c *CLI) HealthCheck(ctx context.Context, env params.Interface,
+	logger logging.Logger) error {
+	// Extract the health server port from the configuration.
+	config := configuration.Health{}
+	err := config.Read(env, logger)
+	if err != nil {
+		return err
+	}
+	_, port, err := net.SplitHostPort(config.ServerAddress)
+	if err != nil {
+		return err
+	}
+
+	const timeout = 10 * time.Second
+	httpClient := &http.Client{Timeout: timeout}
+	client := healthcheck.NewClient(httpClient)
+	ctx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	url := "http://127.0.0.1:" + port
+	return client.Check(ctx, url)
+}

internal/cli/openvpnconfig.go

@@ -0,0 +1,40 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/qdm12/gluetun/internal/configuration"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/provider"
+	"github.com/qdm12/gluetun/internal/storage"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+)
+
+type OpenvpnConfigMaker interface {
+	OpenvpnConfig(logger logging.Logger, env params.Interface) error
+}
+
+func (c *CLI) OpenvpnConfig(logger logging.Logger, env params.Interface) error {
+	storage, err := storage.New(logger, constants.ServersData)
+	if err != nil {
+		return err
+	}
+	allServers := storage.GetServers()
+
+	var allSettings configuration.Settings
+	err = allSettings.Read(env, allServers, logger)
+	if err != nil {
+		return err
+	}
+	providerConf := provider.New(allSettings.VPN.Provider.Name, allServers, time.Now)
+	connection, err := providerConf.GetConnection(allSettings.VPN.Provider.ServerSelection)
+	if err != nil {
+		return err
+	}
+	lines := providerConf.BuildConf(connection, allSettings.VPN.OpenVPN)
+	fmt.Println(strings.Join(lines, "\n"))
+	return nil
+}

internal/cli/update.go

@@ -0,0 +1,113 @@
+package cli
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/qdm12/gluetun/internal/configuration"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/gluetun/internal/storage"
+	"github.com/qdm12/gluetun/internal/updater"
+	"github.com/qdm12/golibs/logging"
+)
+
+var (
+	ErrModeUnspecified         = errors.New("at least one of -enduser or -maintainers must be specified")
+	ErrNewStorage              = errors.New("cannot create storage")
+	ErrUpdateServerInformation = errors.New("cannot update server information")
+	ErrWriteToFile             = errors.New("cannot write updated information to file")
+)
+
+type Updater interface {
+	Update(ctx context.Context, args []string, logger logging.Logger) error
+}
+
+func (c *CLI) Update(ctx context.Context, args []string, logger logging.Logger) error {
+	options := configuration.Updater{CLI: true}
+	var endUserMode, maintainerMode, updateAll bool
+	flagSet := flag.NewFlagSet("update", flag.ExitOnError)
+	flagSet.BoolVar(&endUserMode, "enduser", false, "Write results to /gluetun/servers.json (for end users)")
+	flagSet.BoolVar(&maintainerMode, "maintainer", false,
+		"Write results to ./internal/constants/servers.json to modify the program (for maintainers)")
+	flagSet.StringVar(&options.DNSAddress, "dns", "8.8.8.8", "DNS resolver address to use")
+	flagSet.BoolVar(&updateAll, "all", false, "Update servers for all VPN providers")
+	flagSet.BoolVar(&options.Cyberghost, "cyberghost", false, "Update Cyberghost servers")
+	flagSet.BoolVar(&options.Fastestvpn, "fastestvpn", false, "Update FastestVPN servers")
+	flagSet.BoolVar(&options.HideMyAss, "hidemyass", false, "Update HideMyAss servers")
+	flagSet.BoolVar(&options.Ipvanish, "ipvanish", false, "Update IpVanish servers")
+	flagSet.BoolVar(&options.Ivpn, "ivpn", false, "Update IVPN servers")
+	flagSet.BoolVar(&options.Mullvad, "mullvad", false, "Update Mullvad servers")
+	flagSet.BoolVar(&options.Nordvpn, "nordvpn", false, "Update Nordvpn servers")
+	flagSet.BoolVar(&options.PIA, "pia", false, "Update Private Internet Access post-summer 2020 servers")
+	flagSet.BoolVar(&options.Privado, "privado", false, "Update Privado servers")
+	flagSet.BoolVar(&options.Privatevpn, "privatevpn", false, "Update Private VPN servers")
+	flagSet.BoolVar(&options.Protonvpn, "protonvpn", false, "Update Protonvpn servers")
+	flagSet.BoolVar(&options.Purevpn, "purevpn", false, "Update Purevpn servers")
+	flagSet.BoolVar(&options.Surfshark, "surfshark", false, "Update Surfshark servers")
+	flagSet.BoolVar(&options.Torguard, "torguard", false, "Update Torguard servers")
+	flagSet.BoolVar(&options.VPNUnlimited, "vpnunlimited", false, "Update VPN Unlimited servers")
+	flagSet.BoolVar(&options.Vyprvpn, "vyprvpn", false, "Update Vyprvpn servers")
+	flagSet.BoolVar(&options.Windscribe, "windscribe", false, "Update Windscribe servers")
+	if err := flagSet.Parse(args); err != nil {
+		return err
+	}
+	if !endUserMode && !maintainerMode {
+		return ErrModeUnspecified
+	}
+
+	if updateAll {
+		options.EnableAll()
+	}
+
+	const clientTimeout = 10 * time.Second
+	httpClient := &http.Client{Timeout: clientTimeout}
+
+	storage, err := storage.New(logger, constants.ServersData)
+	if err != nil {
+		return fmt.Errorf("%w: %s", ErrNewStorage, err)
+	}
+	currentServers := storage.GetServers()
+
+	updater := updater.New(options, httpClient, currentServers, logger)
+	allServers, err := updater.UpdateServers(ctx)
+	if err != nil {
+		return fmt.Errorf("%w: %s", ErrUpdateServerInformation, err)
+	}
+
+	if endUserMode {
+		if err := storage.FlushToFile(allServers); err != nil {
+			return fmt.Errorf("%w: %s", ErrWriteToFile, err)
+		}
+	}
+
+	if maintainerMode {
+		if err := writeToEmbeddedJSON(c.repoServersPath, allServers); err != nil {
+			return fmt.Errorf("%w: %s", ErrWriteToFile, err)
+		}
+	}
+
+	return nil
+}
+
+func writeToEmbeddedJSON(repoServersPath string,
+	allServers models.AllServers) error {
+	const perms = 0600
+	f, err := os.OpenFile(repoServersPath,
+		os.O_TRUNC|os.O_WRONLY|os.O_CREATE, perms)
+	if err != nil {
+		return err
+	}
+
+	defer f.Close()
+
+	encoder := json.NewEncoder(f)
+	encoder.SetIndent("", "  ")
+	return encoder.Encode(allServers)
+}

internal/configuration/configuration.go

@@ -0,0 +1,3 @@
+// Package configuration reads initial settings from environment variables
+// and secret files.
+package configuration

internal/configuration/constants.go

@@ -0,0 +1,6 @@
+package configuration
+
+const (
+	lastIndent = "|--"
+	indent     = "   "
+)

internal/configuration/cyberghost.go

@@ -0,0 +1,50 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readCyberghost(r reader) (err error) {
+	settings.Name = constants.Cyberghost
+	servers := r.servers.GetCyberghost()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Groups, err = r.env.CSVInside("CYBERGHOST_GROUP",
+		constants.CyberghostGroupChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CYBERGHOST_GROUP: %w", err)
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.CyberghostRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.CyberghostHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolAndPort(r.env)
+}
+
+func (settings *OpenVPN) readCyberghost(r reader) (err error) {
+	settings.ClientKey, err = readClientKey(r)
+	if err != nil {
+		return err
+	}
+
+	settings.ClientCrt, err = readClientCertificate(r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/dns.go

@@ -0,0 +1,117 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"time"
+
+	"github.com/qdm12/dns/pkg/blacklist"
+	"github.com/qdm12/dns/pkg/unbound"
+	"github.com/qdm12/golibs/params"
+)
+
+// DNS contains settings to configure Unbound for DNS over TLS operation.
+type DNS struct { //nolint:maligned
+	Enabled          bool
+	PlaintextAddress net.IP
+	KeepNameserver   bool
+	UpdatePeriod     time.Duration
+	Unbound          unbound.Settings
+	BlacklistBuild   blacklist.BuilderSettings
+}
+
+func (settings *DNS) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *DNS) lines() (lines []string) {
+	lines = append(lines, lastIndent+"DNS:")
+
+	if settings.PlaintextAddress != nil {
+		lines = append(lines, indent+lastIndent+"Plaintext address: "+settings.PlaintextAddress.String())
+	}
+
+	if settings.KeepNameserver {
+		lines = append(lines, indent+lastIndent+"Keep nameserver (disabled blocking): yes")
+	}
+
+	if !settings.Enabled {
+		return lines
+	}
+
+	lines = append(lines, indent+lastIndent+"DNS over TLS:")
+
+	lines = append(lines, indent+indent+lastIndent+"Unbound:")
+	for _, line := range settings.Unbound.Lines() {
+		lines = append(lines, indent+indent+indent+line)
+	}
+
+	lines = append(lines, indent+indent+lastIndent+"Blacklist:")
+	for _, line := range settings.BlacklistBuild.Lines(indent, lastIndent) {
+		lines = append(lines, indent+indent+indent+line)
+	}
+
+	if settings.UpdatePeriod > 0 {
+		lines = append(lines, indent+indent+lastIndent+"Update: every "+settings.UpdatePeriod.String())
+	}
+
+	return lines
+}
+
+var (
+	ErrUnboundSettings   = errors.New("failed getting Unbound settings")
+	ErrBlacklistSettings = errors.New("failed getting DNS blacklist settings")
+)
+
+func (settings *DNS) read(r reader) (err error) {
+	settings.Enabled, err = r.env.OnOff("DOT", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable DOT: %w", err)
+	}
+
+	// Plain DNS settings
+	if err := settings.readDNSPlaintext(r.env); err != nil {
+		return err
+	}
+	settings.KeepNameserver, err = r.env.OnOff("DNS_KEEP_NAMESERVER", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable DNS_KEEP_NAMESERVER: %w", err)
+	}
+
+	// DNS over TLS external settings
+	if err := settings.readBlacklistBuilding(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrBlacklistSettings, err)
+	}
+
+	settings.UpdatePeriod, err = r.env.Duration("DNS_UPDATE_PERIOD", params.Default("24h"))
+	if err != nil {
+		return fmt.Errorf("environment variable DNS_UPDATE_PERIOD: %w", err)
+	}
+
+	// Unbound settings
+	if err := settings.readUnbound(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrUnboundSettings, err)
+	}
+
+	return nil
+}
+
+var (
+	ErrDNSAddressNotAnIP = errors.New("DNS plaintext address is not an IP address")
+)
+
+func (settings *DNS) readDNSPlaintext(env params.Interface) error {
+	s, err := env.Get("DNS_PLAINTEXT_ADDRESS", params.Default("1.1.1.1"))
+	if err != nil {
+		return fmt.Errorf("environment variable DNS_PLAINTEXT_ADDRESS: %w", err)
+	}
+
+	settings.PlaintextAddress = net.ParseIP(s)
+	if settings.PlaintextAddress == nil {
+		return fmt.Errorf("%w: %s", ErrDNSAddressNotAnIP, s)
+	}
+
+	return nil
+}

internal/configuration/dns_test.go

@@ -0,0 +1,76 @@
+package configuration
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"github.com/qdm12/dns/pkg/blacklist"
+	"github.com/qdm12/dns/pkg/provider"
+	"github.com/qdm12/dns/pkg/unbound"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_DNS_Lines(t *testing.T) {
+	t.Parallel()
+	testCases := map[string]struct {
+		settings DNS
+		lines    []string
+	}{
+		"disabled DOT": {
+			settings: DNS{
+				PlaintextAddress: net.IP{1, 1, 1, 1},
+			},
+			lines: []string{
+				"|--DNS:",
+				"   |--Plaintext address: 1.1.1.1",
+			},
+		},
+		"enabled DOT": {
+			settings: DNS{
+				Enabled:        true,
+				KeepNameserver: true,
+				Unbound: unbound.Settings{
+					Providers: []provider.Provider{
+						provider.Cloudflare(),
+					},
+				},
+				BlacklistBuild: blacklist.BuilderSettings{
+					BlockMalicious:    true,
+					BlockAds:          true,
+					BlockSurveillance: true,
+				},
+				UpdatePeriod: time.Hour,
+			},
+			lines: []string{
+				"|--DNS:",
+				"   |--Keep nameserver (disabled blocking): yes",
+				"   |--DNS over TLS:",
+				"      |--Unbound:",
+				"          |--DNS over TLS providers:",
+				"              |--Cloudflare",
+				"          |--Listening port: 0",
+				"          |--Access control:",
+				"              |--Allowed:",
+				"          |--Caching: disabled",
+				"          |--IPv4 resolution: disabled",
+				"          |--IPv6 resolution: disabled",
+				"          |--Verbosity level: 0/5",
+				"          |--Verbosity details level: 0/4",
+				"          |--Validation log level: 0/2",
+				"          |--Username: ",
+				"      |--Blacklist:",
+				"         |--Blocked categories: malicious, surveillance, ads",
+				"      |--Update: every 1h0m0s",
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			lines := testCase.settings.lines()
+			assert.Equal(t, testCase.lines, lines)
+		})
+	}
+}

internal/configuration/dnsblacklist.go

@@ -0,0 +1,87 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/qdm12/golibs/params"
+	"inet.af/netaddr"
+)
+
+func (settings *DNS) readBlacklistBuilding(r reader) (err error) {
+	settings.BlacklistBuild.BlockMalicious, err = r.env.OnOff("BLOCK_MALICIOUS", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable BLOCK_MALICIOUS: %w", err)
+	}
+
+	settings.BlacklistBuild.BlockSurveillance, err = r.env.OnOff("BLOCK_SURVEILLANCE", params.Default("on"),
+		params.RetroKeys([]string{"BLOCK_NSA"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable BLOCK_SURVEILLANCE (or BLOCK_NSA): %w", err)
+	}
+
+	settings.BlacklistBuild.BlockAds, err = r.env.OnOff("BLOCK_ADS", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable BLOCK_ADS: %w", err)
+	}
+
+	if err := settings.readPrivateAddresses(r.env); err != nil {
+		return err
+	}
+
+	return settings.readBlacklistUnblockedHostnames(r)
+}
+
+var (
+	ErrInvalidPrivateAddress = errors.New("private address is not a valid IP or CIDR range")
+)
+
+func (settings *DNS) readPrivateAddresses(env params.Interface) (err error) {
+	privateAddresses, err := env.CSV("DOT_PRIVATE_ADDRESS")
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_PRIVATE_ADDRESS: %w", err)
+	} else if len(privateAddresses) == 0 {
+		return nil
+	}
+
+	ips := make([]netaddr.IP, 0, len(privateAddresses))
+	ipPrefixes := make([]netaddr.IPPrefix, 0, len(privateAddresses))
+
+	for _, address := range privateAddresses {
+		ip, err := netaddr.ParseIP(address)
+		if err == nil {
+			ips = append(ips, ip)
+			continue
+		}
+
+		ipPrefix, err := netaddr.ParseIPPrefix(address)
+		if err == nil {
+			ipPrefixes = append(ipPrefixes, ipPrefix)
+			continue
+		}
+
+		return fmt.Errorf("%w: %s", ErrInvalidPrivateAddress, address)
+	}
+
+	settings.BlacklistBuild.AddBlockedIPs = append(settings.BlacklistBuild.AddBlockedIPs, ips...)
+	settings.BlacklistBuild.AddBlockedIPPrefixes = append(settings.BlacklistBuild.AddBlockedIPPrefixes, ipPrefixes...)
+
+	return nil
+}
+
+func (settings *DNS) readBlacklistUnblockedHostnames(r reader) (err error) {
+	hostnames, err := r.env.CSV("UNBLOCK")
+	if err != nil {
+		return fmt.Errorf("environment variable UNBLOCK: %w", err)
+	} else if len(hostnames) == 0 {
+		return nil
+	}
+	for _, hostname := range hostnames {
+		if !r.regex.MatchHostname(hostname) {
+			return fmt.Errorf("%w: %s", ErrInvalidHostname, hostname)
+		}
+	}
+
+	settings.BlacklistBuild.AllowedHosts = append(settings.BlacklistBuild.AllowedHosts, hostnames...)
+	return nil
+}

internal/configuration/fastestvpn.go

@@ -0,0 +1,30 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readFastestvpn(r reader) (err error) {
+	settings.Name = constants.Fastestvpn
+	servers := r.servers.GetFastestvpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.FastestvpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.FastestvpnCountriesChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}

internal/configuration/firewall.go

@@ -0,0 +1,99 @@
+package configuration
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+// Firewall contains settings to customize the firewall operation.
+type Firewall struct {
+	VPNInputPorts   []uint16
+	InputPorts      []uint16
+	OutboundSubnets []net.IPNet
+	Enabled         bool
+	Debug           bool
+}
+
+func (settings *Firewall) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *Firewall) lines() (lines []string) {
+	if !settings.Enabled {
+		lines = append(lines, lastIndent+"Firewall: disabled ⚠️")
+		return lines
+	}
+
+	lines = append(lines, lastIndent+"Firewall:")
+
+	if settings.Debug {
+		lines = append(lines, indent+lastIndent+"Debug: on")
+	}
+
+	if len(settings.VPNInputPorts) > 0 {
+		lines = append(lines, indent+lastIndent+"VPN input ports: "+
+			strings.Join(uint16sToStrings(settings.VPNInputPorts), ", "))
+	}
+
+	if len(settings.InputPorts) > 0 {
+		lines = append(lines, indent+lastIndent+"Input ports: "+
+			strings.Join(uint16sToStrings(settings.InputPorts), ", "))
+	}
+
+	if len(settings.OutboundSubnets) > 0 {
+		lines = append(lines, indent+lastIndent+"Outbound subnets: "+
+			strings.Join(ipNetsToStrings(settings.OutboundSubnets), ", "))
+	}
+
+	return lines
+}
+
+func (settings *Firewall) read(r reader) (err error) {
+	settings.Enabled, err = r.env.OnOff("FIREWALL", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL: %w", err)
+	}
+
+	settings.Debug, err = r.env.OnOff("FIREWALL_DEBUG", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_DEBUG: %w", err)
+	}
+
+	if err := settings.readVPNInputPorts(r.env); err != nil {
+		return err
+	}
+
+	if err := settings.readInputPorts(r.env); err != nil {
+		return err
+	}
+
+	return settings.readOutboundSubnets(r)
+}
+
+func (settings *Firewall) readVPNInputPorts(env params.Interface) (err error) {
+	settings.VPNInputPorts, err = readCSVPorts(env, "FIREWALL_VPN_INPUT_PORTS")
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_VPN_INPUT_PORTS: %w", err)
+	}
+	return nil
+}
+
+func (settings *Firewall) readInputPorts(env params.Interface) (err error) {
+	settings.InputPorts, err = readCSVPorts(env, "FIREWALL_INPUT_PORTS")
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_INPUT_PORTS: %w", err)
+	}
+	return nil
+}
+
+func (settings *Firewall) readOutboundSubnets(r reader) (err error) {
+	retroOption := params.RetroKeys([]string{"EXTRA_SUBNETS"}, r.onRetroActive)
+	settings.OutboundSubnets, err = readCSVIPNets(r.env, "FIREWALL_OUTBOUND_SUBNETS", retroOption)
+	if err != nil {
+		return fmt.Errorf("environment variable FIREWALL_OUTBOUND_SUBNETS: %w", err)
+	}
+	return nil
+}

internal/configuration/health.go

@@ -0,0 +1,63 @@
+package configuration
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+)
+
+// Health contains settings for the healthcheck and health server.
+type Health struct {
+	ServerAddress string
+	OpenVPN       HealthyWait
+}
+
+func (settings *Health) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *Health) lines() (lines []string) {
+	lines = append(lines, lastIndent+"Health:")
+
+	lines = append(lines, indent+lastIndent+"Server address: "+settings.ServerAddress)
+
+	lines = append(lines, indent+lastIndent+"OpenVPN:")
+	for _, line := range settings.OpenVPN.lines() {
+		lines = append(lines, indent+indent+line)
+	}
+
+	return lines
+}
+
+// Read is to be used for the healthcheck query mode.
+func (settings *Health) Read(env params.Interface, logger logging.Logger) (err error) {
+	reader := newReader(env, models.AllServers{}, logger) // note: no need for servers data
+	return settings.read(reader)
+}
+
+func (settings *Health) read(r reader) (err error) {
+	var warning string
+	settings.ServerAddress, warning, err = r.env.ListeningAddress(
+		"HEALTH_SERVER_ADDRESS", params.Default("127.0.0.1:9999"))
+	if warning != "" {
+		r.logger.Warn("environment variable HEALTH_SERVER_ADDRESS: " + warning)
+	}
+	if err != nil {
+		return fmt.Errorf("environment variable HEALTH_SERVER_ADDRESS: %w", err)
+	}
+
+	settings.OpenVPN.Initial, err = r.env.Duration("HEALTH_OPENVPN_DURATION_INITIAL", params.Default("6s"))
+	if err != nil {
+		return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_INITIAL: %w", err)
+	}
+
+	settings.OpenVPN.Addition, err = r.env.Duration("HEALTH_OPENVPN_DURATION_ADDITION", params.Default("5s"))
+	if err != nil {
+		return fmt.Errorf("environment variable HEALTH_OPENVPN_DURATION_ADDITION: %w", err)
+	}
+
+	return nil
+}

internal/configuration/health_test.go

@@ -0,0 +1,182 @@
+package configuration
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/golibs/logging/mock_logging"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_Health_String(t *testing.T) {
+	t.Parallel()
+
+	var health Health
+	const expected = "|--Health:\n   |--Server address: \n   |--OpenVPN:\n      |--Initial duration: 0s"
+
+	s := health.String()
+
+	assert.Equal(t, expected, s)
+}
+
+func Test_Health_lines(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		settings Health
+		lines    []string
+	}{
+		"empty": {
+			lines: []string{
+				"|--Health:",
+				"   |--Server address: ",
+				"   |--OpenVPN:",
+				"      |--Initial duration: 0s",
+			},
+		},
+		"filled settings": {
+			settings: Health{
+				ServerAddress: "address:9999",
+				OpenVPN: HealthyWait{
+					Initial:  time.Second,
+					Addition: time.Minute,
+				},
+			},
+			lines: []string{
+				"|--Health:",
+				"   |--Server address: address:9999",
+				"   |--OpenVPN:",
+				"      |--Initial duration: 1s",
+				"      |--Addition duration: 1m0s",
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			lines := testCase.settings.lines()
+
+			assert.Equal(t, testCase.lines, lines)
+		})
+	}
+}
+
+func Test_Health_read(t *testing.T) {
+	t.Parallel()
+
+	errDummy := errors.New("dummy")
+
+	testCases := map[string]struct {
+		openvpnInitialDuration  time.Duration
+		openvpnInitialErr       error
+		openvpnAdditionDuration time.Duration
+		openvpnAdditionErr      error
+		serverAddress           string
+		serverAddressWarning    string
+		serverAddressErr        error
+		expected                Health
+		err                     error
+	}{
+		"success": {
+			openvpnInitialDuration:  time.Second,
+			openvpnAdditionDuration: time.Minute,
+			serverAddress:           "127.0.0.1:9999",
+			expected: Health{
+				ServerAddress: "127.0.0.1:9999",
+				OpenVPN: HealthyWait{
+					Initial:  time.Second,
+					Addition: time.Minute,
+				},
+			},
+		},
+		"listening address error": {
+			openvpnInitialDuration:  time.Second,
+			openvpnAdditionDuration: time.Minute,
+			serverAddress:           "127.0.0.1:9999",
+			serverAddressWarning:    "warning",
+			serverAddressErr:        errDummy,
+			expected: Health{
+				ServerAddress: "127.0.0.1:9999",
+			},
+			err: errors.New("environment variable HEALTH_SERVER_ADDRESS: dummy"),
+		},
+		"initial error": {
+			openvpnInitialDuration:  time.Second,
+			openvpnInitialErr:       errDummy,
+			openvpnAdditionDuration: time.Minute,
+			expected: Health{
+				OpenVPN: HealthyWait{
+					Initial: time.Second,
+				},
+			},
+			err: errors.New("environment variable HEALTH_OPENVPN_DURATION_INITIAL: dummy"),
+		},
+		"addition error": {
+			openvpnInitialDuration:  time.Second,
+			openvpnAdditionDuration: time.Minute,
+			openvpnAdditionErr:      errDummy,
+			expected: Health{
+				OpenVPN: HealthyWait{
+					Initial:  time.Second,
+					Addition: time.Minute,
+				},
+			},
+			err: errors.New("environment variable HEALTH_OPENVPN_DURATION_ADDITION: dummy"),
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			ctrl := gomock.NewController(t)
+
+			env := mock_params.NewMockInterface(ctrl)
+			logger := mock_logging.NewMockLogger(ctrl)
+
+			env.EXPECT().ListeningAddress("HEALTH_SERVER_ADDRESS", gomock.Any()).
+				Return(testCase.serverAddress, testCase.serverAddressWarning,
+					testCase.serverAddressErr)
+			if testCase.serverAddressWarning != "" {
+				logger.EXPECT().Warn("environment variable HEALTH_SERVER_ADDRESS: " + testCase.serverAddressWarning)
+			}
+
+			if testCase.serverAddressErr == nil {
+				env.EXPECT().
+					Duration("HEALTH_OPENVPN_DURATION_INITIAL", gomock.Any()).
+					Return(testCase.openvpnInitialDuration, testCase.openvpnInitialErr)
+				if testCase.openvpnInitialErr == nil {
+					env.EXPECT().
+						Duration("HEALTH_OPENVPN_DURATION_ADDITION", gomock.Any()).
+						Return(testCase.openvpnAdditionDuration, testCase.openvpnAdditionErr)
+				}
+			}
+
+			r := reader{
+				env:    env,
+				logger: logger,
+			}
+
+			var health Health
+
+			err := health.read(r)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.expected, health)
+		})
+	}
+}

internal/configuration/healthwait_test.go

@@ -0,0 +1,55 @@
+package configuration
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_HealthyWait_String(t *testing.T) {
+	t.Parallel()
+
+	var healthyWait HealthyWait
+	const expected = "|--Initial duration: 0s"
+
+	s := healthyWait.String()
+
+	assert.Equal(t, expected, s)
+}
+
+func Test_HealthyWait_lines(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		settings HealthyWait
+		lines    []string
+	}{
+		"empty": {
+			lines: []string{
+				"|--Initial duration: 0s",
+			},
+		},
+		"filled settings": {
+			settings: HealthyWait{
+				Initial:  time.Second,
+				Addition: time.Minute,
+			},
+			lines: []string{
+				"|--Initial duration: 1s",
+				"|--Addition duration: 1m0s",
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			lines := testCase.settings.lines()
+
+			assert.Equal(t, testCase.lines, lines)
+		})
+	}
+}

internal/configuration/healthywait.go

@@ -0,0 +1,30 @@
+package configuration
+
+import (
+	"strings"
+	"time"
+)
+
+type HealthyWait struct {
+	// Initial is the initial duration to wait for the program
+	// to be healthy before taking action.
+	Initial time.Duration
+	// Addition is the duration to add to the Initial duration
+	// after Initial has expired to wait longer for the program
+	// to be healthy.
+	Addition time.Duration
+}
+
+func (settings *HealthyWait) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *HealthyWait) lines() (lines []string) {
+	lines = append(lines, lastIndent+"Initial duration: "+settings.Initial.String())
+
+	if settings.Addition > 0 {
+		lines = append(lines, lastIndent+"Addition duration: "+settings.Addition.String())
+	}
+
+	return lines
+}

internal/configuration/hidemyass.go

@@ -0,0 +1,40 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readHideMyAss(r reader) (err error) {
+	settings.Name = constants.HideMyAss
+	servers := r.servers.GetHideMyAss()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.HideMyAssCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.HideMyAssCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.HideMyAssCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.HideMyAssHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolAndPort(r.env)
+}

internal/configuration/httpproxy.go

@@ -0,0 +1,106 @@
+package configuration
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+// HTTPProxy contains settings to configure the HTTP proxy.
+type HTTPProxy struct {
+	User     string
+	Password string
+	Port     uint16
+	Enabled  bool
+	Stealth  bool
+	Log      bool
+}
+
+func (settings *HTTPProxy) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *HTTPProxy) lines() (lines []string) {
+	if !settings.Enabled {
+		return nil
+	}
+
+	lines = append(lines, lastIndent+"HTTP proxy:")
+
+	lines = append(lines, indent+lastIndent+"Port: "+strconv.Itoa(int(settings.Port)))
+
+	if settings.User != "" {
+		lines = append(lines, indent+lastIndent+"Authentication: enabled")
+	}
+
+	if settings.Log {
+		lines = append(lines, indent+lastIndent+"Log: enabled")
+	}
+
+	if settings.Stealth {
+		lines = append(lines, indent+lastIndent+"Stealth: enabled")
+	}
+
+	return lines
+}
+
+func (settings *HTTPProxy) read(r reader) (err error) {
+	settings.Enabled, err = r.env.OnOff("HTTPPROXY", params.Default("off"),
+		params.RetroKeys([]string{"TINYPROXY", "PROXY"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY (or TINYPROXY, PROXY): %w", err)
+	}
+
+	settings.User, err = r.getFromEnvOrSecretFile("HTTPPROXY_USER", false, // compulsory
+		[]string{"TINYPROXY_USER", "PROXY_USER"})
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY_USER (or TINYPROXY_USER, PROXY_USER): %w", err)
+	}
+
+	settings.Password, err = r.getFromEnvOrSecretFile("HTTPPROXY_PASSWORD", false,
+		[]string{"TINYPROXY_PASSWORD", "PROXY_PASSWORD"})
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY_PASSWORD (or TINYPROXY_PASSWORD, PROXY_PASSWORD): %w", err)
+	}
+
+	settings.Stealth, err = r.env.OnOff("HTTPPROXY_STEALTH", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY_STEALTH: %w", err)
+	}
+
+	if err := settings.readLog(r); err != nil {
+		return err
+	}
+
+	var warning string
+	settings.Port, warning, err = r.env.ListeningPort("HTTPPROXY_PORT", params.Default("8888"),
+		params.RetroKeys([]string{"TINYPROXY_PORT", "PROXY_PORT"}, r.onRetroActive))
+	if len(warning) > 0 {
+		r.logger.Warn(warning)
+	}
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY_PORT (or TINYPROXY_PORT, PROXY_PORT): %w", err)
+	}
+
+	return nil
+}
+
+func (settings *HTTPProxy) readLog(r reader) error {
+	s, err := r.env.Get("HTTPPROXY_LOG",
+		params.RetroKeys([]string{"PROXY_LOG_LEVEL", "TINYPROXY_LOG"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable HTTPPROXY_LOG (or TINYPROXY_LOG, PROXY_LOG_LEVEL): %w", err)
+	}
+
+	switch strings.ToLower(s) {
+	case "on":
+		settings.Log = true
+	// Retro compatibility
+	case "info", "connect", "notice":
+		settings.Log = true
+	}
+
+	return nil
+}

internal/configuration/ipvanish.go

@@ -0,0 +1,35 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readIpvanish(r reader) (err error) {
+	settings.Name = constants.Ipvanish
+	servers := r.servers.GetIpvanish()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IpvanishCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IpvanishCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.IpvanishHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}

internal/configuration/ipvanish_test.go

@@ -0,0 +1,170 @@
+package configuration
+
+import (
+	"errors"
+	"net"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_Provider_readIpvanish(t *testing.T) {
+	t.Parallel()
+
+	var errDummy = errors.New("dummy test error")
+
+	type singleStringCall struct {
+		call  bool
+		value string
+		err   error
+	}
+
+	type sliceStringCall struct {
+		call   bool
+		values []string
+		err    error
+	}
+
+	testCases := map[string]struct {
+		targetIP  singleStringCall
+		countries sliceStringCall
+		cities    sliceStringCall
+		hostnames sliceStringCall
+		protocol  singleStringCall
+		settings  Provider
+		err       error
+	}{
+		"target IP error": {
+			targetIP: singleStringCall{call: true, value: "something", err: errDummy},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+			err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"),
+		},
+		"countries error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+			err: errors.New("environment variable COUNTRY: dummy test error"),
+		},
+		"cities error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+			err: errors.New("environment variable CITY: dummy test error"),
+		},
+		"hostnames error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+			err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"),
+		},
+		"protocol error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+			err: errors.New("environment variable PROTOCOL: dummy test error"),
+		},
+		"default settings": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true},
+			settings: Provider{
+				Name: constants.Ipvanish,
+			},
+		},
+		"set settings": {
+			targetIP:  singleStringCall{call: true, value: "1.2.3.4"},
+			countries: sliceStringCall{call: true, values: []string{"A", "B"}},
+			cities:    sliceStringCall{call: true, values: []string{"C", "D"}},
+			hostnames: sliceStringCall{call: true, values: []string{"E", "F"}},
+			protocol:  singleStringCall{call: true, value: constants.TCP},
+			settings: Provider{
+				Name: constants.Ipvanish,
+				ServerSelection: ServerSelection{
+					OpenVPN: OpenVPNSelection{
+						TCP: true,
+					},
+					TargetIP:  net.IPv4(1, 2, 3, 4),
+					Countries: []string{"A", "B"},
+					Cities:    []string{"C", "D"},
+					Hostnames: []string{"E", "F"},
+				},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctrl := gomock.NewController(t)
+
+			servers := []models.IpvanishServer{{Hostname: "a"}}
+			allServers := models.AllServers{
+				Ipvanish: models.IpvanishServers{
+					Servers: servers,
+				},
+			}
+
+			env := mock_params.NewMockInterface(ctrl)
+			if testCase.targetIP.call {
+				env.EXPECT().Get("OPENVPN_TARGET_IP").
+					Return(testCase.targetIP.value, testCase.targetIP.err)
+			}
+			if testCase.countries.call {
+				env.EXPECT().CSVInside("COUNTRY", constants.IpvanishCountryChoices(servers)).
+					Return(testCase.countries.values, testCase.countries.err)
+			}
+			if testCase.cities.call {
+				env.EXPECT().CSVInside("CITY", constants.IpvanishCityChoices(servers)).
+					Return(testCase.cities.values, testCase.cities.err)
+			}
+			if testCase.hostnames.call {
+				env.EXPECT().CSVInside("SERVER_HOSTNAME", constants.IpvanishHostnameChoices(servers)).
+					Return(testCase.hostnames.values, testCase.hostnames.err)
+			}
+			if testCase.protocol.call {
+				env.EXPECT().Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, gomock.Any()).
+					Return(testCase.protocol.value, testCase.protocol.err)
+			}
+
+			r := reader{
+				servers: allServers,
+				env:     env,
+			}
+
+			var settings Provider
+			err := settings.readIpvanish(r)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.settings, settings)
+		})
+	}
+}

internal/configuration/ivpn.go

@@ -0,0 +1,70 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readIvpn(r reader) (err error) {
+	settings.Name = constants.Ivpn
+	servers := r.servers.GetIvpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.IvpnCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.IvpnCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.ISPs, err = r.env.CSVInside("ISP", constants.IvpnISPChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable ISP: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.IvpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	err = settings.ServerSelection.OpenVPN.readIVPN(r.env)
+	if err != nil {
+		return err
+	}
+
+	return settings.ServerSelection.Wireguard.readIVPN(r.env)
+}
+
+func (settings *OpenVPNSelection) readIVPN(env params.Interface) (err error) {
+	settings.TCP, err = readProtocol(env)
+	if err != nil {
+		return err
+	}
+
+	settings.CustomPort, err = readOpenVPNCustomPort(env, settings.TCP,
+		[]uint16{80, 443, 1443}, []uint16{53, 1194, 2049, 2050})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (settings *WireguardSelection) readIVPN(env params.Interface) (err error) {
+	settings.CustomPort, err = readWireguardCustomPort(env,
+		[]uint16{2049, 2050, 53, 30587, 41893, 48574, 58237})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/ivpn_test.go

@@ -0,0 +1,253 @@
+package configuration
+
+import (
+	"errors"
+	"net"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_Provider_readIvpn(t *testing.T) { //nolint:gocognit
+	t.Parallel()
+
+	var errDummy = errors.New("dummy test error")
+
+	type singleStringCall struct {
+		call  bool
+		value string
+		err   error
+	}
+
+	type portCall struct {
+		getCall   bool
+		getValue  string // "" or "0"
+		getErr    error
+		portCall  bool
+		portValue uint16
+		portErr   error
+	}
+
+	type sliceStringCall struct {
+		call   bool
+		values []string
+		err    error
+	}
+
+	testCases := map[string]struct {
+		targetIP  singleStringCall
+		countries sliceStringCall
+		cities    sliceStringCall
+		isps      sliceStringCall
+		hostnames sliceStringCall
+		protocol  singleStringCall
+		ovpnPort  portCall
+		wgPort    portCall
+		settings  Provider
+		err       error
+	}{
+		"target IP error": {
+			targetIP: singleStringCall{call: true, value: "something", err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"),
+		},
+		"countries error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable COUNTRY: dummy test error"),
+		},
+		"cities error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable CITY: dummy test error"),
+		},
+		"isps error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable ISP: dummy test error"),
+		},
+		"hostnames error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"),
+		},
+		"openvpn protocol error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable PROTOCOL: dummy test error"),
+		},
+		"openvpn custom port error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true},
+			ovpnPort:  portCall{getCall: true, getErr: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable PORT: dummy test error"),
+		},
+		"wireguard custom port error": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true},
+			ovpnPort:  portCall{getCall: true, getValue: "0"},
+			wgPort:    portCall{getCall: true, getErr: errDummy},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+			err: errors.New("environment variable WIREGUARD_PORT: dummy test error"),
+		},
+		"default settings": {
+			targetIP:  singleStringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			isps:      sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  singleStringCall{call: true},
+			ovpnPort:  portCall{getCall: true, getValue: "0"},
+			wgPort:    portCall{getCall: true, getValue: "0"},
+			settings: Provider{
+				Name: constants.Ivpn,
+			},
+		},
+		"set settings": {
+			targetIP:  singleStringCall{call: true, value: "1.2.3.4"},
+			countries: sliceStringCall{call: true, values: []string{"A", "B"}},
+			cities:    sliceStringCall{call: true, values: []string{"C", "D"}},
+			isps:      sliceStringCall{call: true, values: []string{"ISP 1"}},
+			hostnames: sliceStringCall{call: true, values: []string{"E", "F"}},
+			protocol:  singleStringCall{call: true, value: constants.TCP},
+			ovpnPort:  portCall{getCall: true, portCall: true, portValue: 443},
+			wgPort:    portCall{getCall: true, portCall: true, portValue: 2049},
+			settings: Provider{
+				Name: constants.Ivpn,
+				ServerSelection: ServerSelection{
+					OpenVPN: OpenVPNSelection{
+						TCP:        true,
+						CustomPort: 443,
+					},
+					Wireguard: WireguardSelection{
+						CustomPort: 2049,
+					},
+					TargetIP:  net.IPv4(1, 2, 3, 4),
+					Countries: []string{"A", "B"},
+					Cities:    []string{"C", "D"},
+					ISPs:      []string{"ISP 1"},
+					Hostnames: []string{"E", "F"},
+				},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctrl := gomock.NewController(t)
+
+			env := mock_params.NewMockInterface(ctrl)
+
+			servers := []models.IvpnServer{{Hostname: "a"}}
+			allServers := models.AllServers{
+				Ivpn: models.IvpnServers{
+					Servers: servers,
+				},
+			}
+
+			if testCase.targetIP.call {
+				env.EXPECT().Get("OPENVPN_TARGET_IP").
+					Return(testCase.targetIP.value, testCase.targetIP.err)
+			}
+			if testCase.countries.call {
+				env.EXPECT().CSVInside("COUNTRY", constants.IvpnCountryChoices(servers)).
+					Return(testCase.countries.values, testCase.countries.err)
+			}
+			if testCase.cities.call {
+				env.EXPECT().CSVInside("CITY", constants.IvpnCityChoices(servers)).
+					Return(testCase.cities.values, testCase.cities.err)
+			}
+			if testCase.isps.call {
+				env.EXPECT().CSVInside("ISP", constants.IvpnISPChoices(servers)).
+					Return(testCase.isps.values, testCase.isps.err)
+			}
+			if testCase.hostnames.call {
+				env.EXPECT().CSVInside("SERVER_HOSTNAME", constants.IvpnHostnameChoices(servers)).
+					Return(testCase.hostnames.values, testCase.hostnames.err)
+			}
+			if testCase.protocol.call {
+				env.EXPECT().Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, gomock.Any()).
+					Return(testCase.protocol.value, testCase.protocol.err)
+			}
+			if testCase.ovpnPort.getCall {
+				env.EXPECT().Get("PORT", gomock.Any()).
+					Return(testCase.ovpnPort.getValue, testCase.ovpnPort.getErr)
+			}
+			if testCase.ovpnPort.portCall {
+				env.EXPECT().Port("PORT").
+					Return(testCase.ovpnPort.portValue, testCase.ovpnPort.portErr)
+			}
+			if testCase.wgPort.getCall {
+				env.EXPECT().Get("WIREGUARD_PORT", gomock.Any()).
+					Return(testCase.wgPort.getValue, testCase.wgPort.getErr)
+			}
+			if testCase.wgPort.portCall {
+				env.EXPECT().Port("WIREGUARD_PORT").
+					Return(testCase.wgPort.portValue, testCase.wgPort.portErr)
+			}
+
+			r := reader{
+				servers: allServers,
+				env:     env,
+			}
+
+			var settings Provider
+			err := settings.readIvpn(r)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.settings, settings)
+		})
+	}
+}

internal/configuration/keys.go

@@ -0,0 +1,55 @@
+package configuration
+
+import (
+	"encoding/pem"
+	"errors"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func readClientKey(r reader) (clientKey string, err error) {
+	b, err := r.getFromFileOrSecretFile("OPENVPN_CLIENTKEY", constants.ClientKey)
+	if err != nil {
+		return "", err
+	}
+	return extractClientKey(b)
+}
+
+var errDecodePEMBlockClientKey = errors.New("cannot decode PEM block from client key")
+
+func extractClientKey(b []byte) (key string, err error) {
+	pemBlock, _ := pem.Decode(b)
+	if pemBlock == nil {
+		return "", errDecodePEMBlockClientKey
+	}
+	parsedBytes := pem.EncodeToMemory(pemBlock)
+	s := string(parsedBytes)
+	s = strings.ReplaceAll(s, "\n", "")
+	s = strings.TrimPrefix(s, "-----BEGIN PRIVATE KEY-----")
+	s = strings.TrimSuffix(s, "-----END PRIVATE KEY-----")
+	return s, nil
+}
+
+func readClientCertificate(r reader) (clientCertificate string, err error) {
+	b, err := r.getFromFileOrSecretFile("OPENVPN_CLIENTCRT", constants.ClientCertificate)
+	if err != nil {
+		return "", err
+	}
+	return extractClientCertificate(b)
+}
+
+var errDecodePEMBlockClientCert = errors.New("cannot decode PEM block from client certificate")
+
+func extractClientCertificate(b []byte) (certificate string, err error) {
+	pemBlock, _ := pem.Decode(b)
+	if pemBlock == nil {
+		return "", errDecodePEMBlockClientCert
+	}
+	parsedBytes := pem.EncodeToMemory(pemBlock)
+	s := string(parsedBytes)
+	s = strings.ReplaceAll(s, "\n", "")
+	s = strings.TrimPrefix(s, "-----BEGIN CERTIFICATE-----")
+	s = strings.TrimSuffix(s, "-----END CERTIFICATE-----")
+	return s, nil
+}

internal/configuration/keys_test.go

@@ -0,0 +1,174 @@
+package configuration
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_extractClientKey(t *testing.T) {
+	t.Parallel()
+	const validPEM = `
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+`
+	const validKeyString = "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" //nolint:lll
+	testCases := map[string]struct {
+		b   []byte
+		key string
+		err error
+	}{
+		"no input": {
+			err: errDecodePEMBlockClientKey,
+		},
+		"bad input": {
+			b:   []byte{1, 2, 3},
+			err: errDecodePEMBlockClientKey,
+		},
+		"valid key": {
+			b:   []byte(validPEM),
+			key: validKeyString,
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			key, err := extractClientKey(testCase.b)
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, testCase.key, key)
+		})
+	}
+}
+
+func Test_extractClientCertificate(t *testing.T) {
+	t.Parallel()
+	const validPEM = `
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+`
+	const validCertificateString = "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" //nolint:lll
+	testCases := map[string]struct {
+		b           []byte
+		certificate string
+		err         error
+	}{
+		"no input": {
+			err: errDecodePEMBlockClientCert,
+		},
+		"bad input": {
+			b:   []byte{1, 2, 3},
+			err: errDecodePEMBlockClientCert,
+		},
+		"valid key": {
+			b:           []byte(validPEM),
+			certificate: validCertificateString,
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			certificate, err := extractClientCertificate(testCase.b)
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+			assert.Equal(t, testCase.certificate, certificate)
+		})
+	}
+}

internal/configuration/lines.go

@@ -0,0 +1,22 @@
+package configuration
+
+import (
+	"net"
+	"strconv"
+)
+
+func uint16sToStrings(uint16s []uint16) (strings []string) {
+	strings = make([]string, len(uint16s))
+	for i := range uint16s {
+		strings[i] = strconv.Itoa(int(uint16s[i]))
+	}
+	return strings
+}
+
+func ipNetsToStrings(ipNets []net.IPNet) (strings []string) {
+	strings = make([]string, len(ipNets))
+	for i := range ipNets {
+		strings[i] = ipNets[i].String()
+	}
+	return strings
+}

internal/configuration/log.go

@@ -0,0 +1,30 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+)
+
+type Log struct {
+	Level logging.Level `json:"level"`
+}
+
+func (settings *Log) lines() (lines []string) {
+	lines = append(lines, lastIndent+"Log:")
+
+	lines = append(lines, indent+lastIndent+"Level: "+settings.Level.String())
+
+	return lines
+}
+
+func (settings *Log) read(env params.Interface) (err error) {
+	defaultLevel := logging.LevelInfo.String()
+	settings.Level, err = env.LogLevel("LOG_LEVEL", params.Default(defaultLevel))
+	if err != nil {
+		return fmt.Errorf("environment variable LOG_LEVEL: %w", err)
+	}
+
+	return nil
+}

internal/configuration/mullvad.go

@@ -0,0 +1,74 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readMullvad(r reader) (err error) {
+	settings.Name = constants.Mullvad
+	servers := r.servers.GetMullvad()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.MullvadCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.MullvadCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.MullvadHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.ISPs, err = r.env.CSVInside("ISP", constants.MullvadISPChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable ISP: %w", err)
+	}
+
+	settings.ServerSelection.Owned, err = r.env.YesNo("OWNED", params.Default("no"))
+	if err != nil {
+		return fmt.Errorf("environment variable OWNED: %w", err)
+	}
+
+	err = settings.ServerSelection.OpenVPN.readMullvad(r.env)
+	if err != nil {
+		return err
+	}
+
+	return settings.ServerSelection.Wireguard.readMullvad(r.env)
+}
+
+func (settings *OpenVPNSelection) readMullvad(env params.Interface) (err error) {
+	settings.TCP, err = readProtocol(env)
+	if err != nil {
+		return err
+	}
+
+	settings.CustomPort, err = readOpenVPNCustomPort(env, settings.TCP,
+		[]uint16{80, 443, 1401}, []uint16{53, 1194, 1195, 1196, 1197, 1300, 1301, 1302, 1303, 1400})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (settings *WireguardSelection) readMullvad(env params.Interface) (err error) {
+	settings.CustomPort, err = readWireguardCustomPort(env, nil)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/nordvpn.go

@@ -0,0 +1,63 @@
+package configuration
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readNordvpn(r reader) (err error) {
+	settings.Name = constants.Nordvpn
+	servers := r.servers.GetNordvpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.NordvpnRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.NordvpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.NordvpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
+	}
+
+	settings.ServerSelection.Numbers, err = readNordVPNServerNumbers(r.env)
+	if err != nil {
+		return err
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}
+
+func readNordVPNServerNumbers(env params.Interface) (numbers []uint16, err error) {
+	const possiblePortsCount = 65537
+	possibilities := make([]string, possiblePortsCount)
+	for i := range possibilities {
+		possibilities[i] = fmt.Sprintf("%d", i)
+	}
+	possibilities[65536] = ""
+	values, err := env.CSVInside("SERVER_NUMBER", possibilities)
+	if err != nil {
+		return nil, err
+	}
+	numbers = make([]uint16, len(values))
+	for i := range values {
+		n, err := strconv.Atoi(values[i])
+		if err != nil {
+			return nil, err
+		}
+		numbers[i] = uint16(n)
+	}
+	return numbers, nil
+}

internal/configuration/openvpn.go

@@ -0,0 +1,204 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+// OpenVPN contains settings to configure the OpenVPN client.
+type OpenVPN struct {
+	User      string   `json:"user"`
+	Password  string   `json:"password"`
+	Verbosity int      `json:"verbosity"`
+	Flags     []string `json:"flags"`
+	MSSFix    uint16   `json:"mssfix"`
+	Root      bool     `json:"run_as_root"`
+	Cipher    string   `json:"cipher"`
+	Auth      string   `json:"auth"`
+	Config    string   `json:"custom_config"`
+	Version   string   `json:"version"`
+	ClientCrt string   `json:"-"`                 // Cyberghost
+	ClientKey string   `json:"-"`                 // Cyberghost, VPNUnlimited
+	EncPreset string   `json:"encryption_preset"` // PIA
+	IPv6      bool     `json:"ipv6"`              // Mullvad
+	ProcUser  string   `json:"procuser"`          // Process username
+	Interface string   `json:"interface"`
+}
+
+func (settings *OpenVPN) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *OpenVPN) lines() (lines []string) {
+	lines = append(lines, lastIndent+"OpenVPN:")
+
+	lines = append(lines, indent+lastIndent+"Version: "+settings.Version)
+
+	lines = append(lines, indent+lastIndent+"Verbosity level: "+strconv.Itoa(settings.Verbosity))
+
+	lines = append(lines, indent+lastIndent+"Network interface: "+settings.Interface)
+
+	if len(settings.Flags) > 0 {
+		lines = append(lines, indent+lastIndent+"Flags: "+strings.Join(settings.Flags, " "))
+	}
+
+	if settings.Root {
+		lines = append(lines, indent+lastIndent+"Run as root: enabled")
+	}
+
+	if len(settings.Cipher) > 0 {
+		lines = append(lines, indent+lastIndent+"Custom cipher: "+settings.Cipher)
+	}
+	if len(settings.Auth) > 0 {
+		lines = append(lines, indent+lastIndent+"Custom auth algorithm: "+settings.Auth)
+	}
+
+	if len(settings.Config) > 0 {
+		lines = append(lines, indent+lastIndent+"Custom configuration: "+settings.Config)
+	}
+
+	if settings.ClientKey != "" {
+		lines = append(lines, indent+lastIndent+"Client key is set")
+	}
+
+	if settings.ClientCrt != "" {
+		lines = append(lines, indent+lastIndent+"Client certificate is set")
+	}
+
+	if settings.IPv6 {
+		lines = append(lines, indent+lastIndent+"IPv6: enabled")
+	}
+
+	if settings.EncPreset != "" { // PIA only
+		lines = append(lines, indent+lastIndent+"Encryption preset: "+settings.EncPreset)
+	}
+
+	return lines
+}
+
+func (settings *OpenVPN) read(r reader, serviceProvider string) (err error) {
+	settings.Config, err = r.env.Get("OPENVPN_CUSTOM_CONFIG", params.CaseSensitiveValue())
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_CUSTOM_CONFIG: %w", err)
+	}
+
+	credentialsRequired := settings.Config == "" && serviceProvider != constants.VPNUnlimited
+
+	settings.User, err = r.getFromEnvOrSecretFile("OPENVPN_USER", credentialsRequired, []string{"USER"})
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_USER: %w", err)
+	}
+	// Remove spaces in user ID to simplify user's life, thanks @JeordyR
+	settings.User = strings.ReplaceAll(settings.User, " ", "")
+
+	if serviceProvider == constants.Mullvad {
+		settings.Password = "m"
+	} else {
+		settings.Password, err = r.getFromEnvOrSecretFile("OPENVPN_PASSWORD", credentialsRequired, []string{"PASSWORD"})
+		if err != nil {
+			return err
+		}
+	}
+
+	settings.Version, err = r.env.Inside("OPENVPN_VERSION",
+		[]string{constants.Openvpn24, constants.Openvpn25}, params.Default(constants.Openvpn25))
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_VERSION: %w", err)
+	}
+
+	settings.Verbosity, err = r.env.IntRange("OPENVPN_VERBOSITY", 0, 6, params.Default("1")) //nolint:gomnd
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_VERBOSITY: %w", err)
+	}
+
+	settings.Flags = []string{}
+	flagsStr, err := r.env.Get("OPENVPN_FLAGS")
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_FLAGS: %w", err)
+	}
+	if flagsStr != "" {
+		settings.Flags = strings.Fields(flagsStr)
+	}
+
+	settings.Root, err = r.env.YesNo("OPENVPN_ROOT", params.Default("yes"))
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_ROOT: %w", err)
+	}
+
+	settings.Cipher, err = r.env.Get("OPENVPN_CIPHER")
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_CIPHER: %w", err)
+	}
+
+	settings.Auth, err = r.env.Get("OPENVPN_AUTH")
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_AUTH: %w", err)
+	}
+
+	const maxMSSFix = 10000
+	mssFix, err := r.env.IntRange("OPENVPN_MSSFIX", 0, maxMSSFix, params.Default("0"))
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_MSSFIX: %w", err)
+	}
+	settings.MSSFix = uint16(mssFix)
+
+	settings.IPv6, err = r.env.OnOff("OPENVPN_IPV6", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable OPENVPN_IPV6: %w", err)
+	}
+
+	settings.Interface, err = readInterface(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.EncPreset, err = getPIAEncryptionPreset(r)
+	if err != nil {
+		return err
+	}
+
+	switch serviceProvider {
+	case constants.Cyberghost:
+		err = settings.readCyberghost(r)
+	case constants.VPNUnlimited:
+		err = settings.readVPNUnlimited(r)
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func readProtocol(env params.Interface) (tcp bool, err error) {
+	protocol, err := env.Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, params.Default(constants.UDP))
+	if err != nil {
+		return false, fmt.Errorf("environment variable PROTOCOL: %w", err)
+	}
+	return protocol == constants.TCP, nil
+}
+
+const openvpnIntfRegexString = `^.*[0-9]$`
+
+var openvpnIntfRegexp = regexp.MustCompile(openvpnIntfRegexString)
+var errInterfaceNameNotValid = errors.New("interface name is not valid")
+
+func readInterface(env params.Interface) (intf string, err error) {
+	intf, err = env.Get("OPENVPN_INTERFACE", params.Default("tun0"))
+	if err != nil {
+		return "", fmt.Errorf("environment variable OPENVPN_INTERFACE: %w", err)
+	}
+
+	if !openvpnIntfRegexp.MatchString(intf) {
+		return "", fmt.Errorf("%w: does not match regex %s: %s",
+			errInterfaceNameNotValid, openvpnIntfRegexString, intf)
+	}
+
+	return intf, nil
+}

internal/configuration/openvpn_test.go

@@ -0,0 +1,39 @@
+package configuration
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_OpenVPN_JSON(t *testing.T) {
+	t.Parallel()
+	in := OpenVPN{
+		Root:  true,
+		Flags: []string{},
+	}
+	data, err := json.MarshalIndent(in, "", "  ")
+	require.NoError(t, err)
+	assert.Equal(t, `{
+  "user": "",
+  "password": "",
+  "verbosity": 0,
+  "flags": [],
+  "mssfix": 0,
+  "run_as_root": true,
+  "cipher": "",
+  "auth": "",
+  "custom_config": "",
+  "version": "",
+  "encryption_preset": "",
+  "ipv6": false,
+  "procuser": "",
+  "interface": ""
+}`, string(data))
+	var out OpenVPN
+	err = json.Unmarshal(data, &out)
+	require.NoError(t, err)
+	assert.Equal(t, in, out)
+}

internal/configuration/privado.go

@@ -0,0 +1,39 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readPrivado(r reader) (err error) {
+	settings.Name = constants.Privado
+	servers := r.servers.GetPrivado()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivadoCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PrivadoRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivadoCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PrivadoHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return nil
+}

internal/configuration/privateinternetaccess.go

@@ -0,0 +1,75 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readPrivateInternetAccess(r reader) (err error) {
+	settings.Name = constants.PrivateInternetAccess
+	servers := r.servers.GetPia()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PIAGeoChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PIAHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_NAME", constants.PIANameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
+	}
+
+	settings.PortForwarding.Enabled, err = r.env.OnOff("PORT_FORWARDING", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable PORT_FORWARDING: %w", err)
+	}
+
+	if settings.PortForwarding.Enabled {
+		settings.PortForwarding.Filepath, err = r.env.Path("PORT_FORWARDING_STATUS_FILE",
+			params.Default("/tmp/gluetun/forwarded_port"), params.CaseSensitiveValue())
+		if err != nil {
+			return fmt.Errorf("environment variable PORT_FORWARDING_STATUS_FILE: %w", err)
+		}
+	}
+
+	return settings.ServerSelection.OpenVPN.readPrivateInternetAccess(r)
+}
+
+func (settings *OpenVPNSelection) readPrivateInternetAccess(r reader) (err error) {
+	settings.EncPreset, err = getPIAEncryptionPreset(r)
+	if err != nil {
+		return err
+	}
+
+	settings.CustomPort, err = readPortOrZero(r.env, "PORT")
+	if err != nil {
+		return fmt.Errorf("environment variable PORT: %w", err)
+	}
+
+	return nil
+}
+
+func getPIAEncryptionPreset(r reader) (encryptionPreset string, err error) {
+	encryptionPreset, err = r.env.Inside("PIA_ENCRYPTION",
+		[]string{constants.PIAEncryptionPresetNone, constants.PIAEncryptionPresetNormal, constants.PIAEncryptionPresetStrong},
+		params.RetroKeys([]string{"ENCRYPTION"}, r.onRetroActive),
+		params.Default(constants.PIACertificateStrong),
+	)
+	if err != nil {
+		return "", fmt.Errorf("environment variable PIA_ENCRYPTION: %w", err)
+	}
+
+	return encryptionPreset, nil
+}

internal/configuration/privatevpn.go

@@ -0,0 +1,35 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readPrivatevpn(r reader) (err error) {
+	settings.Name = constants.Privatevpn
+	servers := r.servers.GetPrivatevpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PrivatevpnCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PrivatevpnCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.PrivatevpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolAndPort(r.env)
+}

internal/configuration/protonvpn.go

@@ -0,0 +1,51 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readProtonvpn(r reader) (err error) {
+	settings.Name = constants.Protonvpn
+	servers := r.servers.GetProtonvpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.ProtonvpnCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.ProtonvpnRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.ProtonvpnCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Names, err = r.env.CSVInside("SERVER_NAME", constants.ProtonvpnNameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_NAME: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.ProtonvpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no"))
+	if err != nil {
+		return fmt.Errorf("environment variable FREE_ONLY: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolAndPort(r.env)
+}

internal/configuration/provider.go

@@ -0,0 +1,201 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+// Provider contains settings specific to a VPN provider.
+type Provider struct {
+	Name            string          `json:"name"`
+	ServerSelection ServerSelection `json:"server_selection"`
+	PortForwarding  PortForwarding  `json:"port_forwarding"`
+}
+
+func (settings *Provider) lines() (lines []string) {
+	if settings.Name == "" { // custom OpenVPN configuration
+		return nil
+	}
+
+	lines = append(lines, lastIndent+strings.Title(settings.Name)+" settings:")
+
+	for _, line := range settings.ServerSelection.toLines() {
+		lines = append(lines, indent+line)
+	}
+
+	if settings.PortForwarding.Enabled { // PIA
+		lines = append(lines, indent+lastIndent+"Port forwarding:")
+		for _, line := range settings.PortForwarding.lines() {
+			lines = append(lines, indent+indent+line)
+		}
+	}
+
+	return lines
+}
+
+var (
+	ErrInvalidVPNProvider = errors.New("invalid VPN provider")
+)
+
+func (settings *Provider) read(r reader, vpnType string) error {
+	err := settings.readVPNServiceProvider(r, vpnType)
+	if err != nil {
+		return err
+	}
+
+	switch settings.Name {
+	case constants.Cyberghost:
+		err = settings.readCyberghost(r)
+	case constants.Fastestvpn:
+		err = settings.readFastestvpn(r)
+	case constants.HideMyAss:
+		err = settings.readHideMyAss(r)
+	case constants.Ipvanish:
+		err = settings.readIpvanish(r)
+	case constants.Ivpn:
+		err = settings.readIvpn(r)
+	case constants.Mullvad:
+		err = settings.readMullvad(r)
+	case constants.Nordvpn:
+		err = settings.readNordvpn(r)
+	case constants.Privado:
+		err = settings.readPrivado(r)
+	case constants.PrivateInternetAccess:
+		err = settings.readPrivateInternetAccess(r)
+	case constants.Privatevpn:
+		err = settings.readPrivatevpn(r)
+	case constants.Protonvpn:
+		err = settings.readProtonvpn(r)
+	case constants.Purevpn:
+		err = settings.readPurevpn(r)
+	case constants.Surfshark:
+		err = settings.readSurfshark(r)
+	case constants.Torguard:
+		err = settings.readTorguard(r)
+	case constants.VPNUnlimited:
+		err = settings.readVPNUnlimited(r)
+	case constants.Vyprvpn:
+		err = settings.readVyprvpn(r)
+	case constants.Windscribe:
+		err = settings.readWindscribe(r)
+	default:
+		return fmt.Errorf("%w: %s", ErrInvalidVPNProvider, settings.Name)
+	}
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.VPN = vpnType
+	return nil
+}
+
+func (settings *Provider) readVPNServiceProvider(r reader, vpnType string) (err error) {
+	var allowedVPNServiceProviders []string
+	switch vpnType {
+	case constants.OpenVPN:
+		allowedVPNServiceProviders = []string{
+			"cyberghost", "fastestvpn", "hidemyass", "ipvanish", "ivpn", "mullvad", "nordvpn",
+			"privado", "pia", "private internet access", "privatevpn", "protonvpn",
+			"purevpn", "surfshark", "torguard", constants.VPNUnlimited, "vyprvpn", "windscribe"}
+	case constants.Wireguard:
+		allowedVPNServiceProviders = []string{constants.Mullvad, constants.Windscribe,
+			constants.Ivpn}
+	}
+
+	vpnsp, err := r.env.Inside("VPNSP", allowedVPNServiceProviders,
+		params.Default("private internet access"))
+	if err != nil {
+		return fmt.Errorf("environment variable VPNSP: %w", err)
+	}
+	if vpnsp == "pia" { // retro compatibility
+		vpnsp = "private internet access"
+	}
+	settings.Name = vpnsp
+
+	return nil
+}
+
+func commaJoin(slice []string) string {
+	return strings.Join(slice, ", ")
+}
+
+func protoToString(tcp bool) string {
+	if tcp {
+		return constants.TCP
+	}
+	return constants.UDP
+}
+
+func readTargetIP(env params.Interface) (targetIP net.IP, err error) {
+	targetIP, err = readIP(env, "OPENVPN_TARGET_IP")
+	if err != nil {
+		return nil, fmt.Errorf("environment variable OPENVPN_TARGET_IP: %w", err)
+	}
+	return targetIP, nil
+}
+
+func readOpenVPNCustomPort(env params.Interface, tcp bool,
+	allowedTCP, allowedUDP []uint16) (port uint16, err error) {
+	port, err = readPortOrZero(env, "PORT")
+	if err != nil {
+		return 0, fmt.Errorf("environment variable PORT: %w", err)
+	} else if port == 0 {
+		return 0, nil
+	}
+
+	if tcp {
+		for i := range allowedTCP {
+			if allowedTCP[i] == port {
+				return port, nil
+			}
+		}
+		return 0, fmt.Errorf(
+			"environment variable PORT: %w: port %d for TCP protocol, can only be one of %s",
+			ErrInvalidPort, port, portsToString(allowedTCP))
+	}
+	for i := range allowedUDP {
+		if allowedUDP[i] == port {
+			return port, nil
+		}
+	}
+	return 0, fmt.Errorf(
+		"environment variable PORT: %w: port %d for UDP protocol, can only be one of %s",
+		ErrInvalidPort, port, portsToString(allowedUDP))
+}
+
+// note: set allowed to an empty slice to allow all valid ports
+func readWireguardCustomPort(env params.Interface, allowed []uint16) (port uint16, err error) {
+	port, err = readPortOrZero(env, "WIREGUARD_PORT")
+	if err != nil {
+		return 0, fmt.Errorf("environment variable WIREGUARD_PORT: %w", err)
+	} else if port == 0 {
+		return 0, nil
+	}
+
+	if len(allowed) == 0 {
+		return port, nil
+	}
+
+	for i := range allowed {
+		if allowed[i] == port {
+			return port, nil
+		}
+	}
+
+	return 0, fmt.Errorf(
+		"environment variable WIREGUARD_PORT: %w: port %d, can only be one of %s",
+		ErrInvalidPort, port, portsToString(allowed))
+}
+
+func portsToString(ports []uint16) string {
+	slice := make([]string, len(ports))
+	for i := range ports {
+		slice[i] = fmt.Sprint(ports[i])
+	}
+	return strings.Join(slice, ", ")
+}

internal/configuration/provider_test.go

@@ -0,0 +1,406 @@
+package configuration
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var errDummy = errors.New("dummy")
+
+func Test_Provider_lines(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		settings Provider
+		lines    []string
+	}{
+		"cyberghost": {
+			settings: Provider{
+				Name: constants.Cyberghost,
+				ServerSelection: ServerSelection{
+					VPN:     constants.OpenVPN,
+					Groups:  []string{"group"},
+					Regions: []string{"a", "El country"},
+				},
+			},
+			lines: []string{
+				"|--Cyberghost settings:",
+				"   |--Server groups: group",
+				"   |--Regions: a, El country",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"fastestvpn": {
+			settings: Provider{
+				Name: constants.Fastestvpn,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Hostnames: []string{"a", "b"},
+					Countries: []string{"c", "d"},
+				},
+			},
+			lines: []string{
+				"|--Fastestvpn settings:",
+				"   |--Countries: c, d",
+				"   |--Hostnames: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"hidemyass": {
+			settings: Provider{
+				Name: constants.HideMyAss,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					Hostnames: []string{"e", "f"},
+				},
+			},
+			lines: []string{
+				"|--Hidemyass settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--Hostnames: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"ipvanish": {
+			settings: Provider{
+				Name: constants.Ipvanish,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					Hostnames: []string{"e", "f"},
+				},
+			},
+			lines: []string{
+				"|--Ipvanish settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--Hostnames: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"ivpn": {
+			settings: Provider{
+				Name: constants.Ivpn,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					Hostnames: []string{"e", "f"},
+				},
+			},
+			lines: []string{
+				"|--Ivpn settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--Hostnames: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"mullvad": {
+			settings: Provider{
+				Name: constants.Mullvad,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					ISPs:      []string{"e", "f"},
+					OpenVPN: OpenVPNSelection{
+						CustomPort: 1,
+					},
+				},
+			},
+			lines: []string{
+				"|--Mullvad settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--ISPs: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+				"      |--Custom port: 1",
+			},
+		},
+		"nordvpn": {
+			settings: Provider{
+				Name: constants.Nordvpn,
+				ServerSelection: ServerSelection{
+					VPN:     constants.OpenVPN,
+					Regions: []string{"a", "b"},
+					Numbers: []uint16{1, 2},
+				},
+			},
+			lines: []string{
+				"|--Nordvpn settings:",
+				"   |--Regions: a, b",
+				"   |--Numbers: 1, 2",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"privado": {
+			settings: Provider{
+				Name: constants.Privado,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Hostnames: []string{"a", "b"},
+				},
+			},
+			lines: []string{
+				"|--Privado settings:",
+				"   |--Hostnames: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"privatevpn": {
+			settings: Provider{
+				Name: constants.Privatevpn,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Hostnames: []string{"a", "b"},
+					Countries: []string{"c", "d"},
+					Cities:    []string{"e", "f"},
+				},
+			},
+			lines: []string{
+				"|--Privatevpn settings:",
+				"   |--Countries: c, d",
+				"   |--Cities: e, f",
+				"   |--Hostnames: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"protonvpn": {
+			settings: Provider{
+				Name: constants.Protonvpn,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Regions:   []string{"c", "d"},
+					Cities:    []string{"e", "f"},
+					Names:     []string{"g", "h"},
+					Hostnames: []string{"i", "j"},
+				},
+			},
+			lines: []string{
+				"|--Protonvpn settings:",
+				"   |--Countries: a, b",
+				"   |--Regions: c, d",
+				"   |--Cities: e, f",
+				"   |--Hostnames: i, j",
+				"   |--Names: g, h",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"private internet access": {
+			settings: Provider{
+				Name: constants.PrivateInternetAccess,
+				ServerSelection: ServerSelection{
+					VPN:     constants.OpenVPN,
+					Regions: []string{"a", "b"},
+					OpenVPN: OpenVPNSelection{
+						CustomPort: 1,
+					},
+				},
+				PortForwarding: PortForwarding{
+					Enabled:  true,
+					Filepath: string("/here"),
+				},
+			},
+			lines: []string{
+				"|--Private Internet Access settings:",
+				"   |--Regions: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+				"      |--Custom port: 1",
+				"   |--Port forwarding:",
+				"      |--File path: /here",
+			},
+		},
+		"purevpn": {
+			settings: Provider{
+				Name: constants.Purevpn,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Regions:   []string{"a", "b"},
+					Countries: []string{"c", "d"},
+					Cities:    []string{"e", "f"},
+				},
+			},
+			lines: []string{
+				"|--Purevpn settings:",
+				"   |--Countries: c, d",
+				"   |--Regions: a, b",
+				"   |--Cities: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"surfshark": {
+			settings: Provider{
+				Name: constants.Surfshark,
+				ServerSelection: ServerSelection{
+					VPN:     constants.OpenVPN,
+					Regions: []string{"a", "b"},
+				},
+			},
+			lines: []string{
+				"|--Surfshark settings:",
+				"   |--Regions: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"torguard": {
+			settings: Provider{
+				Name: constants.Torguard,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Countries: []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					Hostnames: []string{"e"},
+				},
+			},
+			lines: []string{
+				"|--Torguard settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--Hostnames: e",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		constants.VPNUnlimited: {
+			settings: Provider{
+				Name: constants.VPNUnlimited,
+				ServerSelection: ServerSelection{
+					VPN:        constants.OpenVPN,
+					Countries:  []string{"a", "b"},
+					Cities:     []string{"c", "d"},
+					Hostnames:  []string{"e", "f"},
+					FreeOnly:   true,
+					StreamOnly: true,
+				},
+			},
+			lines: []string{
+				"|--Vpn Unlimited settings:",
+				"   |--Countries: a, b",
+				"   |--Cities: c, d",
+				"   |--Free servers only",
+				"   |--Stream servers only",
+				"   |--Hostnames: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"vyprvpn": {
+			settings: Provider{
+				Name: constants.Vyprvpn,
+				ServerSelection: ServerSelection{
+					VPN:     constants.OpenVPN,
+					Regions: []string{"a", "b"},
+				},
+			},
+			lines: []string{
+				"|--Vyprvpn settings:",
+				"   |--Regions: a, b",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+			},
+		},
+		"windscribe": {
+			settings: Provider{
+				Name: constants.Windscribe,
+				ServerSelection: ServerSelection{
+					VPN:       constants.OpenVPN,
+					Regions:   []string{"a", "b"},
+					Cities:    []string{"c", "d"},
+					Hostnames: []string{"e", "f"},
+					OpenVPN: OpenVPNSelection{
+						CustomPort: 1,
+					},
+				},
+			},
+			lines: []string{
+				"|--Windscribe settings:",
+				"   |--Regions: a, b",
+				"   |--Cities: c, d",
+				"   |--Hostnames: e, f",
+				"   |--OpenVPN selection:",
+				"      |--Protocol: udp",
+				"      |--Custom port: 1",
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			lines := testCase.settings.lines()
+
+			assert.Equal(t, testCase.lines, lines)
+		})
+	}
+}
+
+func Test_readProtocol(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		mockStr string
+		mockErr error
+		tcp     bool
+		err     error
+	}{
+		"error": {
+			mockErr: errDummy,
+			err:     errors.New("environment variable PROTOCOL: dummy"),
+		},
+		"success": {
+			mockStr: "tcp",
+			tcp:     true,
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctrl := gomock.NewController(t)
+
+			env := mock_params.NewMockInterface(ctrl)
+			env.EXPECT().
+				Inside("PROTOCOL", []string{"tcp", "udp"}, gomock.Any()).
+				Return(testCase.mockStr, testCase.mockErr)
+
+			tcp, err := readProtocol(env)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.tcp, tcp)
+		})
+	}
+}

internal/configuration/publicip.go

@@ -0,0 +1,47 @@
+package configuration
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/qdm12/golibs/params"
+)
+
+type PublicIP struct {
+	Period     time.Duration `json:"period"`
+	IPFilepath string        `json:"ip_filepath"`
+}
+
+func (settings *PublicIP) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *PublicIP) lines() (lines []string) {
+	if settings.Period == 0 {
+		lines = append(lines, lastIndent+"Public IP getter: disabled")
+		return lines
+	}
+
+	lines = append(lines, lastIndent+"Public IP getter:")
+	lines = append(lines, indent+lastIndent+"Fetch period: "+settings.Period.String())
+	lines = append(lines, indent+lastIndent+"IP file: "+settings.IPFilepath)
+
+	return lines
+}
+
+func (settings *PublicIP) read(r reader) (err error) {
+	settings.Period, err = r.env.Duration("PUBLICIP_PERIOD", params.Default("12h"))
+	if err != nil {
+		return fmt.Errorf("environment variable PUBLICIP_PERIOD: %w", err)
+	}
+
+	settings.IPFilepath, err = r.env.Path("PUBLICIP_FILE", params.CaseSensitiveValue(),
+		params.Default("/tmp/gluetun/ip"),
+		params.RetroKeys([]string{"IP_STATUS_FILE"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable PUBLICIP_FILE (or IP_STATUS_FILE): %w", err)
+	}
+
+	return nil
+}

internal/configuration/purevpn.go

@@ -0,0 +1,39 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readPurevpn(r reader) (err error) {
+	settings.Name = constants.Purevpn
+	servers := r.servers.GetPurevpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.PurevpnRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.PurevpnCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.PurevpnCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME", constants.PurevpnHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}

internal/configuration/reader.go

@@ -0,0 +1,126 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+	"github.com/qdm12/golibs/verification"
+)
+
+type reader struct {
+	servers models.AllServers
+	env     params.Interface
+	logger  logging.Logger
+	regex   verification.Regex
+}
+
+func newReader(env params.Interface,
+	servers models.AllServers, logger logging.Logger) reader {
+	return reader{
+		servers: servers,
+		env:     env,
+		logger:  logger,
+		regex:   verification.NewRegex(),
+	}
+}
+
+func (r *reader) onRetroActive(oldKey, newKey string) {
+	r.logger.Warn(
+		"You are using the old environment variable " + oldKey +
+			", please consider changing it to " + newKey)
+}
+
+var (
+	ErrInvalidPort = errors.New("invalid port")
+)
+
+func readCSVPorts(env params.Interface, key string) (ports []uint16, err error) {
+	s, err := env.Get(key)
+	if err != nil {
+		return nil, err
+	} else if s == "" {
+		return nil, nil
+	}
+
+	portsStr := strings.Split(s, ",")
+	ports = make([]uint16, len(portsStr))
+	for i, portStr := range portsStr {
+		portInt, err := strconv.Atoi(portStr)
+		if err != nil {
+			return nil, fmt.Errorf("%w: %s: %s", ErrInvalidPort, portStr, err)
+		} else if portInt <= 0 || portInt > 65535 {
+			return nil, fmt.Errorf("%w: %d: must be between 1 and 65535", ErrInvalidPort, portInt)
+		}
+		ports[i] = uint16(portInt)
+	}
+
+	return ports, nil
+}
+
+var (
+	ErrInvalidIPNet = errors.New("invalid IP network")
+)
+
+func readCSVIPNets(env params.Interface, key string, options ...params.OptionSetter) (
+	ipNets []net.IPNet, err error) {
+	s, err := env.Get(key, options...)
+	if err != nil {
+		return nil, err
+	} else if s == "" {
+		return nil, nil
+	}
+
+	ipNetsStr := strings.Split(s, ",")
+	ipNets = make([]net.IPNet, len(ipNetsStr))
+	for i, ipNetStr := range ipNetsStr {
+		_, ipNet, err := net.ParseCIDR(ipNetStr)
+		if err != nil {
+			return nil, fmt.Errorf("%w: %s: %s",
+				ErrInvalidIPNet, ipNetStr, err)
+		} else if ipNet == nil {
+			return nil, fmt.Errorf("%w: %s: subnet is nil", ErrInvalidIPNet, ipNetStr)
+		}
+		ipNets[i] = *ipNet
+	}
+
+	return ipNets, nil
+}
+
+var (
+	ErrInvalidIP = errors.New("invalid IP address")
+)
+
+func readIP(env params.Interface, key string) (ip net.IP, err error) {
+	s, err := env.Get(key)
+	if s == "" {
+		return nil, nil
+	} else if err != nil {
+		return nil, err
+	}
+
+	ip = net.ParseIP(s)
+	if ip == nil {
+		return nil, fmt.Errorf("%w: %s", ErrInvalidIP, s)
+	}
+
+	return ip, nil
+}
+
+func readPortOrZero(env params.Interface, key string) (port uint16, err error) {
+	s, err := env.Get(key, params.Default("0"))
+	if err != nil {
+		return 0, err
+	}
+
+	if s == "0" {
+		return 0, nil
+	}
+
+	return env.Port(key)
+}

internal/configuration/secrets.go

@@ -0,0 +1,119 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+var (
+	ErrGetSecretFilepath = errors.New("cannot get secret file path from env")
+	ErrReadSecretFile    = errors.New("cannot read secret file")
+	ErrSecretFileIsEmpty = errors.New("secret file is empty")
+	ErrReadNonSecretFile = errors.New("cannot read non secret file")
+	ErrFilesDoNotExist   = errors.New("files do not exist")
+)
+
+func cleanSuffix(value string) string {
+	value = strings.TrimSuffix(value, "\n")
+	value = strings.TrimSuffix(value, "\r")
+	return value
+}
+
+func (r *reader) getFromEnvOrSecretFile(envKey string, compulsory bool, retroKeys []string) (value string, err error) {
+	envOptions := []params.OptionSetter{
+		params.Compulsory(), // to fallback on file reading
+		params.CaseSensitiveValue(),
+		params.Unset(),
+		params.RetroKeys(retroKeys, r.onRetroActive),
+	}
+	value, envErr := r.env.Get(envKey, envOptions...)
+	if envErr == nil {
+		value = cleanSuffix(value)
+		return value, nil
+	}
+
+	secretFilepathEnvKey := envKey + "_SECRETFILE"
+	defaultSecretFile := "/run/secrets/" + strings.ToLower(envKey)
+	filepath, err := r.env.Get(secretFilepathEnvKey,
+		params.CaseSensitiveValue(),
+		params.Default(defaultSecretFile),
+	)
+	if err != nil {
+		return "", fmt.Errorf("%w: environment variable %s: %s",
+			ErrGetSecretFilepath, secretFilepathEnvKey, err)
+	}
+
+	file, fileErr := os.OpenFile(filepath, os.O_RDONLY, 0)
+	if os.IsNotExist(fileErr) {
+		if compulsory {
+			return "", envErr
+		}
+		return "", nil
+	} else if fileErr != nil {
+		return "", fmt.Errorf("%w: %s", ErrReadSecretFile, fileErr)
+	}
+
+	b, err := io.ReadAll(file)
+	if err != nil {
+		return "", fmt.Errorf("%w: %s", ErrReadSecretFile, err)
+	}
+
+	value = string(b)
+	value = cleanSuffix(value)
+	if compulsory && value == "" {
+		return "", ErrSecretFileIsEmpty
+	}
+
+	return value, nil
+}
+
+// Tries to read from the secret file then the non secret file.
+func (r *reader) getFromFileOrSecretFile(secretName, filepath string) (
+	b []byte, err error) {
+	defaultSecretFile := "/run/secrets/" + strings.ToLower(secretName)
+	key := strings.ToUpper(secretName) + "_SECRETFILE"
+	secretFilepath, err := r.env.Get(key,
+		params.CaseSensitiveValue(),
+		params.Default(defaultSecretFile),
+	)
+	if err != nil {
+		return b, fmt.Errorf("environment variable %s: %w: %s", key, ErrGetSecretFilepath, err)
+	}
+
+	b, err = readFromFile(secretFilepath)
+	if err != nil && !os.IsNotExist(err) {
+		return b, fmt.Errorf("%w: %s", ErrReadSecretFile, err)
+	} else if err == nil {
+		return b, nil
+	}
+
+	// Secret file does not exist, try the non secret file
+	b, err = readFromFile(filepath)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, fmt.Errorf("%w: %s", ErrReadSecretFile, err)
+	} else if err == nil {
+		return b, nil
+	}
+	return nil, fmt.Errorf("%w: %s and %s", ErrFilesDoNotExist, secretFilepath, filepath)
+}
+
+func readFromFile(filepath string) (b []byte, err error) {
+	file, err := os.Open(filepath)
+	if err != nil {
+		return nil, err
+	}
+	b, err = io.ReadAll(file)
+	if err != nil {
+		_ = file.Close()
+		return nil, err
+	}
+	if err := file.Close(); err != nil {
+		return nil, err
+	}
+	return b, nil
+}

internal/configuration/selection.go

@@ -0,0 +1,173 @@
+package configuration
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+type ServerSelection struct { //nolint:maligned
+	// Common
+	VPN      string `json:"vpn"` // note: this is required
+	TargetIP net.IP `json:"target_ip,omitempty"`
+	// TODO comments
+	// Cyberghost, PIA, Protonvpn, Surfshark, Windscribe, Vyprvpn, NordVPN
+	Regions []string `json:"regions"`
+
+	// Cyberghost
+	Groups []string `json:"groups"`
+
+	// Fastestvpn, HideMyAss, IPVanish, IVPN, Mullvad, PrivateVPN, Protonvpn, PureVPN, VPNUnlimited
+	Countries []string `json:"countries"`
+	// HideMyAss, IPVanish, IVPN, Mullvad, PrivateVPN, Protonvpn, PureVPN, VPNUnlimited, Windscribe
+	Cities []string `json:"cities"`
+	// Fastestvpn, HideMyAss, IPVanish, IVPN, PrivateVPN, Windscribe, Privado, Protonvpn, VPNUnlimited
+	Hostnames []string `json:"hostnames"`
+	Names     []string `json:"names"` // Protonvpn
+
+	// Mullvad
+	ISPs  []string `json:"isps"`
+	Owned bool     `json:"owned"`
+
+	// NordVPN
+	Numbers []uint16 `json:"numbers"`
+
+	// ProtonVPN
+	FreeOnly bool `json:"free_only"`
+
+	// VPNUnlimited
+	StreamOnly bool `json:"stream_only"`
+
+	// Surfshark
+	MultiHopOnly bool `json:"multihop_only"`
+
+	OpenVPN   OpenVPNSelection   `json:"openvpn"`
+	Wireguard WireguardSelection `json:"wireguard"`
+}
+
+func (selection ServerSelection) toLines() (lines []string) {
+	if selection.TargetIP != nil {
+		lines = append(lines, lastIndent+"Target IP address: "+selection.TargetIP.String())
+	}
+
+	if len(selection.Groups) > 0 {
+		lines = append(lines, lastIndent+"Server groups: "+commaJoin(selection.Groups))
+	}
+
+	if len(selection.Countries) > 0 {
+		lines = append(lines, lastIndent+"Countries: "+commaJoin(selection.Countries))
+	}
+
+	if len(selection.Regions) > 0 {
+		lines = append(lines, lastIndent+"Regions: "+commaJoin(selection.Regions))
+	}
+
+	if len(selection.Cities) > 0 {
+		lines = append(lines, lastIndent+"Cities: "+commaJoin(selection.Cities))
+	}
+
+	if len(selection.ISPs) > 0 {
+		lines = append(lines, lastIndent+"ISPs: "+commaJoin(selection.ISPs))
+	}
+
+	if selection.FreeOnly {
+		lines = append(lines, lastIndent+"Free servers only")
+	}
+
+	if selection.StreamOnly {
+		lines = append(lines, lastIndent+"Stream servers only")
+	}
+
+	if len(selection.Hostnames) > 0 {
+		lines = append(lines, lastIndent+"Hostnames: "+commaJoin(selection.Hostnames))
+	}
+
+	if len(selection.Names) > 0 {
+		lines = append(lines, lastIndent+"Names: "+commaJoin(selection.Names))
+	}
+
+	if len(selection.Numbers) > 0 {
+		numbersString := make([]string, len(selection.Numbers))
+		for i, numberUint16 := range selection.Numbers {
+			numbersString[i] = fmt.Sprint(numberUint16)
+		}
+		lines = append(lines, lastIndent+"Numbers: "+commaJoin(numbersString))
+	}
+
+	if selection.VPN == constants.OpenVPN {
+		lines = append(lines, selection.OpenVPN.lines()...)
+	} else { // wireguard
+		lines = append(lines, selection.Wireguard.lines()...)
+	}
+
+	return lines
+}
+
+type OpenVPNSelection struct {
+	TCP        bool   `json:"tcp"`               // UDP if TCP is false
+	CustomPort uint16 `json:"custom_port"`       // HideMyAss, Mullvad, PIA, ProtonVPN, Windscribe
+	EncPreset  string `json:"encryption_preset"` // PIA - needed to get the port number
+}
+
+func (settings *OpenVPNSelection) lines() (lines []string) {
+	lines = append(lines, lastIndent+"OpenVPN selection:")
+
+	lines = append(lines, indent+lastIndent+"Protocol: "+protoToString(settings.TCP))
+
+	if settings.CustomPort != 0 {
+		lines = append(lines, indent+lastIndent+"Custom port: "+fmt.Sprint(settings.CustomPort))
+	}
+
+	if settings.EncPreset != "" {
+		lines = append(lines, indent+lastIndent+"PIA encryption preset: "+settings.EncPreset)
+	}
+
+	return lines
+}
+
+func (settings *OpenVPNSelection) readProtocolOnly(env params.Interface) (err error) {
+	settings.TCP, err = readProtocol(env)
+	return err
+}
+
+func (settings *OpenVPNSelection) readProtocolAndPort(env params.Interface) (err error) {
+	settings.TCP, err = readProtocol(env)
+	if err != nil {
+		return err
+	}
+
+	settings.CustomPort, err = readPortOrZero(env, "PORT")
+	if err != nil {
+		return fmt.Errorf("environment variable PORT: %w", err)
+	}
+
+	return nil
+}
+
+type WireguardSelection struct {
+	CustomPort uint16 `json:"custom_port"` // Mullvad
+}
+
+func (settings *WireguardSelection) lines() (lines []string) {
+	lines = append(lines, lastIndent+"Wireguard selection:")
+
+	if settings.CustomPort != 0 {
+		lines = append(lines, indent+lastIndent+"Custom port: "+fmt.Sprint(settings.CustomPort))
+	}
+
+	return lines
+}
+
+// PortForwarding contains settings for port forwarding.
+type PortForwarding struct {
+	Enabled  bool   `json:"enabled"`
+	Filepath string `json:"filepath"`
+}
+
+func (p *PortForwarding) lines() (lines []string) {
+	return []string{
+		lastIndent + "File path: " + p.Filepath,
+	}
+}

internal/configuration/server.go

@@ -0,0 +1,50 @@
+package configuration
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+// ControlServer contains settings to customize the control server operation.
+type ControlServer struct {
+	Port uint16
+	Log  bool
+}
+
+func (settings *ControlServer) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *ControlServer) lines() (lines []string) {
+	lines = append(lines, lastIndent+"HTTP control server:")
+
+	lines = append(lines, indent+lastIndent+"Listening port: "+strconv.Itoa(int(settings.Port)))
+
+	if settings.Log {
+		lines = append(lines, indent+lastIndent+"Logging: enabled")
+	}
+
+	return lines
+}
+
+func (settings *ControlServer) read(r reader) (err error) {
+	settings.Log, err = r.env.OnOff("HTTP_CONTROL_SERVER_LOG", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_LOG: %w", err)
+	}
+
+	var warning string
+	settings.Port, warning, err = r.env.ListeningPort(
+		"HTTP_CONTROL_SERVER_PORT", params.Default("8000"))
+	if len(warning) > 0 {
+		r.logger.Warn(warning)
+	}
+	if err != nil {
+		return fmt.Errorf("environment variable HTTP_CONTROL_SERVER_PORT: %w", err)
+	}
+
+	return nil
+}

internal/configuration/settings.go

@@ -0,0 +1,126 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/logging"
+	"github.com/qdm12/golibs/params"
+)
+
+// Settings contains all settings for the program to run.
+type Settings struct {
+	VPN                VPN
+	System             System
+	DNS                DNS
+	Firewall           Firewall
+	HTTPProxy          HTTPProxy
+	ShadowSocks        ShadowSocks
+	Updater            Updater
+	PublicIP           PublicIP
+	VersionInformation bool
+	ControlServer      ControlServer
+	Health             Health
+	Log                Log
+}
+
+func (settings *Settings) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *Settings) lines() (lines []string) {
+	lines = append(lines, "Settings summary below:")
+	lines = append(lines, settings.VPN.lines()...)
+	lines = append(lines, settings.DNS.lines()...)
+	lines = append(lines, settings.Firewall.lines()...)
+	lines = append(lines, settings.Log.lines()...)
+	lines = append(lines, settings.System.lines()...)
+	lines = append(lines, settings.HTTPProxy.lines()...)
+	lines = append(lines, settings.ShadowSocks.lines()...)
+	lines = append(lines, settings.Health.lines()...)
+	lines = append(lines, settings.ControlServer.lines()...)
+	lines = append(lines, settings.Updater.lines()...)
+	lines = append(lines, settings.PublicIP.lines()...)
+	if settings.VersionInformation {
+		lines = append(lines, lastIndent+"Github version information: enabled")
+	}
+	return lines
+}
+
+var (
+	ErrVPN           = errors.New("cannot read VPN settings")
+	ErrSystem        = errors.New("cannot read System settings")
+	ErrDNS           = errors.New("cannot read DNS settings")
+	ErrFirewall      = errors.New("cannot read firewall settings")
+	ErrHTTPProxy     = errors.New("cannot read HTTP proxy settings")
+	ErrShadowsocks   = errors.New("cannot read Shadowsocks settings")
+	ErrControlServer = errors.New("cannot read control server settings")
+	ErrUpdater       = errors.New("cannot read Updater settings")
+	ErrPublicIP      = errors.New("cannot read Public IP getter settings")
+	ErrHealth        = errors.New("cannot read health settings")
+	ErrLog           = errors.New("cannot read log settings")
+)
+
+// Read obtains all configuration options for the program and returns an error as soon
+// as an error is encountered reading them.
+func (settings *Settings) Read(env params.Interface, servers models.AllServers,
+	logger logging.Logger) (err error) {
+	r := newReader(env, servers, logger)
+
+	settings.VersionInformation, err = r.env.OnOff("VERSION_INFORMATION", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable VERSION_INFORMATION: %w", err)
+	}
+
+	if err := settings.VPN.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrVPN, err)
+	}
+
+	if err := settings.System.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrSystem, err)
+	}
+
+	if err := settings.DNS.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrDNS, err)
+	}
+
+	if err := settings.Firewall.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrFirewall, err)
+	}
+
+	if err := settings.HTTPProxy.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrHTTPProxy, err)
+	}
+
+	if err := settings.ShadowSocks.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrShadowsocks, err)
+	}
+
+	if err := settings.ControlServer.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrControlServer, err)
+	}
+
+	if err := settings.Updater.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrUpdater, err)
+	}
+
+	if ip := settings.DNS.PlaintextAddress; ip != nil {
+		settings.Updater.DNSAddress = ip.String()
+	}
+
+	if err := settings.PublicIP.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrPublicIP, err)
+	}
+
+	if err := settings.Health.read(r); err != nil {
+		return fmt.Errorf("%w: %s", ErrHealth, err)
+	}
+
+	if err := settings.Log.read(r.env); err != nil {
+		return fmt.Errorf("%w: %s", ErrLog, err)
+	}
+
+	return nil
+}

internal/configuration/settings_test.go

@@ -0,0 +1,73 @@
+package configuration
+
+import (
+	"testing"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_Settings_lines(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		settings Settings
+		lines    []string
+	}{
+		"default settings": {
+			settings: Settings{
+				VPN: VPN{
+					Type: constants.OpenVPN,
+					Provider: Provider{
+						Name: constants.Mullvad,
+						ServerSelection: ServerSelection{
+							VPN: constants.OpenVPN,
+						},
+					},
+					OpenVPN: OpenVPN{
+						Version:   constants.Openvpn25,
+						Interface: "tun",
+					},
+				},
+			},
+			lines: []string{
+				"Settings summary below:",
+				"|--VPN:",
+				"   |--Type: openvpn",
+				"   |--OpenVPN:",
+				"      |--Version: 2.5",
+				"      |--Verbosity level: 0",
+				"      |--Network interface: tun",
+				"   |--Mullvad settings:",
+				"      |--OpenVPN selection:",
+				"         |--Protocol: udp",
+				"|--DNS:",
+				"|--Firewall: disabled ⚠️",
+				"|--Log:",
+				"   |--Level: DEBUG",
+				"|--System:",
+				"   |--Process user ID: 0",
+				"   |--Process group ID: 0",
+				"   |--Timezone: NOT SET ⚠️ - it can cause time related issues",
+				"|--Health:",
+				"   |--Server address: ",
+				"   |--OpenVPN:",
+				"      |--Initial duration: 0s",
+				"|--HTTP control server:",
+				"   |--Listening port: 0",
+				"|--Public IP getter: disabled",
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			lines := testCase.settings.lines()
+
+			assert.Equal(t, testCase.lines, lines)
+		})
+	}
+}

internal/configuration/shadowsocks.go

@@ -0,0 +1,109 @@
+package configuration
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+	"github.com/qdm12/ss-server/pkg/tcpudp"
+)
+
+// ShadowSocks contains settings to configure the Shadowsocks server.
+type ShadowSocks struct {
+	Enabled bool
+	tcpudp.Settings
+}
+
+func (settings *ShadowSocks) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *ShadowSocks) lines() (lines []string) {
+	if !settings.Enabled {
+		return nil
+	}
+
+	lines = append(lines, lastIndent+"Shadowsocks server:")
+
+	lines = append(lines, indent+lastIndent+"Listening address: "+settings.Address)
+
+	lines = append(lines, indent+lastIndent+"Cipher: "+settings.CipherName)
+
+	if settings.LogAddresses {
+		lines = append(lines, indent+lastIndent+"Log addresses: enabled")
+	}
+
+	return lines
+}
+
+func (settings *ShadowSocks) read(r reader) (err error) {
+	settings.Enabled, err = r.env.OnOff("SHADOWSOCKS", params.Default("off"))
+	if !settings.Enabled {
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("environment variable SHADOWSOCKS: %w", err)
+	}
+
+	settings.Password, err = r.getFromEnvOrSecretFile("SHADOWSOCKS_PASSWORD", settings.Enabled, nil)
+	if err != nil {
+		return err
+	}
+
+	settings.LogAddresses, err = r.env.OnOff("SHADOWSOCKS_LOG", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable SHADOWSOCKS_LOG: %w", err)
+	}
+
+	settings.CipherName, err = r.env.Get("SHADOWSOCKS_CIPHER", params.Default("chacha20-ietf-poly1305"),
+		params.RetroKeys([]string{"SHADOWSOCKS_METHOD"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable SHADOWSOCKS_CIPHER (or SHADOWSOCKS_METHOD): %w", err)
+	}
+
+	warning, err := settings.getAddress(r.env)
+	if warning != "" {
+		r.logger.Warn(warning)
+	}
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (settings *ShadowSocks) getAddress(env params.Interface) (
+	warning string, err error) {
+	address, err := env.Get("SHADOWSOCKS_LISTENING_ADDRESS")
+	if err != nil {
+		return "", fmt.Errorf("environment variable SHADOWSOCKS_LISTENING_ADDRESS: %w", err)
+	}
+
+	if address != "" {
+		address, warning, err := env.ListeningAddress("SHADOWSOCKS_LISTENING_ADDRESS")
+		if err != nil {
+			return "", fmt.Errorf("environment variable SHADOWSOCKS_LISTENING_ADDRESS: %w", err)
+		}
+		settings.Address = address
+		return warning, nil
+	}
+
+	// Retro-compatibility
+	const retroWarning = "You are using the old environment variable " +
+		"SHADOWSOCKS_PORT, please consider using " +
+		"SHADOWSOCKS_LISTENING_ADDRESS instead"
+	portStr, err := env.Get("SHADOWSOCKS_PORT")
+	if err != nil {
+		return retroWarning, fmt.Errorf("environment variable SHADOWSOCKS_PORT: %w", err)
+	} else if portStr != "" {
+		port, _, err := env.ListeningPort("SHADOWSOCKS_PORT")
+		if err != nil {
+			return retroWarning, fmt.Errorf("environment variable SHADOWSOCKS_PORT: %w", err)
+		}
+		settings.Address = ":" + fmt.Sprint(port)
+		return retroWarning, nil
+	}
+
+	// Default value
+	settings.Address = ":8388"
+	return "", nil
+}

internal/configuration/surfshark.go

@@ -0,0 +1,102 @@
+package configuration
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readSurfshark(r reader) (err error) {
+	settings.Name = constants.Surfshark
+	servers := r.servers.GetSurfshark()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.SurfsharkCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.SurfsharkCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.SurfsharkHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	regionChoices := constants.SurfsharkRegionChoices(servers)
+	regionChoices = append(regionChoices, constants.SurfsharkRetroLocChoices(servers)...)
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", regionChoices)
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	// Retro compatibility
+	// TODO remove in v4
+	settings.ServerSelection = surfsharkRetroRegion(settings.ServerSelection)
+
+	settings.ServerSelection.MultiHopOnly, err = r.env.YesNo("MULTIHOP_ONLY", params.Default("no"))
+	if err != nil {
+		return fmt.Errorf("environment variable MULTIHOP_ONLY: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}
+
+func surfsharkRetroRegion(selection ServerSelection) (
+	updatedSelection ServerSelection) {
+	locationData := constants.SurfsharkLocationData()
+
+	retroToLocation := make(map[string]models.SurfsharkLocationData, len(locationData))
+	for _, data := range locationData {
+		if data.RetroLoc == "" {
+			continue
+		}
+		retroToLocation[strings.ToLower(data.RetroLoc)] = data
+	}
+
+	for i, region := range selection.Regions {
+		location, ok := retroToLocation[region]
+		if !ok {
+			continue
+		}
+		selection.Regions[i] = strings.ToLower(location.Region)
+		selection.Countries = append(selection.Countries, strings.ToLower(location.Country))
+		selection.Cities = append(selection.Cities, strings.ToLower(location.City)) // even empty string
+		selection.Hostnames = append(selection.Hostnames, location.Hostname)
+	}
+
+	selection.Regions = dedupSlice(selection.Regions)
+	selection.Countries = dedupSlice(selection.Countries)
+	selection.Cities = dedupSlice(selection.Cities)
+	selection.Hostnames = dedupSlice(selection.Hostnames)
+
+	return selection
+}
+
+func dedupSlice(slice []string) (deduped []string) {
+	if slice == nil {
+		return nil
+	}
+
+	deduped = make([]string, 0, len(slice))
+	seen := make(map[string]struct{}, len(slice))
+	for _, s := range slice {
+		if _, ok := seen[s]; !ok {
+			seen[s] = struct{}{}
+			deduped = append(deduped, s)
+		}
+	}
+
+	return deduped
+}

internal/configuration/surfshark_test.go

@@ -0,0 +1,305 @@
+package configuration
+
+import (
+	"errors"
+	"net"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/gluetun/internal/models"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_Provider_readSurfshark(t *testing.T) {
+	t.Parallel()
+
+	var errDummy = errors.New("dummy test error")
+
+	type stringCall struct {
+		call  bool
+		value string
+		err   error
+	}
+
+	type boolCall struct {
+		call  bool
+		value bool
+		err   error
+	}
+
+	type sliceStringCall struct {
+		call   bool
+		values []string
+		err    error
+	}
+
+	testCases := map[string]struct {
+		targetIP  stringCall
+		countries sliceStringCall
+		cities    sliceStringCall
+		hostnames sliceStringCall
+		regions   sliceStringCall
+		multiHop  boolCall
+		protocol  stringCall
+		settings  Provider
+		err       error
+	}{
+		"target IP error": {
+			targetIP: stringCall{call: true, value: "something", err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable OPENVPN_TARGET_IP: dummy test error"),
+		},
+		"countries error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable COUNTRY: dummy test error"),
+		},
+		"cities error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable CITY: dummy test error"),
+		},
+		"hostnames error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable SERVER_HOSTNAME: dummy test error"),
+		},
+		"regions error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			regions:   sliceStringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable REGION: dummy test error"),
+		},
+		"multi hop error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			regions:   sliceStringCall{call: true},
+			multiHop:  boolCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable MULTIHOP_ONLY: dummy test error"),
+		},
+		"openvpn protocol error": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			regions:   sliceStringCall{call: true},
+			multiHop:  boolCall{call: true},
+			protocol:  stringCall{call: true, err: errDummy},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+			err: errors.New("environment variable PROTOCOL: dummy test error"),
+		},
+		"default settings": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			regions:   sliceStringCall{call: true},
+			multiHop:  boolCall{call: true},
+			protocol:  stringCall{call: true},
+			settings: Provider{
+				Name: constants.Surfshark,
+			},
+		},
+		"set settings": {
+			targetIP:  stringCall{call: true, value: "1.2.3.4"},
+			countries: sliceStringCall{call: true, values: []string{"A", "B"}},
+			cities:    sliceStringCall{call: true, values: []string{"C", "D"}},
+			regions: sliceStringCall{call: true, values: []string{
+				"E", "F", "netherlands amsterdam",
+			}}, // Netherlands Amsterdam is for retro compatibility test
+			multiHop:  boolCall{call: true},
+			hostnames: sliceStringCall{call: true, values: []string{"E", "F"}},
+			protocol:  stringCall{call: true, value: constants.TCP},
+			settings: Provider{
+				Name: constants.Surfshark,
+				ServerSelection: ServerSelection{
+					OpenVPN: OpenVPNSelection{
+						TCP: true,
+					},
+					TargetIP:  net.IPv4(1, 2, 3, 4),
+					Regions:   []string{"E", "F", "europe"},
+					Countries: []string{"A", "B", "netherlands"},
+					Cities:    []string{"C", "D", "amsterdam"},
+					Hostnames: []string{"E", "F", "nl-ams.prod.surfshark.com"},
+				},
+			},
+		},
+		"Netherlands Amsterdam": {
+			targetIP:  stringCall{call: true},
+			countries: sliceStringCall{call: true},
+			cities:    sliceStringCall{call: true},
+			regions:   sliceStringCall{call: true, values: []string{"netherlands amsterdam"}},
+			multiHop:  boolCall{call: true},
+			hostnames: sliceStringCall{call: true},
+			protocol:  stringCall{call: true},
+			settings: Provider{
+				Name: constants.Surfshark,
+				ServerSelection: ServerSelection{
+					Regions:   []string{"europe"},
+					Countries: []string{"netherlands"},
+					Cities:    []string{"amsterdam"},
+					Hostnames: []string{"nl-ams.prod.surfshark.com"},
+				},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctrl := gomock.NewController(t)
+
+			env := mock_params.NewMockInterface(ctrl)
+
+			servers := []models.SurfsharkServer{{Hostname: "a"}}
+			allServers := models.AllServers{
+				Surfshark: models.SurfsharkServers{
+					Servers: servers,
+				},
+			}
+
+			if testCase.targetIP.call {
+				env.EXPECT().Get("OPENVPN_TARGET_IP").
+					Return(testCase.targetIP.value, testCase.targetIP.err)
+			}
+			if testCase.countries.call {
+				env.EXPECT().CSVInside("COUNTRY", constants.SurfsharkCountryChoices(servers)).
+					Return(testCase.countries.values, testCase.countries.err)
+			}
+			if testCase.cities.call {
+				env.EXPECT().CSVInside("CITY", constants.SurfsharkCityChoices(servers)).
+					Return(testCase.cities.values, testCase.cities.err)
+			}
+			if testCase.hostnames.call {
+				env.EXPECT().CSVInside("SERVER_HOSTNAME", constants.SurfsharkHostnameChoices(servers)).
+					Return(testCase.hostnames.values, testCase.hostnames.err)
+			}
+			if testCase.regions.call {
+				regionChoices := constants.SurfsharkRegionChoices(servers)
+				regionChoices = append(regionChoices, constants.SurfsharkRetroLocChoices(servers)...)
+				env.EXPECT().CSVInside("REGION", regionChoices).
+					Return(testCase.regions.values, testCase.regions.err)
+			}
+			if testCase.multiHop.call {
+				env.EXPECT().YesNo("MULTIHOP_ONLY", gomock.Any()).
+					Return(testCase.multiHop.value, testCase.multiHop.err)
+			}
+			if testCase.protocol.call {
+				env.EXPECT().Inside("PROTOCOL", []string{constants.TCP, constants.UDP}, gomock.Any()).
+					Return(testCase.protocol.value, testCase.protocol.err)
+			}
+
+			r := reader{
+				servers: allServers,
+				env:     env,
+			}
+
+			var settings Provider
+			err := settings.readSurfshark(r)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.settings, settings)
+		})
+	}
+}
+
+func Test_surfsharkRetroRegion(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		original ServerSelection
+		modified ServerSelection
+	}{
+		"empty": {},
+		"1 retro region": {
+			original: ServerSelection{
+				Regions: []string{"australia adelaide"},
+			},
+			modified: ServerSelection{
+				Regions:   []string{"asia pacific"},
+				Countries: []string{"australia"},
+				Cities:    []string{"adelaide"},
+				Hostnames: []string{"au-adl.prod.surfshark.com"},
+			},
+		},
+		"2 overlapping retro regions": {
+			original: ServerSelection{
+				Regions: []string{"australia adelaide", "australia melbourne"},
+			},
+			modified: ServerSelection{
+				Regions:   []string{"asia pacific"},
+				Countries: []string{"australia"},
+				Cities:    []string{"adelaide", "melbourne"},
+				Hostnames: []string{"au-adl.prod.surfshark.com", "au-mel.prod.surfshark.com"},
+			},
+		},
+		"2 distinct retro regions": {
+			original: ServerSelection{
+				Regions: []string{"australia adelaide", "netherlands amsterdam"},
+			},
+			modified: ServerSelection{
+				Regions:   []string{"asia pacific", "europe"},
+				Countries: []string{"australia", "netherlands"},
+				Cities:    []string{"adelaide", "amsterdam"},
+				Hostnames: []string{"au-adl.prod.surfshark.com", "nl-ams.prod.surfshark.com"},
+			},
+		},
+		"retro region with existing region": {
+			// note TestRegion will be ignored in the filters downstream
+			original: ServerSelection{
+				Regions: []string{"TestRegion", "australia adelaide"},
+			},
+			modified: ServerSelection{
+				Regions:   []string{"TestRegion", "asia pacific"},
+				Countries: []string{"australia"},
+				Cities:    []string{"adelaide"},
+				Hostnames: []string{"au-adl.prod.surfshark.com"},
+			},
+		},
+	}
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			selection := surfsharkRetroRegion(testCase.original)
+
+			assert.Equal(t, testCase.modified, selection)
+		})
+	}
+}

internal/configuration/system.go

@@ -0,0 +1,55 @@
+package configuration
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+// System contains settings to configure system related elements.
+type System struct {
+	PUID     int
+	PGID     int
+	Timezone string
+}
+
+func (settings *System) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *System) lines() (lines []string) {
+	lines = append(lines, lastIndent+"System:")
+	lines = append(lines, indent+lastIndent+"Process user ID: "+strconv.Itoa(settings.PUID))
+	lines = append(lines, indent+lastIndent+"Process group ID: "+strconv.Itoa(settings.PGID))
+
+	if len(settings.Timezone) > 0 {
+		lines = append(lines, indent+lastIndent+"Timezone: "+settings.Timezone)
+	} else {
+		lines = append(lines, indent+lastIndent+"Timezone: NOT SET ⚠️ - it can cause time related issues")
+	}
+	return lines
+}
+
+func (settings *System) read(r reader) (err error) {
+	const maxID = 65535
+	settings.PUID, err = r.env.IntRange("PUID", 0, maxID, params.Default("1000"),
+		params.RetroKeys([]string{"UID"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable PUID (or UID): %w", err)
+	}
+
+	settings.PGID, err = r.env.IntRange("PGID", 0, maxID, params.Default("1000"),
+		params.RetroKeys([]string{"GID"}, r.onRetroActive))
+	if err != nil {
+		return fmt.Errorf("environment variable PGID (or GID): %w", err)
+	}
+
+	settings.Timezone, err = r.env.Get("TZ")
+	if err != nil {
+		return fmt.Errorf("environment variable TZ: %w", err)
+	}
+
+	return nil
+}

internal/configuration/torguard.go

@@ -0,0 +1,35 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readTorguard(r reader) (err error) {
+	settings.Name = constants.Torguard
+	servers := r.servers.GetTorguard()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.TorguardCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.TorguardCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.TorguardHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolAndPort(r.env)
+}

internal/configuration/unbound.go

@@ -0,0 +1,79 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/dns/pkg/provider"
+	"github.com/qdm12/golibs/params"
+	"inet.af/netaddr"
+)
+
+func (settings *DNS) readUnbound(r reader) (err error) {
+	if err := settings.readUnboundProviders(r.env); err != nil {
+		return err
+	}
+
+	settings.Unbound.ListeningPort = 53
+
+	settings.Unbound.Caching, err = r.env.OnOff("DOT_CACHING", params.Default("on"))
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_CACHING: %w", err)
+	}
+
+	settings.Unbound.IPv4 = true
+
+	settings.Unbound.IPv6, err = r.env.OnOff("DOT_IPV6", params.Default("off"))
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_IPV6: %w", err)
+	}
+
+	verbosityLevel, err := r.env.IntRange("DOT_VERBOSITY", 0, 5, params.Default("1")) //nolint:gomnd
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_VERBOSITY: %w", err)
+	}
+	settings.Unbound.VerbosityLevel = uint8(verbosityLevel)
+
+	verbosityDetailsLevel, err := r.env.IntRange("DOT_VERBOSITY_DETAILS", 0, 4, params.Default("0")) //nolint:gomnd
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_VERBOSITY_DETAILS: %w", err)
+	}
+	settings.Unbound.VerbosityDetailsLevel = uint8(verbosityDetailsLevel)
+
+	validationLogLevel, err := r.env.IntRange("DOT_VALIDATION_LOGLEVEL", 0, 2, params.Default("0")) //nolint:gomnd
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_VALIDATION_LOGLEVEL: %w", err)
+	}
+	settings.Unbound.ValidationLogLevel = uint8(validationLogLevel)
+
+	settings.Unbound.AccessControl.Allowed = []netaddr.IPPrefix{
+		netaddr.IPPrefixFrom(netaddr.IPv4(0, 0, 0, 0), 0),
+		netaddr.IPPrefixFrom(netaddr.IPv6Raw([16]byte{}), 0),
+	}
+
+	return nil
+}
+
+var (
+	ErrInvalidDNSOverTLSProvider = errors.New("invalid DNS over TLS provider")
+)
+
+func (settings *DNS) readUnboundProviders(env params.Interface) (err error) {
+	s, err := env.Get("DOT_PROVIDERS", params.Default("cloudflare"))
+	if err != nil {
+		return fmt.Errorf("environment variable DOT_PROVIDERS: %w", err)
+	}
+	for _, field := range strings.Split(s, ",") {
+		dnsProvider, err := provider.Parse(field)
+		if err != nil {
+			return fmt.Errorf("%w: %s", ErrInvalidDNSOverTLSProvider, err)
+		}
+		settings.Unbound.Providers = append(settings.Unbound.Providers, dnsProvider)
+	}
+	return nil
+}
+
+var (
+	ErrInvalidHostname = errors.New("invalid hostname")
+)

internal/configuration/unbound_test.go

@@ -0,0 +1,80 @@
+package configuration
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/dns/pkg/provider"
+	"github.com/qdm12/dns/pkg/unbound"
+	"github.com/qdm12/golibs/params/mock_params"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_DNS_readUnboundProviders(t *testing.T) {
+	t.Parallel()
+
+	testCases := map[string]struct {
+		envValue string
+		envErr   error
+		expected DNS
+		err      error
+	}{
+		"bad value": {
+			envValue: "invalid",
+			err:      errors.New(`invalid DNS over TLS provider: cannot parse provider: "invalid"`),
+		},
+		"env error": {
+			envErr: errors.New("env error"),
+			err:    errors.New("environment variable DOT_PROVIDERS: env error"),
+		},
+		"multiple valid values": {
+			envValue: "cloudflare,google",
+			expected: DNS{
+				Unbound: unbound.Settings{
+					Providers: []provider.Provider{
+						provider.Cloudflare(),
+						provider.Google(),
+					},
+				},
+			},
+		},
+		"one invalid value in two": {
+			envValue: "cloudflare,invalid",
+			expected: DNS{
+				Unbound: unbound.Settings{
+					Providers: []provider.Provider{
+						provider.Cloudflare(),
+					},
+				},
+			},
+			err: errors.New(`invalid DNS over TLS provider: cannot parse provider: "invalid"`),
+		},
+	}
+
+	for name, testCase := range testCases {
+		testCase := testCase
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			ctrl := gomock.NewController(t)
+
+			env := mock_params.NewMockInterface(ctrl)
+			env.EXPECT().Get("DOT_PROVIDERS", gomock.Any()).
+				Return(testCase.envValue, testCase.envErr)
+
+			var settings DNS
+			err := settings.readUnboundProviders(env)
+
+			if testCase.err != nil {
+				require.Error(t, err)
+				assert.Equal(t, testCase.err.Error(), err.Error())
+			} else {
+				assert.NoError(t, err)
+			}
+
+			assert.Equal(t, testCase.expected, settings)
+		})
+	}
+}

internal/configuration/updater.go

@@ -0,0 +1,85 @@
+package configuration
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/qdm12/golibs/params"
+)
+
+type Updater struct {
+	Period       time.Duration `json:"period"`
+	DNSAddress   string        `json:"dns_address"`
+	Cyberghost   bool          `json:"cyberghost"`
+	Fastestvpn   bool          `json:"fastestvpn"`
+	HideMyAss    bool          `json:"hidemyass"`
+	Ipvanish     bool          `json:"ipvanish"`
+	Ivpn         bool          `json:"ivpn"`
+	Mullvad      bool          `json:"mullvad"`
+	Nordvpn      bool          `json:"nordvpn"`
+	PIA          bool          `json:"pia"`
+	Privado      bool          `json:"privado"`
+	Privatevpn   bool          `json:"privatevpn"`
+	Protonvpn    bool          `json:"protonvpn"`
+	Purevpn      bool          `json:"purevpn"`
+	Surfshark    bool          `json:"surfshark"`
+	Torguard     bool          `json:"torguard"`
+	VPNUnlimited bool          `json:"vpnunlimited"`
+	Vyprvpn      bool          `json:"vyprvpn"`
+	Windscribe   bool          `json:"windscribe"`
+	// The two below should be used in CLI mode only
+	CLI bool `json:"-"`
+}
+
+func (settings *Updater) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *Updater) lines() (lines []string) {
+	if settings.Period == 0 {
+		return nil
+	}
+
+	lines = append(lines, lastIndent+"Updater:")
+
+	lines = append(lines, indent+lastIndent+"Period: every "+settings.Period.String())
+
+	return lines
+}
+
+func (settings *Updater) EnableAll() {
+	settings.Cyberghost = true
+	settings.HideMyAss = true
+	settings.Ipvanish = true
+	settings.Ivpn = true
+	settings.Mullvad = true
+	settings.Nordvpn = true
+	settings.Privado = true
+	settings.PIA = true
+	settings.Privado = true
+	settings.Privatevpn = true
+	settings.Protonvpn = true
+	settings.Purevpn = true
+	settings.Surfshark = true
+	settings.Torguard = true
+	settings.VPNUnlimited = true
+	settings.Vyprvpn = true
+	settings.Windscribe = true
+}
+
+func (settings *Updater) read(r reader) (err error) {
+	settings.EnableAll()
+	// use cloudflare in plaintext to not be blocked by DNS over TLS by default.
+	// If a plaintext address is set in the DNS settings, this one will be used.
+	// TODO use custom future encrypted DNS written in Go without blocking
+	// as it's too much trouble to start another parallel unbound instance for now.
+	settings.DNSAddress = "1.1.1.1"
+
+	settings.Period, err = r.env.Duration("UPDATER_PERIOD", params.Default("0"))
+	if err != nil {
+		return fmt.Errorf("environment variable UPDATER_PERIOD: %w", err)
+	}
+
+	return nil
+}

internal/configuration/vpn.go

@@ -0,0 +1,97 @@
+package configuration
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+type VPN struct {
+	Type      string    `json:"type"`
+	OpenVPN   OpenVPN   `json:"openvpn"`
+	Wireguard Wireguard `json:"wireguard"`
+	Provider  Provider  `json:"provider"`
+}
+
+func (settings *VPN) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *VPN) lines() (lines []string) {
+	lines = append(lines, lastIndent+"VPN:")
+
+	lines = append(lines, indent+lastIndent+"Type: "+settings.Type)
+
+	var vpnLines []string
+	switch settings.Type {
+	case constants.OpenVPN:
+		vpnLines = settings.OpenVPN.lines()
+	case constants.Wireguard:
+		vpnLines = settings.Wireguard.lines()
+	}
+	for _, line := range vpnLines {
+		lines = append(lines, indent+line)
+	}
+
+	for _, line := range settings.Provider.lines() {
+		lines = append(lines, indent+line)
+	}
+
+	return lines
+}
+
+var (
+	errReadProviderSettings  = errors.New("cannot read provider settings")
+	errReadOpenVPNSettings   = errors.New("cannot read OpenVPN settings")
+	errReadWireguardSettings = errors.New("cannot read Wireguard settings")
+)
+
+func (settings *VPN) read(r reader) (err error) {
+	vpnType, err := r.env.Inside("VPN_TYPE",
+		[]string{constants.OpenVPN, constants.Wireguard},
+		params.Default(constants.OpenVPN))
+	if err != nil {
+		return fmt.Errorf("environment variable VPN_TYPE: %w", err)
+	}
+	settings.Type = vpnType
+
+	if !settings.isOpenVPNCustomConfig(r.env) {
+		if err := settings.Provider.read(r, vpnType); err != nil {
+			return fmt.Errorf("%w: %s", errReadProviderSettings, err)
+		}
+	}
+
+	switch settings.Type {
+	case constants.OpenVPN:
+		err = settings.OpenVPN.read(r, settings.Provider.Name)
+		if err != nil {
+			return fmt.Errorf("%w: %s", errReadOpenVPNSettings, err)
+		}
+	case constants.Wireguard:
+		err = settings.Wireguard.read(r)
+		if err != nil {
+			return fmt.Errorf("%w: %s", errReadWireguardSettings, err)
+		}
+	}
+
+	return nil
+}
+
+func (settings VPN) isOpenVPNCustomConfig(env params.Interface) (ok bool) {
+	if settings.Type != constants.OpenVPN {
+		return false
+	}
+	s, err := env.Get("OPENVPN_CUSTOM_CONFIG")
+	return err == nil && s != ""
+}
+
+func (settings VPN) VPNInterface() (intf string) {
+	if settings.Type == constants.Wireguard {
+		return settings.Wireguard.Interface
+	}
+	// OpenVPN
+	return settings.OpenVPN.Interface
+}

internal/configuration/vpnunlimited.go

@@ -0,0 +1,60 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readVPNUnlimited(r reader) (err error) {
+	settings.Name = constants.VPNUnlimited
+	servers := r.servers.GetVPNUnlimited()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Countries, err = r.env.CSVInside("COUNTRY", constants.VPNUnlimitedCountryChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable COUNTRY: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.VPNUnlimitedCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.VPNUnlimitedHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	settings.ServerSelection.FreeOnly, err = r.env.YesNo("FREE_ONLY", params.Default("no"))
+	if err != nil {
+		return fmt.Errorf("environment variable FREE_ONLY: %w", err)
+	}
+
+	settings.ServerSelection.StreamOnly, err = r.env.YesNo("STREAM_ONLY", params.Default("no"))
+	if err != nil {
+		return fmt.Errorf("environment variable STREAM_ONLY: %w", err)
+	}
+
+	return settings.ServerSelection.OpenVPN.readProtocolOnly(r.env)
+}
+
+func (settings *OpenVPN) readVPNUnlimited(r reader) (err error) {
+	settings.ClientKey, err = readClientKey(r)
+	if err != nil {
+		return err
+	}
+
+	settings.ClientCrt, err = readClientCertificate(r)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/vyprvpn.go

@@ -0,0 +1,24 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+)
+
+func (settings *Provider) readVyprvpn(r reader) (err error) {
+	settings.Name = constants.Vyprvpn
+	servers := r.servers.GetVyprvpn()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.VyprvpnRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	return nil
+}

internal/configuration/windscribe.go

@@ -0,0 +1,67 @@
+package configuration
+
+import (
+	"fmt"
+
+	"github.com/qdm12/gluetun/internal/constants"
+	"github.com/qdm12/golibs/params"
+)
+
+func (settings *Provider) readWindscribe(r reader) (err error) {
+	settings.Name = constants.Windscribe
+	servers := r.servers.GetWindscribe()
+
+	settings.ServerSelection.TargetIP, err = readTargetIP(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.ServerSelection.Regions, err = r.env.CSVInside("REGION", constants.WindscribeRegionChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable REGION: %w", err)
+	}
+
+	settings.ServerSelection.Cities, err = r.env.CSVInside("CITY", constants.WindscribeCityChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable CITY: %w", err)
+	}
+
+	settings.ServerSelection.Hostnames, err = r.env.CSVInside("SERVER_HOSTNAME",
+		constants.WindscribeHostnameChoices(servers))
+	if err != nil {
+		return fmt.Errorf("environment variable SERVER_HOSTNAME: %w", err)
+	}
+
+	err = settings.ServerSelection.OpenVPN.readWindscribe(r.env)
+	if err != nil {
+		return err
+	}
+
+	return settings.ServerSelection.Wireguard.readWindscribe(r.env)
+}
+
+func (settings *OpenVPNSelection) readWindscribe(env params.Interface) (err error) {
+	settings.TCP, err = readProtocol(env)
+	if err != nil {
+		return err
+	}
+
+	settings.CustomPort, err = readOpenVPNCustomPort(env, settings.TCP,
+		[]uint16{21, 22, 80, 123, 143, 443, 587, 1194, 3306, 8080, 54783},
+		[]uint16{53, 80, 123, 443, 1194, 54783})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (settings *WireguardSelection) readWindscribe(env params.Interface) (err error) {
+	settings.CustomPort, err = readWireguardCustomPort(env,
+		[]uint16{53, 80, 123, 443, 1194, 65142})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/configuration/wireguard.go

@@ -0,0 +1,88 @@
+package configuration
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/qdm12/golibs/params"
+)
+
+// Wireguard contains settings to configure the Wireguard client.
+type Wireguard struct {
+	PrivateKey   string       `json:"privatekey"`
+	PreSharedKey string       `json:"presharedkey"`
+	Addresses    []*net.IPNet `json:"addresses"`
+	Interface    string       `json:"interface"`
+}
+
+func (settings *Wireguard) String() string {
+	return strings.Join(settings.lines(), "\n")
+}
+
+func (settings *Wireguard) lines() (lines []string) {
+	lines = append(lines, lastIndent+"Wireguard:")
+
+	lines = append(lines, indent+lastIndent+"Network interface: "+settings.Interface)
+
+	if settings.PrivateKey != "" {
+		lines = append(lines, indent+lastIndent+"Private key is set")
+	}
+
+	if settings.PreSharedKey != "" {
+		lines = append(lines, indent+lastIndent+"Pre-shared key is set")
+	}
+
+	if len(settings.Addresses) > 0 {
+		lines = append(lines, indent+lastIndent+"Addresses: ")
+		for _, address := range settings.Addresses {
+			lines = append(lines, indent+indent+lastIndent+address.String())
+		}
+	}
+
+	return lines
+}
+
+func (settings *Wireguard) read(r reader) (err error) {
+	settings.PrivateKey, err = r.env.Get("WIREGUARD_PRIVATE_KEY",
+		params.CaseSensitiveValue(), params.Unset(), params.Compulsory())
+	if err != nil {
+		return fmt.Errorf("environment variable WIREGUARD_PRIVATE_KEY: %w", err)
+	}
+
+	settings.PreSharedKey, err = r.env.Get("WIREGUARD_PRESHARED_KEY",
+		params.CaseSensitiveValue(), params.Unset())
+	if err != nil {
+		return fmt.Errorf("environment variable WIREGUARD_PRESHARED_KEY: %w", err)
+	}
+
+	err = settings.readAddresses(r.env)
+	if err != nil {
+		return err
+	}
+
+	settings.Interface, err = r.env.Get("WIREGUARD_INTERFACE", params.Default("wg0"))
+	if err != nil {
+		return fmt.Errorf("environment variable WIREGUARD_INTERFACE: %w", err)
+	}
+
+	return nil
+}
+
+func (settings *Wireguard) readAddresses(env params.Interface) (err error) {
+	addressStrings, err := env.CSV("WIREGUARD_ADDRESS", params.Compulsory())
+	if err != nil {
+		return fmt.Errorf("environment variable WIREGUARD_ADDRESS: %w", err)
+	}
+
+	for _, addressString := range addressStrings {
+		ip, ipNet, err := net.ParseCIDR(addressString)
+		if err != nil {
+			return fmt.Errorf("environment variable WIREGUARD_ADDRESS: address %s: %w", addressString, err)
+		}
+		ipNet.IP = ip
+		settings.Addresses = append(settings.Addresses, ipNet)
+	}
+
+	return nil
+}

internal/constants/colors.go

@@ -0,0 +1,11 @@
+package constants
+
+import "github.com/fatih/color"
+
+func ColorUnbound() *color.Color {
+	return color.New(color.FgCyan)
+}
+
+func ColorOpenvpn() *color.Color {
+	return color.New(color.FgHiMagenta)
+}

internal/constants/constants.go

@@ -0,0 +1,25 @@
+// Package constants defines constants shared throughout the program.
+// It also defines constant maps and slices using functions.
+package constants
+
+import "sort"
+
+func makeChoicesUnique(choices []string) []string {
+	uniqueChoices := map[string]struct{}{}
+	for _, choice := range choices {
+		uniqueChoices[choice] = struct{}{}
+	}
+
+	uniqueChoicesSlice := make([]string, len(uniqueChoices))
+	i := 0
+	for choice := range uniqueChoices {
+		uniqueChoicesSlice[i] = choice
+		i++
+	}
+
+	sort.Slice(uniqueChoicesSlice, func(i, j int) bool {
+		return uniqueChoicesSlice[i] < uniqueChoicesSlice[j]
+	})
+
+	return uniqueChoicesSlice
+}

internal/constants/countries.go

@@ -0,0 +1,256 @@
+package constants
+
+func CountryCodes() map[string]string {
+	return map[string]string{
+		"af":  "Afghanistan",
+		"ax":  "Aland Islands",
+		"al":  "Albania",
+		"dz":  "Algeria",
+		"as":  "American Samoa",
+		"ad":  "Andorra",
+		"ao":  "Angola",
+		"ai":  "Anguilla",
+		"aq":  "Antarctica",
+		"ag":  "Antigua and Barbuda",
+		"ar":  "Argentina",
+		"am":  "Armenia",
+		"aw":  "Aruba",
+		"au":  "Australia",
+		"at":  "Austria",
+		"az":  "Azerbaijan",
+		"bs":  "Bahamas",
+		"bh":  "Bahrain",
+		"bd":  "Bangladesh",
+		"bb":  "Barbados",
+		"by":  "Belarus",
+		"be":  "Belgium",
+		"bz":  "Belize",
+		"bj":  "Benin",
+		"bm":  "Bermuda",
+		"bt":  "Bhutan",
+		"bo":  "Bolivia",
+		"bq":  "Bonaire",
+		"ba":  "Bosnia and Herzegovina",
+		"bw":  "Botswana",
+		"bv":  "Bouvet Island",
+		"br":  "Brazil",
+		"io":  "British Indian Ocean Territory",
+		"vg":  "British Virgin Islands",
+		"bn":  "Brunei Darussalam",
+		"bg":  "Bulgaria",
+		"bf":  "Burkina Faso",
+		"bi":  "Burundi",
+		"kh":  "Cambodia",
+		"cm":  "Cameroon",
+		"ca":  "Canada",
+		"cv":  "Cape Verde",
+		"ky":  "Cayman Islands",
+		"cf":  "Central African Republic",
+		"td":  "Chad",
+		"cl":  "Chile",
+		"cn":  "China",
+		"cx":  "Christmas Island",
+		"cc":  "Cocos Islands",
+		"co":  "Colombia",
+		"km":  "Comoros",
+		"cg":  "Congo",
+		"ck":  "Cook Islands",
+		"cr":  "Costa Rica",
+		"ci":  "Cote d'Ivoire",
+		"hr":  "Croatia",
+		"cu":  "Cuba",
+		"cw":  "Curacao",
+		"cy":  "Cyprus",
+		"cz":  "Czech Republic",
+		"cd":  "Democratic Republic of the Congo",
+		"dk":  "Denmark",
+		"dj":  "Djibouti",
+		"dm":  "Dominica",
+		"do":  "Dominican Republic",
+		"ec":  "Ecuador",
+		"eg":  "Egypt",
+		"sv":  "El Salvador",
+		"gq":  "Equatorial Guinea",
+		"er":  "Eritrea",
+		"ee":  "Estonia",
+		"et":  "Ethiopia",
+		"fk":  "Falkland Islands",
+		"fo":  "Faroe Islands",
+		"fj":  "Fiji",
+		"fi":  "Finland",
+		"fr":  "France",
+		"gf":  "French Guiana",
+		"pf":  "French Polynesia",
+		"tf":  "French Southern Territories",
+		"ga":  "Gabon",
+		"gm":  "Gambia",
+		"ge":  "Georgia",
+		"de":  "Germany",
+		"gh":  "Ghana",
+		"gi":  "Gibraltar",
+		"gr":  "Greece",
+		"gl":  "Greenland",
+		"gd":  "Grenada",
+		"gp":  "Guadeloupe",
+		"gu":  "Guam",
+		"gt":  "Guatemala",
+		"gg":  "Guernsey",
+		"gw":  "Guinea-Bissau",
+		"gn":  "Guinea",
+		"gy":  "Guyana",
+		"ht":  "Haiti",
+		"hm":  "Heard Island and McDonald Islands",
+		"hn":  "Honduras",
+		"hk":  "Hong Kong",
+		"hu":  "Hungary",
+		"is":  "Iceland",
+		"in":  "India",
+		"id":  "Indonesia",
+		"ir":  "Iran",
+		"iq":  "Iraq",
+		"ie":  "Ireland",
+		"im":  "Isle of Man",
+		"il":  "Israel",
+		"it":  "Italy",
+		"jm":  "Jamaica",
+		"jp":  "Japan",
+		"je":  "Jersey",
+		"jo":  "Jordan",
+		"kz":  "Kazakhstan",
+		"ke":  "Kenya",
+		"ki":  "Kiribati",
+		"kr":  "Korea",
+		"kw":  "Kuwait",
+		"kg":  "Kyrgyzstan",
+		"la":  "Lao People's Democratic Republic",
+		"lv":  "Latvia",
+		"lb":  "Lebanon",
+		"ls":  "Lesotho",
+		"lr":  "Liberia",
+		"ly":  "Libya",
+		"li":  "Liechtenstein",
+		"lt":  "Lithuania",
+		"lu":  "Luxembourg",
+		"mo":  "Macao",
+		"mk":  "Macedonia",
+		"mg":  "Madagascar",
+		"mw":  "Malawi",
+		"my":  "Malaysia",
+		"mys": "Kuala Lumpur",
+		"mv":  "Maldives",
+		"ml":  "Mali",
+		"mt":  "Malta",
+		"mh":  "Marshall Islands",
+		"mq":  "Martinique",
+		"mr":  "Mauritania",
+		"mu":  "Mauritius",
+		"yt":  "Mayotte",
+		"mx":  "Mexico",
+		"fm":  "Micronesia",
+		"md":  "Moldova",
+		"mc":  "Monaco",
+		"mn":  "Mongolia",
+		"me":  "Montenegro",
+		"ms":  "Montserrat",
+		"ma":  "Morocco",
+		"mz":  "Mozambique",
+		"mm":  "Myanmar",
+		"na":  "Namibia",
+		"nr":  "Nauru",
+		"np":  "Nepal",
+		"nl":  "Netherlands",
+		"nc":  "New Caledonia",
+		"nz":  "New Zealand",
+		"ni":  "Nicaragua",
+		"ne":  "Niger",
+		"ng":  "Nigeria",
+		"nu":  "Niue",
+		"nf":  "Norfolk Island",
+		"mp":  "Northern Mariana Islands",
+		"no":  "Norway",
+		"om":  "Oman",
+		"pk":  "Pakistan",
+		"pw":  "Palau",
+		"ps":  "Palestine, State of",
+		"pa":  "Panama",
+		"pg":  "Papua New Guinea",
+		"py":  "Paraguay",
+		"pe":  "Peru",
+		"ph":  "Philippines",
+		"pn":  "Pitcairn",
+		"pl":  "Poland",
+		"pt":  "Portugal",
+		"pr":  "Puerto Rico",
+		"qa":  "Qatar",
+		"re":  "Reunion",
+		"ro":  "Romania",
+		"ru":  "Russian Federation",
+		"rw":  "Rwanda",
+		"bl":  "Saint Barthelemy",
+		"sh":  "Saint Helena",
+		"kn":  "Saint Kitts and Nevis",
+		"lc":  "Saint Lucia",
+		"mf":  "Saint Martin",
+		"pm":  "Saint Pierre and Miquelon",
+		"vc":  "Saint Vincent and the Grenadines",
+		"ws":  "Samoa",
+		"sm":  "San Marino",
+		"st":  "Sao Tome and Principe",
+		"sa":  "Saudi Arabia",
+		"sn":  "Senegal",
+		"rs":  "Serbia",
+		"sc":  "Seychelles",
+		"sl":  "Sierra Leone",
+		"sg":  "Singapore",
+		"sx":  "Sint Maarten",
+		"sk":  "Slovakia",
+		"si":  "Slovenia",
+		"sb":  "Solomon Islands",
+		"so":  "Somalia",
+		"za":  "South Africa",
+		"gs":  "South Georgia and the South Sandwich Islands",
+		"ss":  "South Sudan",
+		"es":  "Spain",
+		"lk":  "Sri Lanka",
+		"sd":  "Sudan",
+		"sr":  "Suriname",
+		"sj":  "Svalbard and Jan Mayen",
+		"sz":  "Swaziland",
+		"se":  "Sweden",
+		"ch":  "Switzerland",
+		"sy":  "Syrian Arab Republic",
+		"tw":  "Taiwan",
+		"tj":  "Tajikistan",
+		"tz":  "Tanzania",
+		"th":  "Thailand",
+		"tl":  "Timor-Leste",
+		"tg":  "Togo",
+		"tk":  "Tokelau",
+		"to":  "Tonga",
+		"tt":  "Trinidad and Tobago",
+		"tn":  "Tunisia",
+		"tr":  "Turkey",
+		"tm":  "Turkmenistan",
+		"tc":  "Turks and Caicos Islands",
+		"tv":  "Tuvalu",
+		"ug":  "Uganda",
+		"ua":  "Ukraine",
+		"ae":  "United Arab Emirates",
+		"gb":  "United Kingdom",
+		"uk":  "United Kingdom",
+		"um":  "United States Minor Outlying Islands",
+		"us":  "United States",
+		"uy":  "Uruguay",
+		"vi":  "US Virgin Islands",
+		"uz":  "Uzbekistan",
+		"vu":  "Vanuatu",
+		"va":  "Vatican City State",
+		"ve":  "Venezuela",
+		"vn":  "Vietnam",
+		"wf":  "Wallis and Futuna",
+		"eh":  "Western Sahara",
+		"ye":  "Yemen",
+		"zm":  "Zambia",
+		"zw":  "Zimbabwe",
+	}
+}

internal/constants/cyberghost.go

@@ -0,0 +1,45 @@
+package constants
+
+import (
+	"sort"
+
+	"github.com/qdm12/gluetun/internal/models"
+)
+
+//nolint:lll
+const (
+	CyberghostCertificate = "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"
+)
+
+func CyberghostRegionChoices(servers []models.CyberghostServer) (choices []string) {
+	choices = make([]string, len(servers))
+	for i := range servers {
+		choices[i] = servers[i].Region
+	}
+	return makeUnique(choices)
+}
+
+func CyberghostGroupChoices(servers []models.CyberghostServer) (choices []string) {
+	uniqueChoices := map[string]struct{}{}
+	for _, server := range servers {
+		uniqueChoices[server.Group] = struct{}{}
+	}
+
+	choices = make([]string, 0, len(uniqueChoices))
+	for choice := range uniqueChoices {
+		choices = append(choices, choice)
+	}
+
+	sortable := sort.StringSlice(choices)
+	sortable.Sort()
+
+	return sortable
+}
+
+func CyberghostHostnameChoices(servers []models.CyberghostServer) (choices []string) {
+	choices = make([]string, len(servers))
+	for i := range servers {
+		choices[i] = servers[i].Hostname
+	}
+	return makeUnique(choices)
+}

internal/constants/cyberghost_test.go

@@ -0,0 +1,31 @@
+package constants
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/qdm12/gluetun/internal/storage"
+	"github.com/qdm12/golibs/logging/mock_logging"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_CyberghostGroupChoices(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+
+	logger := mock_logging.NewMockLogger(ctrl)
+	logger.EXPECT().Info(gomock.Any())
+
+	storage, err := storage.New(logger, "")
+	require.NoError(t, err)
+
+	servers := storage.GetServers()
+
+	expected := []string{"Premium TCP Asia", "Premium TCP Europe",
+		"Premium TCP USA", "Premium UDP Asia", "Premium UDP Europe",
+		"Premium UDP USA"}
+	choices := CyberghostGroupChoices(servers.GetCyberghost())
+
+	assert.Equal(t, expected, choices)
+}

internal/constants/dns.go

@@ -1,83 +0,0 @@
-package constants
-
-import (
-	"net"
-
-	"github.com/qdm12/private-internet-access-docker/internal/models"
-)
-
-const (
-	// Cloudflare is a DNS over TLS provider
-	Cloudflare models.DNSProvider = "cloudflare"
-	// Google is a DNS over TLS provider
-	Google models.DNSProvider = "google"
-	// Quad9 is a DNS over TLS provider
-	Quad9 models.DNSProvider = "quad9"
-	// Quadrant is a DNS over TLS provider
-	Quadrant models.DNSProvider = "quadrant"
-	// CleanBrowsing is a DNS over TLS provider
-	CleanBrowsing models.DNSProvider = "cleanbrowsing"
-	// SecureDNS is a DNS over TLS provider
-	SecureDNS models.DNSProvider = "securedns"
-	// LibreDNS is a DNS over TLS provider
-	LibreDNS models.DNSProvider = "libredns"
-)
-
-// DNSProviderMapping returns a constant mapping of dns provider name
-// to their data such as IP addresses or TLS host name.
-func DNSProviderMapping() map[models.DNSProvider]models.DNSProviderData {
-	return map[models.DNSProvider]models.DNSProviderData{
-		Cloudflare: models.DNSProviderData{
-			IPs:         []net.IP{{1, 1, 1, 1}, {1, 0, 0, 1}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("cloudflare-dns.com"),
-		},
-		Google: models.DNSProviderData{
-			IPs:         []net.IP{{8, 8, 8, 8}, {8, 8, 4, 4}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("dns.google"),
-		},
-		Quad9: models.DNSProviderData{
-			IPs:         []net.IP{{9, 9, 9, 9}, {149, 112, 112, 112}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("dns.quad9.net"),
-		},
-		Quadrant: models.DNSProviderData{
-			IPs:         []net.IP{{12, 159, 2, 159}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("dns-tls.qis.io"),
-		},
-		CleanBrowsing: models.DNSProviderData{
-			IPs:         []net.IP{{185, 228, 168, 9}, {185, 228, 169, 9}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("security-filter-dns.cleanbrowsing.org"),
-		},
-		SecureDNS: models.DNSProviderData{
-			IPs:         []net.IP{{146, 185, 167, 43}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("dot.securedns.eu"),
-		},
-		LibreDNS: models.DNSProviderData{
-			IPs:         []net.IP{{116, 203, 115, 192}},
-			SupportsTLS: true,
-			Host:        models.DNSHost("dot.libredns.gr"),
-		},
-	}
-}
-
-// Block lists URLs
-const (
-	AdsBlockListHostnamesURL          models.URL = "https://raw.githubusercontent.com/qdm12/files/master/ads-hostnames.updated"
-	AdsBlockListIPsURL                models.URL = "https://raw.githubusercontent.com/qdm12/files/master/ads-ips.updated"
-	MaliciousBlockListHostnamesURL    models.URL = "https://raw.githubusercontent.com/qdm12/files/master/malicious-hostnames.updated"
-	MaliciousBlockListIPsURL          models.URL = "https://raw.githubusercontent.com/qdm12/files/master/malicious-ips.updated"
-	SurveillanceBlockListHostnamesURL models.URL = "https://raw.githubusercontent.com/qdm12/files/master/surveillance-hostnames.updated"
-	SurveillanceBlockListIPsURL       models.URL = "https://raw.githubusercontent.com/qdm12/files/master/surveillance-ips.updated"
-)
-
-// DNS certificates to fetch
-// TODO obtain from source directly, see qdm12/updated)
-const (
-	NamedRootURL models.URL = "https://raw.githubusercontent.com/qdm12/files/master/named.root.updated"
-	RootKeyURL   models.URL = "https://raw.githubusercontent.com/qdm12/files/master/root.key.updated"
-)