chore(release): v2.0.1

* chore(organization): allow nested header and c files

* feat: add shell login "middleware" & etc:
  * lidm now calls `bash` (or other shells, depends on PACKAGE cfg) in
  login mode as a session wrapper to source most env (can be disabled)
  * this fixes a lot of env problems with all `/etc/profile` and more

Extra:
* implemented a musl compatible version of `execvpe` and now lidm should
  search for PATH everywhere it needs to
* `search_path` now also checks if the found binary is properly
  executable
* lidm now uses `confstr` for a decent PATH default if none is found
* logs are unbuffered for cases where debug logs appear empty (exit
  without handlers moment)

* chore: one-time evaluate certain makefile vars

---------

Co-authored-by: grialion <48643945+grialion@users.noreply.github.com>

.clang-format

@@ -1,2 +1,11 @@
-BasedOnStyle: LLVM
+BasedOnStyle: Chromium
 IndentWidth: 2
+SpacesBeforeTrailingComments: 1
+AllowShortIfStatementsOnASingleLine: WithoutElse
+
+AlignAfterOpenBracket: Align
+BinPackParameters: true
+AllowAllParametersOfDeclarationOnNextLine: true
+
+IndentPPDirectives: BeforeHash
+IndentGotoLabels: true

.clang-tidy

@@ -0,0 +1,49 @@
+Checks: >
+  clang-analyzer-*,
+  -clang-analyzer-security.insecureAPI.str*,
+  -clang-analyzer-security.insecureAPI.mem*,
+  -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-signal-handler,
+  cert-*,
+  -cert-msc54-cpp,
+  -cert-sig30-c,
+  modernize-*,
+  -modernize-macro-to-enum,
+  performance-*,
+  portability-*,
+  readability-*,
+  -readability-braces-around-statements,
+
+WarningsAsErrors: ""
+HeaderFilterRegex: ".*"
+FormatStyle: file
+
+CheckOptions:
+  - key: readability-magic-numbers.IgnoredIntegerValues
+    value: "0;1;2;3;10;255"
+  - key: readability-identifier-naming.VariableCase
+    value: lower_case
+  - key: readability-identifier-naming.ConstantParameterCase
+    value: UPPER_CASE
+
+  - key: readability-identifier-naming.ConstantCase
+    value: "UPPER_CASE"
+  - key: readability-identifier-naming.EnumCase
+    value: "CamelCase"
+  - key: readability-identifier-naming.FunctionCase
+    value: "lower_case"
+
+  - key: readability-identifier-length.VariableThreshold
+    value: "2"
+  - key: readability-identifier-length.ParameterThreshold
+    value: "2"
+  - key: readability-identifier-length.LocalConstantThreshold
+    value: "2"
+  - key: readability-identifier-length.MemberThreshold
+    value: "2"
+  - key: readability-identifier-length.MinimumParameterNameLength
+    value: "2"
+  - key: readability-identifier-length.MinimumVariableNameLength
+    value: "2"

.codespellrc

@@ -1,2 +1,2 @@
 [codespell]
-skip = ./assets/pkg/aur/*/src,./assets/pkg/aur/*/*/objects
+skip = ./assets/pkg/aur/*/src,./assets/pkg/aur/*/*/objects,./assets/pkg/aur/*/*.tar.*

.gitattributes

@@ -0,0 +1,2 @@
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/build.yml

@@ -0,0 +1,162 @@
+name: Build
+
+on:
+  workflow_call:
+
+jobs:
+  build-linux-amd64:
+    name: amd64
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git libpam0g-dev"
+          version: 1.0
+      - uses: actions/checkout@v4
+      - id: build
+        run: ARCH=amd64 assets/github_scripts/build.sh
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-amd64
+          path: lidm-amd64
+          retention-days: 1
+
+  build-linux-i386:
+    name: i386
+    runs-on: ubuntu-24.04
+    permissions: write-all
+
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git libpam0g-dev gcc-multilib"
+          version: 1.0
+      - uses: actions/checkout@v4
+      - run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update -y
+          sudo apt-get install -y libpam0g-dev:i386
+
+      - id: build
+        run: ARCH=i386 assets/github_scripts/build.sh CFLAGS="-O3 -Wall -m32"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-i386
+          path: lidm-i386
+          retention-days: 1
+
+  build-linux-aarch64:
+    name: aarch64
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git"
+          version: 1.0
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v2
+        with:
+          arch: aarch64
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update && \
+            apt-get install -y make gcc libpam0g-dev
+          run: ARCH=aarch64 GITHUB_STEP_SUMMARY=gss.out GITHUB_OUTPUT=go.out assets/github_scripts/build.sh
+      - if: always()
+        run: set +e; cat gss.out >>"$GITHUB_STEP_SUMMARY"; cat go.out >>"$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-aarch64
+          path: lidm-aarch64
+          retention-days: 1
+
+  build-linux-armv7:
+    name: armv7
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git"
+          version: 1.0
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v2
+        with:
+          arch: armv7
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update && \
+            apt-get install -y make gcc libpam0g-dev
+          run: ARCH=armv7 GITHUB_STEP_SUMMARY=gss.out GITHUB_OUTPUT=go.out assets/github_scripts/build.sh
+      - if: always()
+        run: set +e; cat gss.out >>"$GITHUB_STEP_SUMMARY"; cat go.out >>"$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-armv7
+          path: lidm-armv7
+          retention-days: 1
+
+  build-linux-riscv64:
+    name: riscv64
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git"
+          version: 1.0
+      - uses: actions/checkout@v4
+      - uses: uraimo/run-on-arch-action@v2
+        with:
+          arch: riscv64
+          distro: ubuntu22.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update && \
+            apt-get install -y make gcc libpam0g-dev
+          run: ARCH=riscv64 GITHUB_STEP_SUMMARY=gss.out GITHUB_OUTPUT=go.out assets/github_scripts/build.sh
+      - if: always()
+        run: set +e; cat gss.out >>"$GITHUB_STEP_SUMMARY"; cat go.out >>"$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-riscv64
+          path: lidm-riscv64
+          retention-days: 1
+
+  # This build job is only symbolic, the behavior of the packaged Void Linux version may differ.
+  build-linux-amd64-musl:
+    name: amd64-musl
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run in Musl Container
+        uses: addnab/docker-run-action@v3
+        with:
+          image: ghcr.io/void-linux/void-musl-full
+          options: -v ${{ github.workspace }}:/workspace
+          run: |
+            cd /workspace
+
+            xbps-install -Syu xbps && xbps-install -yu
+            xbps-install -y git pam-devel make gcc bash git
+
+            ARCH=amd64-musl GITHUB_STEP_SUMMARY=gss.out GITHUB_OUTPUT=go.out assets/github_scripts/build.sh
+      - if: always()
+        run: set +e; cat gss.out >>"$GITHUB_STEP_SUMMARY"; cat go.out >>"$GITHUB_OUTPUT"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: build-amd64-musl
+          path: lidm-amd64-musl
+          retention-days: 1

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

@@ -1,262 +0,0 @@
-name: Check and Build
-
-on:
-  workflow_call:
-    inputs:
-      set-statuses:
-        required: false
-        default: true
-        type: boolean
-
-jobs:
-  spellcheck:
-    name: Check Grammar
-    runs-on: ubuntu-24.04
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: "codespell"
-          version: 1.0
-      - run: codespell
-
-  shellcheck:
-    name: Shell Check
-    runs-on: ubuntu-24.04
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: "shellcheck"
-          version: 1.0
-      - run: find . -type f -name '*.sh' -not -path './assets/pkg/aur/*/src/*' | xargs shellcheck
-
-  clangcheck:
-    name: Chang Check
-    runs-on: ubuntu-24.04
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: "clang-format clang-tidy"
-          version: 1.0
-      - run: clang-format -ni src/*.c include/*.h
-      # TODO: include when the errors/warnings are bearable
-      #- run: clang-tidy src/*.c include/*.h
-
-  build-linux-amd64:
-    name: Build for amd64
-    runs-on: ubuntu-24.04
-    permissions: write-all
-    needs: [spellcheck, shellcheck, clangcheck]
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: "libpam0g-dev"
-          version: 1.0
-      - id: build
-        run: |
-          make -j$(nproc) 2> /tmp/stderr
-          cat /tmp/stderr >&2
-
-          HSIZE="$(stat --printf="%s" lidm | numfmt --to=iec-i)B"
-          WARNS="$(cat /tmp/stderr | grep '^[^ ]*\.[ch]:' | wc -l)"
-          mv lidm lidm-amd64
-
-          echo "DESCR='$HSIZE, $WARNS warnings'" >> "$GITHUB_OUTPUT"
-
-      - uses: myrotvorets/set-commit-status-action@master
-        if: inputs.set-statuses
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          status: ${{ job.status }}
-          description: ${{ steps.build.outputs.DESCR }}
-          context: Build for amd64
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-amd64
-          path: lidm-amd64
-          retention-days: 1
-
-  build-linux-i386:
-    name: Build for i386
-    runs-on: ubuntu-24.04
-    permissions: write-all
-    needs: [spellcheck, shellcheck, clangcheck]
-
-    steps:
-      - uses: actions/checkout@v4
-      - uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: "libpam0g-dev gcc-multilib"
-          version: 1.0
-      - run: |
-          sudo dpkg --add-architecture i386
-          sudo apt-get update -y
-          sudo apt-get install -y libpam0g-dev:i386
-
-      - id: build
-        run: |
-          make -j$(nproc) CFLAGS="-O3 -Wall -m32" 2> /tmp/stderr
-          cat /tmp/stderr >&2
-
-          HSIZE="$(stat --printf="%s" lidm | numfmt --to=iec-i)B"
-          WARNS="$(cat /tmp/stderr | grep '^[^ ]*\.[ch]:' | wc -l)"
-          mv lidm lidm-i386
-
-          echo "DESCR='$HSIZE, $WARNS warnings'" >> "$GITHUB_OUTPUT"
-
-      - uses: myrotvorets/set-commit-status-action@master
-        if: inputs.set-statuses
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          status: ${{ job.status }}
-          description: ${{ steps.build.outputs.DESCR }}
-          context: Build for i386
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-i386
-          path: lidm-i386
-          retention-days: 1
-
-  build-linux-aarch64:
-    name: Build for aarch64
-    runs-on: ubuntu-24.04
-    permissions: write-all
-    needs: [spellcheck, shellcheck, clangcheck]
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: uraimo/run-on-arch-action@v2
-        with:
-          arch: none
-          distro: none
-          base_image: '--platform=linux/aarch64 ubuntu:22.04'
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update && \
-            apt-get install -y make gcc libpam0g-dev
-          run: |
-            make -j$(nproc) 2> /tmp/stderr
-
-            cat /tmp/stderr >&2
-            mv lidm lidm-aarch64
-
-      - if: inputs.set-statuses
-        id: status
-        run: |
-          HSIZE="$(stat --printf="%s" lidm-aarch64 | numfmt --to=iec-i)B"
-          WARNS="$(cat /tmp/stderr | grep '^[^ ]*\.[ch]:' | wc -l)"
-
-          echo "DESCR='$HSIZE, $WARNS warnings'" >> "$GITHUB_OUTPUT"
-
-      - uses: myrotvorets/set-commit-status-action@master
-        if: inputs.set-statuses
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          status: ${{ job.status }}
-          description: ${{ steps.status.outputs.DESCR }}
-          context: Build for aarch64
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-aarch64
-          path: lidm-aarch64
-          retention-days: 1
-
-  build-linux-armv7:
-    name: Build for armv7
-    runs-on: ubuntu-24.04
-    permissions: write-all
-    needs: [spellcheck, shellcheck, clangcheck]
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: uraimo/run-on-arch-action@v2
-        with:
-          arch: none
-          distro: none
-          base_image: '--platform=linux/arm/v7 ubuntu:22.04'
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update && \
-            apt-get install -y make gcc libpam0g-dev
-          run: |
-            make -j$(nproc) 2> /tmp/stderr
-
-            cat /tmp/stderr >&2
-            mv lidm lidm-armv7
-
-      - if: inputs.set-statuses
-        id: status
-        run: |
-          HSIZE="$(stat --printf="%s" lidm-armv7 | numfmt --to=iec-i)B"
-          WARNS="$(cat /tmp/stderr | grep '^[^ ]*\.[ch]:' | wc -l)"
-
-          echo "DESCR='$HSIZE, $WARNS warnings'" >> "$GITHUB_OUTPUT"
-
-      - uses: myrotvorets/set-commit-status-action@master
-        if: inputs.set-statuses
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          status: ${{ job.status }}
-          description: ${{ steps.status.outputs.DESCR }}
-          context: Build for armv7
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-armv7
-          path: lidm-armv7
-          retention-days: 1
-
-  build-linux-riscv64:
-    name: Build for riscv64
-    runs-on: ubuntu-24.04
-    permissions: write-all
-    needs: [spellcheck, shellcheck, clangcheck]
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: uraimo/run-on-arch-action@v2
-        with:
-          arch: none
-          distro: none
-          base_image: '--platform=linux/riscv64 riscv64/ubuntu:22.04'
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update && \
-            apt-get install -y make gcc libpam0g-dev
-          run: |
-            make -j$(nproc) 2> /tmp/stderr
-
-            cat /tmp/stderr >&2
-            mv lidm lidm-riscv64
-
-      - if: inputs.set-statuses
-        id: status
-        run: |
-          HSIZE="$(stat --printf="%s" lidm-riscv64 | numfmt --to=iec-i)B"
-          WARNS="$(cat /tmp/stderr | grep '^[^ ]*\.[ch]:' | wc -l)"
-
-          echo "DESCR='$HSIZE, $WARNS warnings'" >> "$GITHUB_OUTPUT"
-
-      - uses: myrotvorets/set-commit-status-action@master
-        if: inputs.set-statuses
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          status: ${{ job.status }}
-          description: ${{ steps.status.outputs.DESCR }}
-          context: Build for riscv64
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: build-riscv64
-          path: lidm-riscv64
-          retention-days: 1

.github/workflows/check.yml

@@ -0,0 +1,51 @@
+name: Check
+
+on:
+  workflow_call:
+
+jobs:
+  spellcheck:
+    name: Grammar
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "codespell"
+          version: 1.0
+      - run: codespell
+
+  shellcheck:
+    name: Shellcheck
+    runs-on: ubuntu-24.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "shellcheck"
+          version: 1.0
+      - run: git ls-files "*.sh" "*/PKGBUILD" | xargs shellcheck --shell=bash
+
+  clangcheck:
+    name: Clang
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:25.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - run: apt -y update && apt install -y clang-format clang-tidy make gcc git bear libpam0g-dev
+
+      - run: bear -- make
+      - run: clang-format -version && clang-format -dump-config
+      - run: |
+          set -euo pipefail
+          clang-format -ni src/*.c include/*.h -Werror 2>&1 | \
+            sed -E 's/^([^ ]+\.[ch]):([0-9]+):([0-9]+): ([a-z]+): (.*)$/::\4 file=\1,line=\2,col=\3::\5/'
+      - run: clang-tidy -version && clang-tidy -dump-config
+      - run: |
+          set -euo pipefail
+          clang-tidy -p . src/*.c include/*.h -warnings-as-errors=\* 2>&1 1>/dev/null |
+            sed -E 's/^([^ ]+\.[ch]):([0-9]+):([0-9]+): ([a-z]+): (.*)$/::\4 file=\1,line=\2,col=\3::\5/'

.github/workflows/make-release.yml

@@ -1,26 +1,55 @@
-name: Check and Build Release
+name: Make Release
 
 on:
   workflow_dispatch:
-    inputs:
-      version:
-        required: true
-        default: ''
-        type: string
 
 jobs:
-  build:
-    name: Check and Build
-    uses: ./.github/workflows/check-and-build.yml
-    permissions: write-all
-    with:
-      set-statuses: false
-
-  release:
-    name: Make Release v${{ inputs.version }}
+  release-checks:
+    name: Release Checks
     runs-on: ubuntu-24.04
     permissions: write-all
-    needs: build
+    outputs:
+      VERSION: ${{ steps.check-ver-changed.outputs.VERSION }}
+    steps:
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: "git"
+          version: 1.0
+      - uses: actions/checkout@v4
+        with:
+          fetch-tags: true
+
+      - name: Check Version Changed
+        id: check-ver-changed
+        run: |
+          GIT_TAG=$(git describe --no-long --abbrev=0 --tags --always)
+          MAKE_TAG=$(make print-version)
+
+          if [[ "$GIT_TAG" == "v$MAKE_TAG" ]]; then
+            echo "ERR: Git tag matches makefile, did you bump Makefile up?" >&2
+            exit 1
+          fi
+
+          echo "VERSION=$MAKE_TAG" >> "$GITHUB_OUTPUT"
+
+
+  check:
+    name: Check
+    needs: release-checks
+    uses: ./.github/workflows/check.yml
+    permissions: write-all
+
+  build:
+    name: Build
+    needs: release-checks
+    uses: ./.github/workflows/build.yml
+    permissions: write-all
+
+  release:
+    name: Make Release v${{ needs.release-checks.outputs.VERSION }}
+    runs-on: ubuntu-24.04
+    permissions: write-all
+    needs: [ release-checks, check, build ]
     steps:
       - uses: actions/download-artifact@v4
         with:
@@ -30,43 +59,42 @@ jobs:
 
       - uses: ncipollo/release-action@v1
         with:
-          tag: v${{ inputs.version }}
+          tag: v${{ needs.release-checks.outputs.VERSION }}
           commit: ${{ github.sha }}
           artifacts: builds/lidm-*
           artifactErrorsFailBuild: true
           body: Release notes not generated yet.
 
-  aur-update:
-    name: Update AUR pkgs
+  nix-update:
+    name: Update NixOS module
     runs-on: ubuntu-24.04
-    container: archlinux:latest
     permissions: write-all
-    needs: release
+    needs: [ release-checks, release ]
     steps:
-      - run: pacman -Sy --noconfirm git github-cli base-devel pacman-contrib
-
+      - uses: cachix/install-nix-action@v31
       - uses: actions/checkout@v4
+        with:
+          fetch-tags: true
 
       - run: |
-          chage -E -1 nobody
-          passwd -u nobody
+          tmpdir=$(mktemp -d)
+          git archive v${{ needs.release-checks.outputs.VERSION }} | tar -xC "$tmpdir"
+          sha256sum=$(nix hash path "$tmpdir")
 
-          cd "assets/pkg/aur"
-          chown nobody:nobody . -R
-          su - -s /bin/bash nobody -c "$PWD/update-pkgs.sh ${{ inputs.version }}"
-          su - -s /bin/bash nobody -c "$PWD/test-makepkg.sh" # This will also update -git pkgver
-          chown $UID:$(id -g) . -R
+          sed -i -E 's/(.*version\s*=\s*")[0-9.]*(".*)/\1'${{ needs.release-checks.outputs.VERSION }}'\2/' assets/pkg/nix/module.nix
+          sed -i -E 's|(.*sha256\s*=\s*")[^"]*(".*)|\1'"$sha256sum"'\2|' assets/pkg/nix/module.nix
+        # would be cool to be able to check the new module.nix builds
 
       - run: |
-          BRANCH=actions/update-aur-${{ inputs.version }}
+          BRANCH=actions/update-nix-${{ needs.release-checks.outputs.VERSION }}
           git config --global --add safe.directory $GITHUB_WORKSPACE
           git config user.name "GitHub Actions"
           git config user.email "actions@github.com"
           git checkout -b $BRANCH
-          git commit -am "Update AUR pkgs to v${{ inputs.version }}"
+          git commit -am "Update NixOS module to v${{ needs.release-checks.outputs.VERSION }}"
           git push -u origin $BRANCH
           gh pr create --head $BRANCH \
-            --title "[AUR update]: Bump to ${{ inputs.version }}" \
+            --title "[Nix update]: Bump to ${{ needs.release-checks.outputs.VERSION }}" \
             --body "*This PR was created automatically*"
         env:
           GH_TOKEN: ${{ github.token }}

.github/workflows/push.yml

@@ -1,10 +1,35 @@
-name: Push Checks
+name: _
 
 on:
-  push
+  push:
+    branches:
+      - master
+  pull_request:
+  workflow_dispatch:
 
 jobs:
-  check-and-build:
-    name: Check and Build
-    uses: ./.github/workflows/check-and-build.yml
+  check:
+    name: Check
+    uses: ./.github/workflows/check.yml
+    permissions: write-all
+  check_paths:
+    name: Paths Filter
+    runs-on: ubuntu-latest
+    outputs:
+      code_changed: ${{ steps.filter.outputs.code }}
+    steps:
+      - uses: actions/checkout@v4
+      - id: filter
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            code:
+              - Makefile
+              - 'src/**'
+              - 'include/**'
+  build:
+    name: Build
+    needs: check_paths
+    if: github.event_name != 'push' || needs.check_paths.outputs.code_changed == 'true'
+    uses: ./.github/workflows/build.yml
     permissions: write-all

.gitignore

@@ -3,6 +3,8 @@ dist/
 /compile_commands.json
 
 .cache/
+# just in case, i dont wanna rebase ever again
+valgrind-out.txt
 
 # nix build result
 result

CHANGELOG.md

@@ -0,0 +1,19 @@
+<!-- Unspecified dates shall be in CET/CEST -->
+
+<!-- Add only very relevant changes, bottom to top -->
+<!-- By "very relevant" I mean big features or something manual packagers should know, like leftover files -->
+<!-- Once a release would be opened, group the last bunch of dangling changes, add release version as header and its date -->
+
+# 2.0.1
+
+- source and header files can be nested in `src/` and `include/`
+- lidm now calls bash for logging in and sourcing profile files, other shells can be configured
+- a good PATH default is fetched from `confstr`
+- debug logs are now unbuffered
+
+# 2.0.0
+
+- Most stuff (most of `/etc` being a notable exception) now installs to `/usr/local` by default, check [`docs/PACKAGERS.md`](./docs/PACKAGERS.md).
+- Added a changelog.
+- Finally add proper (experimental) xorg support.
+- Systemd service install path changed to `/usr/local/lib/systemd`, there could be a leftover file at `/etc/systemd/system/lidm.service`.

INSTALL.md

@@ -1,69 +0,0 @@
-# Index
-
-- [Index](#index)
-- [Installing from Source](#installing-from-source)
-- [AUR](#aur)
-- [Nix Flake](#nix-flake)
-
-> [!CAUTION]
-> I encourage you to read the manual installation steps to understand what will get installed in your computer by this package.
-
-# Installing from Source
-
-Firstly, you'll need to build the package, this also includes man pages, default config, themes and other files you might need.
-
-To build it you only need to have some basic packages (should come pre-installed in almost all distros): `make`, `gcc` or another `gcc`ish compiler, and libpam headers. If it builds, it surely works anyways.
-
-```sh
-git clone https://github.com/javalsai/lidm.git
-cd lidm
-make # 👍
-```
-
-> [!NOTE]
-> There's pre-built binaries on the [releases tab](https://github.com/javalsai/lidm/releases) too.
-
-Then you can install the files onto your filesystem with:
-
-```sh
-make install
-```
-
-And additionally, to install service files (start-up behavior). <sup>[more docs](./assets/services/README.md)</sup>
-
-```sh
-# automatically detects your init system
-# and install service file (for tty7)
-make install-service
-
-# or if you don't like autodetection
-make install-service-systemd # systemd
-make install-service-dinit # dinit
-make install-service-runit # runit
-make install-service-openrc # openrc
-make install-service-s6 # s6
-```
-
-# AUR
-
-[AUR packages](https://aur.archlinux.org/packages?K=lidm\&SeB=n) will automatically install most files.
-
-> [!CAUTION]
-> [service files](./assets/pkg/aur#services) have to be manually installed by now.
-
-# Nix Flake
-
-You can install by doing
-
-```sh
-nix profile install github:javalsai/lidm
-```
-
-or try it out without installing by:
-
-```sh
-nix run github:javalsai/lidm
-```
-
-> [!CAUTION]
-> This doesn't include [service files](./assets/pkg/aur#services) neither

Makefile

@@ -1,74 +1,71 @@
+VERSION := 2.0.1
+.DEFAULT_GOAL := lidm
+
 CDIR = src
 LDIR = lib
 IDIR = include
 ODIR = dist
 
-PREFIX=/usr
+PREFIX = /usr/local
 
-CC?=gcc
-CFLAGS?=-O3 -Wall
-_CFLAGS=-I$(DIR)
-ALLFLAGS=$(CFLAGS) -I$(IDIR)
+INFO_GIT_REV ?= $(shell git describe --long --tags --always || echo '?')
+INFO_GIT_REV := $(INFO_GIT_REV)
+INFO_BUILD_TS ?= $(shell date +%s)
+INFO_BUILD_TS := $(INFO_BUILD_TS)
 
-LIBS=-lm -lpam -lpam_misc
+CFLAGS ?= -O3 -Wall -Wextra -fdata-sections -ffunction-sections
+# C PreProcessor flags, not C Plus Plus
+CPPFLAGS ?=
+_DFLAGS?= \
+	-DLIDM_VERSION=\"$(VERSION)\" \
+	-DLIDM_GIT_REV=\"$(INFO_GIT_REV)\" \
+	-DLIDM_BUILD_TS=$(INFO_BUILD_TS)
+ALLFLAGS = $(_DFLAGS) $(CFLAGS) $(CPPFLAGS) -I$(IDIR)
+LDFLAGS ?= -Wl,--gc-sections
 
-_DEPS = util.h ui.h config.h auth.h efield.h keys.h users.h sessions.h chvt.h
-DEPS = $(patsubst %,$(IDIR)/%,$(_DEPS))
+LIBS = -lpam
 
-_OBJ = main.o util.o ui.o config.o auth.o efield.o users.o sessions.o chvt.o
-OBJ = $(patsubst %,$(ODIR)/%,$(_OBJ))
+# includes all headers in `$(IDIR)` and compiles everything in `$(CDIR)`
+DEPS = $(wildcard $(IDIR)/*.h $(IDIR)/**/*.h)
+_SOURCES = $(wildcard $(CDIR)/*.c) $(wildcard $(CDIR)/**/*.c)
+OBJ = $(patsubst $(CDIR)/%.c,$(ODIR)/%.o,$(_SOURCES))
 
 $(ODIR)/%.o: $(CDIR)/%.c $(DEPS)
-	@mkdir -p $(ODIR)
+	@mkdir -p $(dir $@)
 	$(CC) -c -o $@ $< $(ALLFLAGS)
 
 lidm: $(OBJ)
-	$(CC) -o $@ $^ $(ALLFLAGS) $(LIBS)
+	$(CC) -o $@ $^ $(ALLFLAGS) $(LIBS) $(LDFLAGS)
 
-.PHONY: clean
 clean:
-	rm -f $(ODIR)/*.o lidm
+	rm -rf $(ODIR) lidm
 
-# Copy lidm to ${DESTDIR}${PREFIX}/bin (/usr/bin)
 install: lidm
 	mkdir -p ${DESTDIR}${PREFIX}/bin ${DESTDIR}${PREFIX}/share/man/man{1,5}
 	install -Dm755 ./lidm ${DESTDIR}${PREFIX}/bin/
-	install -Dm644 ./themes/default.ini ${DESTDIR}/etc/lidm.ini
+	[ -f ${DESTDIR}/etc/lidm.ini ] || install -Dm644 ./themes/default.ini ${DESTDIR}/etc/lidm.ini
 	install -Dm644 ./assets/man/lidm.1 ${DESTDIR}${PREFIX}/share/man/man1/
 	install -Dm644 ./assets/man/lidm-config.5 ${DESTDIR}${PREFIX}/share/man/man5/
 
-uninstall:
+uninstall: uninstall-service
 	rm -rf ${DESTDIR}${PREFIX}/bin/lidm ${DESTDIR}/etc/lidm.ini
-	rm -rf ${DESTDIR}/usr/share/man/man{1/lidm.1,5/lidm-config.5}.gz
-	rm -rf /etc/systemd/system/lidm.service /etc/dinit.d/lidm /etc/runit/sv/lidm
+	rm -rf ${DESTDIR}${PREFIX}/share/man/man{1/lidm.1,5/lidm-config.5}.gz
 
-install-service:
-	@if command -v systemctl &> /dev/null; then \
-		make install-service-systemd; \
-	elif command -v dinitctl &> /dev/null; then \
-		make install-service-dinit; \
-	elif command -v sv &> /dev/null; then \
-		make install-service-runit; \
-	elif command -v rc-update &> /dev/null; then \
-		make install-service-openrc; \
-	elif command -v s6-service &> /dev/null; then \
-		make install-service-s6; \
-	else \
-		printf '\x1b[1;31m%s\x1b[0m\n' "Unknown init system, skipping service install..."; \
-	fi
+include services.mk
 
-install-service-systemd:
-	install -m644 ./assets/services/systemd.service /etc/systemd/system/lidm.service
-	@printf '\x1b[1m%s\x1b[0m\n\n' " don't forget to run 'systemctl enable lidm'"
-install-service-dinit:
-	install -m644 ./assets/services/dinit /etc/dinit.d/lidm
-	@printf '\x1b[1m%s\x1b[0m\n\n' " don't forget to run 'dinitctl enable lidm'"
-install-service-runit:
-	rsync -a --no-owner --no-group ./assets/services/runit/. /etc/runit/sv/lidm
-	@printf '\x1b[1m%s\x1b[0m\n\n' " don't forget to run 'ln -s /etc/runit/sv/lidm /run/runit/service' and 'sv enable lidm'"
-install-service-openrc:
-	install -m755 ./assets/services/openrc /etc/init.d/lidm
-	@printf '\x1b[1m%s\x1b[0m\n\n' " don't forget to run 'rc-update add lidm'"
-install-service-s6:
-	rsync -a --no-owner --no-group ./assets/services/s6/. /etc/s6/sv/lidm
-	@printf '\x1b[1m%s\x1b[0m\n\n' " don't forget to run 's6-service add default lidm' and 's6-db-reload'"
+pre-commit:
+	codespell
+	prettier -c "**/*.md"
+	git ls-files "*.sh" "*/PKGBUILD" | xargs shellcheck --shell=bash
+	clang-format -i $$(git ls-files "*.c" "*.h")
+	git ls-files -z "*.c" "*.h" | \
+		parallel -j$$(nproc) -q0 --no-notice --will-cite --tty clang-tidy -warnings-as-errors=\* --quiet |& \
+		grep -v "warnings generated." || true
+
+print-version:
+	@echo $(VERSION)
+
+.PHONY: clean \
+	install uninstall \
+	pre-commit \
+	print-version

README.md

@@ -4,45 +4,41 @@
 
 # LiDM
 
-LiDM is a really light UI portion a unix [login manager](https://en.wikipedia.org/wiki/Login_manager) made in C, highly customizable and held together by hopes and prayers 🙏.
+LiDM is a really light unix [login manager](https://en.wikipedia.org/wiki/Login_manager) made in C, highly customizable and held together by hopes and prayers 🙏.
 
-LiDM is like any [X Display Manager](https://en.wikipedia.org/wiki/X_display_manager) you have seen such as SDDM or GDM but without using X org graphics, instead being a purely [text based interface](https://en.wikipedia.org/wiki/Text-based_user_interface).
+LiDM is like any [Display Manager](https://en.wikipedia.org/wiki/X_display_manager) you have seen such as SDDM or GDM but without using any X.org graphics at all. Instead being a purely [text based interface](https://en.wikipedia.org/wiki/Text-based_user_interface) inside your terminal/TTY.
 
 ![demo gif](assets/media/lidm.gif)
 
-> *shown as in a featured terminal emulator, actual linux console doesn't support as much color and decorations*
+<blockquote><details>
+<summary><i>
+shown as in a featured terminal emulator, actual linux console doesn't support as much color and decorations
+</i></summary>
 
-> *however, all colors and strings are fully customizable*
+If you want to add fancy color and font support to your TTYs you can try wrapping lidm in [`kmscon`](https://wiki.archlinux.org/title/KMSCON). (edit appropriate service files). e.g:
+
+```sh
+kmscon -l --vt /dev/tty7 --font-name "Cascadia Code" -- /usr/bin/lidm
+```
+
+Kmscon is NOT officially supported so you are on your own when trying this, [according to the arch wiki](https://wiki.archlinux.org/title/KMSCON#Window_managers_cannot_be_started_from_KMS_console) it's not possible to start window managers if you do this.
+
+But [according to farouk](https://github.com/javalsai/lidm/issues/91#issuecomment-3708503568) you can make it work if you tell kmscon to work in `no-drm` mode. There's still input grabbing issues which cause <kbd><kbd>Ctrl</kbd> + <kbd>C</kbd></kbd> to kill lidm, they are likely fixable though.
+
+</details></blockquote>
+
+> _however, all colors and strings are fully customizable_
 
 ## Features
 
-* Builds **FAST**.
-  * `a32e4a5`:
-    * `2.830s`: laptop, -O3, -j2, `AMD E-450 APU with Radeon(tm) HD Graphics`
-    * `0.172s`: desktop, -O3, -j12, `AMD Ryzen 5 5600G with Radeon Graphics`
-  * `663427e`:
-    * `0.085s`: desktop, -O0, `AMD Ryzen 5 5600G with Radeon Graphics`
-    * `0.009s`: desktop, -O0, CC=tcc, `AMD Ryzen 5 5600G with Radeon Graphics`
-* Works everywhere you can get gcc to compile.
-* Fast and possibly efficient.
-* Fully customizable, from strings, including action keys, to colors (I hope you know ansi escape codes)
-* Automatically detects xorg and wayland sessions, plus allowing to launch the default user shell (if enabled in config)
-* Starts with many init systems (systemd, dinit, runit, openrc and s6).
+- Simple as C, meant to depend only on standard libc and basic unix system headers.
+- Fully customizable: ALL strings, colors (with its ANSI keys) and most behavior.
+- Experimental Xorg support[\*](https://github.com/javalsai/lidm/pull/80?#issuecomment-3764073217) and wayland sessions, while supporting the default user shell (if enabled in config)
+- Init agnostinc (systemd, dinit, runit, openrc and s6).
+- Supports [fido yubikeys](./docs/yubikey.md) (via pam_u2f).
 
-## WIP
+# Table of Contents
 
-* Desktop's file `TryExec` key.
-* Save last selection.
-* Show/hide passwd switch.
-* Long sessions, strings, usernames, passwords... they will just overflow or fuck your terminal, I know it and I don't know if I'll fix it.
-* UTF characters or any multi-byte character, not yet supported properly, everything treats characters as a single byte, some chars might work or not depending on the context, but it's not designed to.
-
-# Index
-
-- [LiDM](#lidm)
-  - [Features](#features)
-  - [WIP](#wip)
-- [Index](#index)
 - [Ideology](#ideology)
 - [Usage](#usage)
   - [Arguments](#arguments)
@@ -50,8 +46,10 @@ LiDM is like any [X Display Manager](https://en.wikipedia.org/wiki/X_display_man
 - [Requirements](#requirements)
 - [Installation](#installation)
 - [Configuring](#configuring)
+- [PAM](#pam)
 - [Contributing](#contributing)
-- [Backstory](#backstory)
+- [License](#license)
+- [Inspiration](#inspiration)
 - [Contributors](#contributors)
 
 # Ideology
@@ -60,72 +58,97 @@ We all know that the most important thing in a project is the ideology of the au
 
 [ ![stopchatcontrol](https://stopchatcontrol.eu/wp-content/uploads/2023/09/1-1-1024x1024.png) ](https://stopchatcontrol.eu)
 
-> *there's also a [change.org post](https://www.change.org/p/stoppt-die-chatkontrolle-grundrechte-gelten-auch-im-netz).*
+> _there's also a [change.org post](https://www.change.org/p/stoppt-die-chatkontrolle-grundrechte-gelten-auch-im-netz)._
 
 # Usage
 
 ### Arguments
 
-If a single argument is provided (don't even do `--` or standard parsing...), it passes that argument to `chvt` on startup, used (at least) by most service files.
+If a single argument is provided (don't even do `--` or standard unix parsing...), it switches to said tty number at startup. Used (at least) by most service files.
 
 ### Program
 
-On top of pure intuition:
+Base (mostly intuitive):
 
-* You can change focus of session/user/passwd with up/down arrows.
-* In case arrow keys do nothing on the focused input (Either is empty text or doesn't have more options), it tries to change session and if there's only one session it changes user.
-* Typing anything will allow to put a custom user or shell command too, you can use arrow keys to move.
-* ESC and then left/right arrows will force to change the option of the focused input, useful if you're editing the current input and arrow keys just move.
-* Editing a predefined option on a user or a shell session, will put you in edit mode preserving the original value, other cases start from scratch.
+- Use arrow keys to navigate the inputs and type over any of them to override the default value.
+- Enter will just attempt to login.
+- If you are focused on an edited input, horizontal arrow keys will attempt to move across the text just as expected.
+
+On top of that:
+
+- Using the horizontal arrow keys if the focused input is not in text mode or the movement would overflow the input. It will try to change in such direction the option of session or the user.
+- Pressing <kbd>ESC</kbd> and then horizontal arrows will force to change the option of the focused input even if it's in edit mode.
+- Editing an option on a user or a shell session will put you in edit mode appending after the original value.
 
 # Requirements
 
-* A computer with unix based system.
-* That system should have the resources necessary for this program to make sense (Sessions, users...).
-* A compiler (optional, you can compile by hand, but I doubt you want to see the code).
-* Make (Also optional, but does things automatically, make sure `gcc` and `mkdir -p` work as expected).
-* PAM, used for user authentication, just what `login` or `su` use internally. Don't worry, it's surely pre-installed.
+- Make (Also optional, but does things automatically, make sure `gcc` and `mkdir -p` work as expected).
+- A compiler like `cc`, `gcc` or `clang`. Make sure to use the desired `CC=<compiler>` on the `make` command.
+- PAM library, used for user authentication, just what `login` or `su` use internally. Don't worry, it's surely pre-installed.
 
 # Installation
 
-Check the [installation guide](./INSTALL.md) to use your preferred installation source.
+Check the [installation guide](./docs/INSTALL.md) to use your preferred installation source.
+
+<details>
+
+<summary>Packagers read here!!</summary>
+
+If you are a package maintainer or are willing to become one, please read [the packagers guide](./docs/PACKAGERS.md).
+
+</details>
 
 # Configuring
 
-Copy any `.ini` file from [`themes/`](./themes/) (`default.ini` will always be updated) to `/etc/lidm.ini` and/or configure it to your liking. Also, don't place empty lines (for now). You can also set `LIDM_CONF` environment variable to specify a config path.
+Copy any `.ini` file from [`themes/`](./themes/) (`default.ini` will always be updated) to `/etc/lidm.ini` and/or configure it to your liking. You can also set `LIDM_CONF` environment variable to specify a config path.
 
-Configured colors are just gonna be put inside `\x1b[...m`, ofc you can add an 'm' to break this and this can f\*ck up really bad or even make some nice UI effect possible, you should also be able to embed the `\x1b` byte in the config as I won't parse escape codes, I think that the parser is just gonna grab anything in the config file from the space after the `=` (yes, I'ma enforce that space, get good taste if you don't like it) until the newline, you can put any abomination in there. But please, keep in mind this might break easily.
+The format attempts to mimic the TOML format. Escape sequences like `\x1b` are allowed as well as comments and empty lines.
 
-The default fg style should disable decorators set up in other elements (cursive, underline... it's just adding 20 to the number btw, so if cursive is 4 (iirc), disabling it is 24).
+Colors are gonna be put inside `\x1b[...m`, if you don't know what this is check [an ANSI table](https://gist.github.com/JBlond/2fea43a3049b38287e5e9cefc87b2124). Mind that `\x1b` is the same as `\e`, `\033` and several other representations.
+
+> [!NOTE]
+> The default `fg` style should disable decorators set up in other elements (cursive, underline...). It's just adding 20 to the number, so if an underline is 4, disabling it is done with 24.
 
 > [!TIP]
 > If you don't like seeing an element, you can change the fg color of it to be the same as the bg, making it invisible.
 
+# PAM
+
+If your distribution does not use the standard PAM service name `login` (`/etc/pam.d/login`) for its PAM services or if you want to use another PAM file, simply set the `LIDM_PAM_SERVICE` env variable to your PAM service name.
+
+When the env variable is empty it defaults to the `login` PAM service or whatever fallback your distribution packager has defined during compilation.
+
 # Contributing
 
-If you want to contribute check the [CONTRIBUTING.md](docs/CONTRIBUTING.md)
+If you want to contribute check the [contribution guide](docs/CONTRIBUTING.md).
 
-# Backstory
+# License
 
-Summer travelling to visit family with an old laptop that barely supports x86\_64, and ly recently added some avx2 instructions I think (invalid op codes), manually building (any previous commit too) didn't work because of something in the `build.zig` file, so out of boredom I decided to craft up my own simple display manager on the only language this thing can handle... **C** (I hate this and reserve the right for the rust rewrite, actually solid).
+This project is licensed under the GNU General Public License v3.0 **only**.
 
-I spedrun it in roughly 3 days and I'm bad af in C, so this is spaghetti code on **another** level. I think it doesn't do almost anything unsafe, I mean, I didn't check allocations and it's capable of reallocating memory until your username uses all memory, crashing the system due to a off-by-one error, but pretty consistent otherwise (probably).
+# Inspiration
 
-The name is just ly but changing "y" with "i", that had a reason but forgot it, (maybe the i in *simple*), so I remembered this sh\*tty laptop with a lid, this thing is also a display manager (dm, ly command is also `ly-dm`), so just did lidm due to all that.
+This project was started after facing some issues building [ly](https://github.com/fairyglade/ly) on an ancient laptop, the UI is heavily inspired by it.
+
+For this reason the project's philosophy is to be simple and minimal, such that even prehistoric hardware is capable of running it.
+
+I forgot what exactly the name came from, but it surely was a mix of a few things so:
+
+- Obviously it's inspired by `ly`. `ly-dm` leads to "lydm".
+- Wow make "lydm" simple with a "y" → "i" transformation.
+- Associate it with the "i" in s**i**mple and other display managers like **Li**ghtDM.
+- And the **la**ptop this project started in has a **lid**.
 
 # Contributors
 
-[![GitHub Contributors](https://contrib.rocks/image?repo=javalsai/lidm\&max=20)](https://github.com/javalsai/lidm/graphs/contributors)
+[![GitHub Contributors](https://contrib.rocks/image?repo=javalsai/lidm&max=20)](https://github.com/javalsai/lidm/graphs/contributors)
 
-* KillerTofus, [made the AUR package](https://github.com/javalsai/lidm/pull/2)! Saved me from reading the Arch Wiki 💀.
-* DeaDvey, the most awesomest of all, did some pretty HARDCORE gramer checking. (and trolling, he wrote that, 33 commits of just readme changes ffs)
-* grialion, made a simple C implementation of `chvt` instead of insecurely relying on `kbd utils`'s command.
-* cerealexperiments\_, found a missing newline (had the guts to read the source code, crazy ik)
-* ChatGPT, in times of slow laptops where pages take ages to load, a single tab connected to a bunch of burning cloud GPUs feeding corporate hype is all you need to get quick answers for your questions, as long as you know how to filter AI crap ofc.
-* [My lack of gf](https://www.instagram.com/reel/C8sa3Gltmtq), can't imagine this project being possible if somebody actually cared about me daily.
+[killertofus](https://github.com/killertofus), [deadvey](https://github.com/deadvey), [grialion](https://github.com/grialion/), cerealexperiments\_, [antiz96](https://github.com/Antiz96), [rmntgx](https://github.com/rmntgx) and [more...](https://github.com/javalsai/lidm/graphs/contributors)
+
+With their big or small contributions, every commit has helped in its own way and encouraged me to keep putting my soul into this.
 
 ---
 
-🌟 Finally, consider starring this repo or... 🔪
+🌟 Finally, consider starring this repo [or...](https://www.reddit.com/r/github/comments/1l2mchg/is_this_allowed) 🔪
 
 ![star-history](https://api.star-history.com/svg?repos=javalsai/lidm&type=Date)

assets/github_scripts/build.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [ -z "$ARCH" ]; then
+    echo "\$ARCH not present" >&2
+    exit 1
+fi
+
+ERR=0
+# shellcheck disable=SC2034
+make -j"$(nproc)" "$@" 2> /tmp/stderr || ERR=$?
+
+BSIZE=$(stat --printf="%s" lidm)
+HSIZE=$(numfmt --to=iec-i<<<"$BSIZE")B
+WARNS=$(
+  sed -nE \
+      's/^([^ ]+\.[ch]):([0-9]+):([0-9]+): ([a-z]+): (.*)$/::\4 file=\1,line=\2,col=\3::\5/p' \
+      /tmp/stderr
+)
+WARNS_NUM=$({ [[ "$WARNS" == "" ]] && echo 0; } || wc -l <<<"$WARNS")
+
+echo "$WARNS"
+
+{
+    echo "# Build for $ARCH"
+    echo ""
+    if [ -s "/tmp/stderr" ]; then
+        echo "<details><summary><code>stderr</code></summary>"
+        echo ""
+        echo "\`\`\`"
+        cat "/tmp/stderr"
+        echo "\`\`\`"
+        echo ""
+        echo "</details>"
+    else
+        echo "*no \`stderr\` to show*"
+    fi
+    echo ""
+    echo "## Stats"
+    echo "* **Filesize:** $HSIZE ($BSIZE B)"
+    echo "* **Warnings & Errors:** $WARNS_NUM"
+} >> "$GITHUB_STEP_SUMMARY"
+
+if [ "$ERR" -ne 0 ]; then exit "$ERR"; fi
+
+mv lidm lidm-"$ARCH"
+
+echo "DESCR='$HSIZE, $WARNS_NUM warnings'" >> "$GITHUB_OUTPUT"

assets/man/lidm-config.5

@@ -10,76 +10,105 @@ lidm-config \- Configuration file syntax for lidm
 \fB\fI/etc/lidm.ini\fP
 
 
+.SH THEMES
+There are themes you can take as reference or simply copy in \fBthemes/\fP, no need to tackle the config yourself. It's good to give this a read however.
+
 .SH DESCRIPTION
-The \fI/etc/lidm.ini\fP file specifies all the configuration for lidm, including theme colors.
+The \fI/etc/lidm.ini\fP file specifies all the configuration for lidm, including theme colors. It's also possible to override this path with the \fILIDM_CONF\fP environment variable.
 
-The config parser is very primitive still, so the file only consists of \fBkey/value\fP pairs separated by \fB' = '\fP (yes, the surrounding spaces are necessary). It will also not warn if the config is invalid.
+The configuration aims to mimic a toml syntax but it's not 100% compatible with it. It's grouped in tables and takes key/value pairs parsed in different modes depndending on the type. Comments and empty lines are allowed as well as surrounding whitespace at the edges of the line and the equals sign.
 
-You can't escape characters with \fB'\\'\fP, but the program reads until the end of line, so you can put any raw bytes there.
+Values can be of these types:
+.TP
+\fBSTRING\fP
+Needs to be quoted with double quotes, allows basic character escaping with a backslash as well as bytes of the form \fB\\xHH\fP, please don't put a nullbyte.
+.TP
+\fBBOOL\fP
+Either \fBtrue\fP or \fBfalse\fP, no quoting.
+.TP
+\fBKEY\fP
+Represents a keyboard key, must be unquoted, possible values are enumerated in \fBinclude/keys.h\fP.
+.TP
+\fBSTRING_ARRAY\fP
+A list of strings, especified as a normal string, but reassigning to the same variable will append to that list.
 
 
 .SH KEYS
-Similar keys are grouped together to keep this as short as possible.
+In case anything here is outdated, all the config structure is defined in \fBinclude/config.h\fP, you can also find the default values there. This reference is separated by tables.
 
-.SS Colors
-All keys under this section are always wrapped inside ansi sequences (\fB\\x1b[...m\fP).
+.SS colors
+All these values are of type \fBSTRING\fP.
 .TP
-\fBcolors.bd, colors.fg, colors.err\fP
+\fBbd, fg, err\fP
 Background, foreground and error escape sequences. \fB'fg'\fP is also used as reset sequence, so it must remove effects used in other keys (such as bold, underline...) \fBWITHOUT\fP using the \fB'0'\fP sequence, as that would remove the background color.
 .TP
-\fBcolors.s_wayland, colors.s_xorg, colors.s_shell\fP
+\fBs_wayland, s_xorg, s_shell\fP
 Coloring for sessions of such types (Wayland, X.org, Shells)
 .TP
-.TP
-\fBcolors.e_hostname, colors.e_date, colors.e_box\fP
+\fBe_hostname, e_date, e_box\fP
 Coloring for the hostname, date and box elements.
 .TP
-\fBcolors.e_header\fP
+\fB.e_header\fP
 Coloring for heading elements (left column)
 .TP
-\fBcolors.e_user, colors.e_passwd, colors.e_badpasswd\fP
+\fBe_user, e_passwd, e_badpasswd\fP
 Coloring for the user element, password and bad padssword.
 .TP
-\fBcolors.e_key\fP
+\fBe_key\fP
 Coloring for key elements (eg: F1, F2, CTRL...)
 
-.SS
-Single characters used for some elements (can be longer than a character, but it will likely break UI)
+.SS chars
+Single characters used for some elements (could be longer than a character, but it will likely break UI code assumptions), these are also of type \fBSTRING\fP.
 .TP
-\fBchars.hb, chars.vb\fP
+\fBhb, vb\fP
 Character for the horizontal bar (hb) and vertical bar (vb).
 .TP
-\fBchars.ctl, chars.ctr, chars.cbl, chars.cbr\fP
+\fBctl, ctr, cbl, cbr\fP
 Characters for the corners of the box (ctl = corner top left, cbr = corner bottom right)
 
-.SS Functions
+.SS functions
+All these are of type \fBKEY\fP.
 .TP
-\fBfunctions.poweroff, functions.reboot, functions.refresh\fP
+\fBpoweroff, reboot, fido, refresh\fP
 Function key to use for such action.
 
-.SS String
-Strings to use for some elements.
+.SS strings
+Display strings to use for some elements.
 .TP
-\fBstrings.f_poweroff, strings.f_reboot, strings.f_refresh\fP
-Text displayed to name such functions.
+\fBf_poweroff, f_reboot, f_fido, f_refresh\fP
+Text displayed to name such functions at the bottom of the screen.
 .TP
-\fBstrings.e_user, strings.e_passwd\fP
+\fBe_user, e_passwd\fP
 Text to display for these element headers.
 .TP
-\fBstrings.s_wayland, strings.s_xorg, strings.s_shell\fP
+\fBs_wayland, s_xorg, s_shell\fP
 Text to display as the header for such sessions.
+.TP
+\fBopts_pre, opts_post\fP
+To be used for items with multiple options on the left and right sides \fB"< "\fP and \fB" >"\fP.
+.TP
+\fBellipsis\fP
+Ellipsis to be used in multiple parts such as overflowing hostnames.
 
-.SS Behavior
+.SS behavior
+Other miscellaneous behavior strings, of mixed types
 .TP
-\fBbehavior.include_defshell\fP
-"true"/"false" (invalid input defaults to false), if true, includes the user default shell as a session to launch
+\fBinclude_defshell\fP
+Type \fBBOOL\fP, specifies if the default user shel should be included as a session.
 .TP
-\fBbehavior.source\fP
-Specify paths to source on login, simple KEY=VALUE format with comments (#) or empty'ish lines, quoting or escape sequences not supported yet. It is NOT an array, but you rather assign to it multiple times.
+\fBsource, user_source\fP
+Types \fBSTRING_ARRAY\fP. Specify paths to source on login if they exist, simple KEY=VALUE format with comments (#) or empty'ish lines, quoting or escape sequences not supported yet. \fBuser_source\fP paths are relative to user home.
 .TP
-\fBbehavior.user_source\fP
-Same as \fIbehavior.source\fP but relative to user home (if present).
+\fBtimefmt\fP
+Specify the time format string to be displayed. Check \fBstrftime (3)\fP to know the possible formatting variables.
+.TP
+\fBrefresh_rate\fP
+Rate (in milliseconds) at which the UI should refresh, affects clock and resize behavior.
+.TP
+\fBbypass_shell_login\fP
+Type \fBBOOL\fP, lidm logins through a login shell (e.g. `bash`) in login mode (e.g. `arg0` being `-bash`) to load `/etc/profile/, `/etc/profile.d/` and more. If this option is enabled that's bypassed entirely.
 
 
 .SH "SEE ALSO"
 .BR lidm (1)
+.BR strftime (3)

assets/man/lidm.1

@@ -23,6 +23,9 @@ TTY to switch to, does not mean that it will run in it.
 .TP
 \fBLIDM_CONF\fP
 Specify the config to use other than \fI/etc/lidm.ini\fP
+.TP
+\fBLIDM_LOG\fP
+Optionally, a path to output misc logs and potential silent failures.
 
 .SH FILES
 .TP

assets/pkg/aur/.gitignore

@@ -1,4 +0,0 @@
-*/*
-!*/.gitignore
-!*/PKGBUILD
-!*/.SRCINFO

assets/pkg/aur/README.md

@@ -1,12 +0,0 @@
-# AUR Packages
-
-These files are just for reference, I'll manually edit and publish them, at least until I automate it with github actions (like updating version automatically on a release).
-
-There are three packages that follow standard conventions:
-
-* [`lidm`](https://aur.archlinux.org/packages/lidm): Builds latest release (manually updated per release basis)
-* [`lidm-bin`](https://aur.archlinux.org/packages/lidm-bin): Fetches latest release binary (compiled by GitHub Actions, also updated per release)
-* [`lidm-git`](https://aur.archlinux.org/packages/lidm-git): Fetches latest commit and builds it (should be updated automatically)
-
-> \[!IMPORTANT]
-> None of those packages include the service files. [You have to do this yourself](../../services/README.md).

assets/pkg/aur/lidm-bin/.SRCINFO

@@ -1,20 +0,0 @@
-pkgbase = lidm-bin
-	pkgdesc = A fully colorful customizable TUI display manager made in C. (release binary)
-	pkgver = 0.2.0
-	pkgrel = 1
-	url = https://github.com/javalsai/lidm
-	arch = x86_64
-	license = GPL
-	depends = pam
-	provides = lidm
-	conflicts = lidm
-	source = lidm::https://github.com/javalsai/lidm/releases/download/v0.2.0/lidm-amd64
-	source = default-theme.ini::https://raw.githubusercontent.com/javalsai/lidm/v0.2.0/themes/default.ini
-	source = lidm.1::https://raw.githubusercontent.com/javalsai/lidm/v0.2.0/assets/man/lidm.1
-	source = lidm-config.5::https://raw.githubusercontent.com/javalsai/lidm/v0.2.0/assets/man/lidm-config.5
-	sha256sums = 65b42f4f7acd970b167fe84d1fa75450b54e01a6f0edddb9d8dd487058a20850
-	sha256sums = 68662430a6d262b35cc54d9f0e164ed935b7f7f4497a87cc94946c558bbe8a91
-	sha256sums = a6807a55ff72ec5a5678583156b3efd0d367f0bcb79854094132771f0cb86bce
-	sha256sums = 3adaae60f79dff1cef2b2aba7dcea04196cd49816759ad36afb9f7331ac9c3e4
-
-pkgname = lidm-bin

assets/pkg/aur/lidm-bin/.gitignore

@@ -1,3 +0,0 @@
-*
-!PKGBUILD
-!.SRCINFO

assets/pkg/aur/lidm-bin/PKGBUILD

@@ -1,29 +0,0 @@
-# shellcheck disable=SC2034,SC2148,SC2128,SC2154,SC2164
-# Maintainer: javalsai <javalsai@proton.me>
-pkgname=lidm-bin
-pkgver=0.2.0
-pkgrel=1
-depends=('pam')
-pkgdesc="A fully colorful customizable TUI display manager made in C. (release binary)"
-arch=('x86_64')
-url="https://github.com/javalsai/lidm"
-license=('GPL')
-provides=('lidm')
-conflicts=('lidm')
-source=(
-    "lidm::$url/releases/download/v$pkgver/lidm-amd64"
-    "default-theme.ini::https://raw.githubusercontent.com/javalsai/lidm/v$pkgver/themes/default.ini"
-    "lidm.1::https://raw.githubusercontent.com/javalsai/lidm/v$pkgver/assets/man/lidm.1"
-    "lidm-config.5::https://raw.githubusercontent.com/javalsai/lidm/v$pkgver/assets/man/lidm-config.5"
-)
-sha256sums=('65b42f4f7acd970b167fe84d1fa75450b54e01a6f0edddb9d8dd487058a20850'
-            '68662430a6d262b35cc54d9f0e164ed935b7f7f4497a87cc94946c558bbe8a91'
-            'a6807a55ff72ec5a5678583156b3efd0d367f0bcb79854094132771f0cb86bce'
-            '3adaae60f79dff1cef2b2aba7dcea04196cd49816759ad36afb9f7331ac9c3e4')
-
-package() {
-    install -Dm755 lidm "${pkgdir}/usr/bin/lidm"
-    install -Dm644 default-theme.ini "${pkgdir}/etc/lidm.ini"
-    install -Dm644 lidm.1 "${pkgdir}/usr/share/man/man1/lidm.1"
-    install -Dm644 lidm-config.5 "${pkgdir}/usr/share/man/man5/lidm-config.5"
-}

assets/pkg/aur/lidm-git/.SRCINFO

@@ -1,17 +0,0 @@
-pkgbase = lidm-git
-	pkgdesc = A fully colorful customizable TUI display manager made in C. (last git commit)
-	pkgver = 0.1.0.r0.g8071694
-	pkgrel = 1
-	url = https://github.com/javalsai/lidm
-	arch = any
-	license = GPL
-	makedepends = git
-	makedepends = make
-	makedepends = gcc
-	depends = pam
-	provides = lidm
-	conflicts = lidm
-	source = lidm::git+https://github.com/javalsai/lidm
-	sha256sums = SKIP
-
-pkgname = lidm-git

assets/pkg/aur/lidm-git/.gitignore

@@ -1,3 +0,0 @@
-*
-!PKGBUILD
-!.SRCINFO

assets/pkg/aur/lidm-git/PKGBUILD

@@ -1,31 +0,0 @@
-# shellcheck disable=SC2034,SC2148,SC2128,SC2154,SC2164
-# Maintainer: javalsai <javalsai@proton.me>
-pkgname=lidm-git
-pkgver=0.2.0.r2.g255256b
-pkgrel=1
-depends=('pam')
-makedepends=('git' 'make' 'gcc')
-pkgdesc="A fully colorful customizable TUI display manager made in C. (last git commit)"
-arch=('any')
-url="https://github.com/javalsai/lidm"
-license=('GPL')
-provides=('lidm')
-conflicts=('lidm')
-source=("lidm::git+https://github.com/javalsai/lidm")
-sha256sums=('SKIP')
-
-pkgver() {
-    cd "lidm"
-    git describe --long --abbrev=7 --tags | \
-        sed 's/^v//;s/\([^-]*-g\)/r\1/;s/-/./g'
-}
-
-build() {
-    cd "lidm"
-    make CFLAGS="-O3"
-}
-
-package() {
-    cd "lidm"
-    make install DESTDIR="${pkgdir}"
-}

assets/pkg/aur/lidm/.SRCINFO

@@ -1,14 +0,0 @@
-pkgbase = lidm
-	pkgdesc = A fully colorful customizable TUI display manager made in C. (build latest tag)
-	pkgver = 0.2.0
-	pkgrel = 1
-	url = https://github.com/javalsai/lidm
-	arch = any
-	license = GPL
-	makedepends = git
-	makedepends = gcc
-	depends = pam
-	source = tarball.tar.gz::https://github.com/javalsai/lidm/archive/refs/tags/v0.2.0.tar.gz
-	sha256sums = 6d397cf75cafdcb95e5a2623d70f2e07bbb085a07b7c3b743caac06454ed7b16
-
-pkgname = lidm

assets/pkg/aur/lidm/.gitignore

@@ -1,3 +0,0 @@
-*
-!PKGBUILD
-!.SRCINFO

assets/pkg/aur/lidm/PKGBUILD

@@ -1,25 +0,0 @@
-# shellcheck disable=SC2034,SC2148,SC2128,SC2154,SC2164
-# Maintainer: javalsai <javalsai@proton.me>
-pkgname=lidm
-pkgver=0.2.0
-pkgrel=1
-depends=('pam')
-makedepends=('git' 'gcc')
-pkgdesc="A fully colorful customizable TUI display manager made in C. (build latest tag)"
-arch=('any')
-url="https://github.com/javalsai/lidm"
-license=('GPL')
-source=("tarball.tar.gz::https://github.com/javalsai/lidm/archive/refs/tags/v$pkgver.tar.gz")
-sha256sums=('6d397cf75cafdcb95e5a2623d70f2e07bbb085a07b7c3b743caac06454ed7b16')
-
-build() {
-    tar -xzf "tarball.tar.gz"
-    cd "lidm-$pkgver"
-
-    make CFLAGS="-O3"
-}
-
-package() {
-    cd "lidm-$pkgver"
-    make install DESTDIR="${pkgdir}"
-}

assets/pkg/aur/make-srcinfo.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-MYSELF=$(realpath "$0")
-MYDIR=$(dirname "$MYSELF")
-
-for pkg in "$MYDIR"/*/; do
-    cd "$pkg"
-    printf "\x1b[1mEntering '%s'\x1b[0m\n" "$pkg"
-    makepkg --printsrcinfo | tee .SRCINFO
-    echo
-done

assets/pkg/aur/test-makepkg.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-MYSELF=$(realpath "$0")
-MYDIR=$(dirname "$MYSELF")
-
-for pkg in "$MYDIR"/*/; do
-    cd "$pkg"
-    printf "\x1b[1mEntering '%s'\x1b[0m\n" "$pkg"
-
-    rm -rf ./*.{gz,zst} src pkg
-    makepkg -f .
-
-    echo
-done

assets/pkg/aur/update-pkgs.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-MYSELF=$(realpath "$0")
-MYDIR=$(dirname "$MYSELF")
-
-if [ -z "$1" ]; then
-    printf "\x1b[1;31mERR: No version to update provided\x1b[0m\n" >&2
-    exit 1;
-fi
-version="$1"
-printf "\x1b[34mINF: Using '%s' version\x1b[0m\n" "$version"
-
-for pkg in "$MYDIR"/lidm{,-bin}/; do
-    cd "$pkg"
-    printf "\x1b[1mEntering '%s'\x1b[0m\n" "$pkg"
-    sed -i "s/pkgver=.*/pkgver=$1/" PKGBUILD
-    sed -i "s/pkgrel=.*/pkgrel=1/" PKGBUILD
-
-    grep 'source = ' <.SRCINFO | awk -F'= |::' '{print $2}' | \
-    while read -r srcfile; do
-        printf "\x1b[31mDeleting '%s'\x1b[0m\n" "$srcfile"
-        rm -f "$srcfile"
-    done
-
-    updpkgsums
-    makepkg --printsrcinfo | tee .SRCINFO
-    echo
-done

assets/pkg/nix/get-cfg-file.nix

@@ -0,0 +1,23 @@
+{
+  cfg,
+  src,
+  lib,
+  ...
+}:
+let
+  maker = import ./make-cfg.nix {
+    inherit lib;
+    keys-h-file = builtins.readFile "${src}/include/keys.h";
+  };
+in
+{
+  inherit maker;
+  file = builtins.toFile "lidm.conf" (
+    if builtins.isString cfg then
+      builtins.readFile "${src}/themes/${cfg}.ini"
+    else if builtins.isAttrs cfg then
+      maker.make cfg
+    else
+      builtins.throw "invalid cfg type, expected str or attrs"
+  );
+}

assets/pkg/nix/lidm.nix

@@ -0,0 +1,50 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}:
+let
+  get-cfg =
+    if config.cfg != null then
+      import ./get-cfg-file.nix {
+        inherit lib;
+        inherit (config) cfg src;
+      }
+    else
+      null;
+  cfg-file = get-cfg.file;
+  maker = get-cfg.maker;
+in
+pkgs.stdenv.mkDerivation rec {
+  pname = "lidm";
+  version = config.version;
+  src = config.src;
+
+  nativeBuildInputs = with pkgs; [
+    gcc
+    gnumake
+    linux-pam
+  ];
+
+  makeFlags =
+    [
+      "DESTDIR=$(out)"
+      "PREFIX="
+    ]
+    ++ lib.optional (
+      config.xsessions != null
+    ) "CPPFLAGS+=-DSESSIONS_XSESSIONS=\\\"${config.xsessions}\\\""
+    ++ lib.optional (
+      config.wayland-sessions != null
+    ) "CPPFLAGS+=-DSESSIONS_WAYLAND=\\\"${config.wayland-sessions}\\\""
+    ++ lib.optional (cfg-file != null) "CPPFLAGS+=-DLIDM_CONF_PATH=\\\"${cfg-file}\\\"";
+
+  fixupPhase = ''
+    rm -rf $out/etc
+  '';
+
+  passthru = {
+    keysEnum = maker.keys-enum;
+  };
+}

assets/pkg/nix/make-cfg.nix

@@ -0,0 +1,73 @@
+{ lib, keys-h-file }:
+
+let
+  double-match-to-nameval = dmatch: {
+    name = builtins.elemAt dmatch 0;
+    value = builtins.elemAt dmatch 1;
+  };
+
+  keys-enum =
+    let
+      key-names = builtins.replaceStrings [ "\n" " " ] [ "" "" ] (
+        builtins.elemAt (builtins.match ".*KEY_NAMES\\[][[:blank:]]*=[[:blank:]]*\\{([^}]*)}.*" keys-h-file) 0
+      );
+
+      keys-2d-list = builtins.map (builtins.match "\\[(.*)]=\"(.*)\"") (
+        builtins.filter (s: builtins.isString s && s != "") (builtins.split "," key-names)
+      );
+
+    in
+    builtins.listToAttrs (
+      builtins.map (
+        k:
+        k
+        // {
+          value = {
+            __enum_key = k.value;
+          };
+        }
+      ) (builtins.map double-match-to-nameval keys-2d-list)
+    );
+in
+{
+  inherit keys-enum;
+  make =
+    let
+      name-val-to-attrs = (name: value: { inherit name value; });
+      map-attrs = attrset: fn: lib.map fn (lib.attrsets.mapAttrsToList name-val-to-attrs attrset);
+
+      try-foldl' =
+        op: nul: list:
+        if (builtins.length list) == 0 then "" else builtins.foldl' op nul list;
+      concat-with = sepr: list: try-foldl' (x: y: if x == null then y else x + sepr + y) null list;
+
+      ser-bool = bool: if bool then "true" else "false";
+      ser-str = str: "\"${builtins.replaceStrings [ "\n" "\"" ] [ "\\n" "\\\"" ] str}\"";
+      ser-kvs =
+        { name, value }:
+        if builtins.isList value then
+          concat-with "\n" (builtins.map (value: ser-kvs { inherit name value; }) value)
+        else
+          "${name} = ${
+            if builtins.isString value then
+              ser-str value
+            else if builtins.isInt value then
+              builtins.toString value
+            else if builtins.isBool value then
+              ser-bool value
+            else if builtins.isAttrs value then
+              value.__enum_key
+            else
+              builtins.throw "type not supported"
+          }";
+
+      ser-table =
+        table':
+        let
+          tname = table'.name;
+          table = table'.value;
+        in
+        "[${tname}]\n" + (concat-with "\n" (map-attrs table ser-kvs));
+    in
+    cfg: concat-with "\n\n" (map-attrs cfg ser-table);
+}

assets/pkg/nix/module.nix

@@ -0,0 +1,73 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+
+let
+  cfg = config.services.lidm;
+
+  dmcfg = config.services.displayManager;
+  desktops = dmcfg.sessionData.desktops;
+
+  version = "2.0.0";
+  lidmPkg = pkgs.callPackage ./lidm.nix {
+    inherit pkgs;
+    config = {
+      inherit version lib;
+      cfg = cfg.config;
+      src = pkgs.fetchFromGitHub {
+        owner = "javalsai";
+        repo = "lidm";
+        rev = "v${version}";
+        sha256 = "sha256-dI1OGndbT6wFAhuGmsPZPqLFvtPREfO/3HqhmlSMpN4=";
+      };
+
+      xsessions = "${desktops}/share/xsessions";
+      wayland-sessions = "${desktops}/share/wayland-sessions";
+    };
+  };
+in
+{
+  options = {
+    lidm.keysEnum = lib.mkOption {
+      type = with lib.types; attrs;
+      default = lidm.passthru.keysEnum;
+      readOnly = true;
+      description = "Keys enum constants";
+    };
+    services.lidm.config = lib.mkOption {
+      type =
+        with lib.types;
+        oneOf [
+          str
+          attrs
+        ];
+      default = { };
+      description = "Config options for lidm | Either attr tree or name of bundled themes";
+    };
+  };
+  config = {
+    services.displayManager.defaultSession = "lidm";
+
+    systemd.services.lidm = {
+      description = "TUI display manager";
+      aliases = [ "display-manager.service" ];
+      after = [
+        "systemd-user-sessions.service"
+        "plymouth-quit-wait.service"
+      ];
+      serviceConfig = {
+        Type = "idle";
+        ExecStart = "${lidmPkg}/bin/lidm 7";
+        StandardInput = "tty";
+        StandardOutput = "tty";
+        StandardError = "tty";
+        TTYPath = "/dev/tty7";
+        TTYReset = "yes";
+        TTYVHangup = "yes";
+      };
+    };
+  };
+}

assets/services/README.md

@@ -2,38 +2,44 @@
 
 This folder contains the files necessary to set up lidm on start up for the supported init systems, all of them are configured for tty7.
 
+If you're using lidm from a packaged source, this should be included with the package. Only read this for manual installations, if you are packaging or if your package exceptionally doesn't include them.
+
 If you don't know what a init system is, you're certainly using `systemd`.
 
-There's make scripts to automatically copy the service files to the proper locations, you just have to run `make install-service-$INIT`. `make install-service` will attempt to detect the init system in use and install for it.
+There's make scripts to automatically copy the service files to the proper locations, you just have to run `make install-service-$INIT` (or `make install-service-$INIT-etc`). `make install-service` will attempt to detect the init system in use and install for it.
 
 The manual steps for installation are:
 
 ## Systemd
 
-* Copy `systemd.service` to `/etc/systemd/system/lidm.service`
-* To enable it you can run `systemctl enable lidm`
+- Copy `systemd.service` to `/usr/local/lib/systemd/system/lidm.service` (if the directory doesn't exist, create it first) or `/usr/lib/systemd/system/lidm.service` (if you wish to install along your system files).
+- To enable it you can run `systemctl enable lidm`
 
 ## Dinit
 
-* Copy `dinit` to `/etc/dinit.d/lidm`
-* To enable it, run `dinitctl enable lidm`
+- Copy `dinit` to `/etc/dinit.d/lidm`
+- To enable it, run `dinitctl enable lidm`
 
 ## Runit
 
-* Copy `runit/` to `/etc/runit/sv/lidm/`
-* Add the service with `ln -s /etc/runit/sv/lidm /run/runit/service`
-* And to enable it `sv enable lidm`
+Your runit service path can be either `/etc/runit/sv` or `/etc/sv`.
+
+- Copy `runit/` to `runit-path/lidm/`
+- Add the service with `ln -s runit-path/lidm /run/runit/service`
+- And to enable it `sv enable lidm`
 
 ## OpenRC
 
-* Copy `openrc` to `/etc/init.d/lidm`
-* Enable the service with `rc-update add lidm`
+- Copy `openrc` to `/etc/init.d/lidm`
+- Enable the service with `rc-update add lidm`
 
 ## S6
 
-* Copy `s6/` to `/etc/s6/sv/lidm/`
-* Add the service with `s6-service add default lidm`
-* Reload the database with `s6-db-reload` (you might have to run this every time the service file changes)
+Your S6 service path can be either `/etc/s6/sv` or `/etc/sv`.
 
-> \[!WARNING]
+- Copy `s6/` to `s6-path/lidm/`
+- Add the service with `s6-service add default lidm`
+- Reload the database with `s6-db-reload` (you might have to run this every time the service file changes)
+
+> [!WARNING]
 > Make sure to disable any other service that might run on tty7, such us lightdm or most display managers out there.

assets/services/systemd.service

@@ -5,12 +5,13 @@ After=systemd-user-sessions.service plymouth-quit-wait.service
 [Service]
 Type=idle
 ExecStart=/usr/bin/lidm 7
-StandardError=journal
 StandardInput=tty
 StandardOutput=tty
+StandardError=tty
 TTYPath=/dev/tty7
 TTYReset=yes
 TTYVHangup=yes
+Restart=always
 
 [Install]
 Alias=display-manager.service

debug/README.md

@@ -0,0 +1,3 @@
+# Debug
+
+This folder contains debug utils like gdb scripts. They are not guaranteed to work but can ease some tasks when debugging.

debug/debug.gdb

@@ -0,0 +1,59 @@
+# this just meant to run in another term, is probably better to attach to another already running window
+set inferior-tty /dev/pts/7
+set pagination off
+
+break *(read_press + 62)
+define fake_read
+    set *((char*) $rsi) = $al
+    set $rax = 1
+    jump *(read_press + 67)
+end
+
+break *(read_press + 108)
+define fake_magic_cont
+    set $eax = 1
+    jump *(read_press + 113)
+end
+define fake_magic_end
+    set $eax = 0
+    jump *(read_press + 113)
+end
+
+run
+set $al = 0x1b
+fake_read
+fake_magic_cont
+set $al = '['
+fake_read
+fake_magic_cont
+set $al = 'D'
+fake_read
+fake_magic_end
+
+set $al = 'p'
+fake_read
+fake_magic_end
+
+set $al = 'a'
+fake_read
+fake_magic_end
+
+set $al = 's'
+fake_read
+fake_magic_end
+
+set $al = 's'
+fake_read
+fake_magic_end
+
+set $al = 'w'
+fake_read
+fake_magic_end
+
+set $al = 'd'
+fake_read
+fake_magic_end
+
+set $al = '\n'
+fake_read
+fake_magic_end

debug/lidm-debug

@@ -0,0 +1,9 @@
+type            = process
+command         = /bin/sh -c "LIDM_LOG=/tmp/lidm.debug /sbin/agetty tty8 linux-c -n -l /usr/local/bin/lidm -o 8"
+restart         = true
+depends-on      = login.target
+termsignal      = HUP
+smooth-recovery = true
+inittab-id      = 8
+inittab-line    = tty8
+log-type        = buffer

docs/CONTRIBUTING.md

@@ -2,29 +2,35 @@
 
 Contributions are welcome! Here's how you can help:
 
-- [Contributing code](#code)
-- [Reporting issues](#issues)
+- [Contributing](#contributing)
+  - [Code](#code)
+  - [Issues](#issues)
+  - [Other](#other)
 
 ## Code
 
-For small fixes or incremental improvements simply fork the repo and follow the process below. For larger changes submit an [RFC:](RFC.md)
+For small fixes or incremental improvements simply fork the repo and follow the process below.
+
 1. [Fork](https://help.github.com/articles/fork-a-repo/) the repository and [clone](https://help.github.com/articles/cloning-a-repository/) your fork.
 
-2. Start coding!
+2. Start coding! (it might be helpful to read a [quide on the project structure and conventions](./structure.md) before this)
    - Configure clangd LSP by generating `compile_commands.json` (e.g. `bear -- make` or `compiledb make`)
    - Implement your feature.
    - Check your code works as expected.
-    - Run the code formatter: `clang-format -i $(git ls-files "*.cpp" "*.h")`
+   - Run the code formatter: `clang-format -i $(git ls-files "*.c" "*.h")`.
+   - Run the code linter: `clang-tidy -p . $(git ls-files "*.c" "*.h")`. Some checks are pretty pedantic, feel free to ignore or debate some of the rules.
+   - If you prefer, you can run `make pre-commit` to run several code style checks like the above along a few extra stuff (shellcheck, spellcheck, prettier, etc).
 
 3. Commit your changes to a new branch (not `master`, one change per branch) and push it:
    - Commit messages should:
-        - Header line: explain the commit in one line (use the imperative)
+     - Header line: explain the commit in one line (use the imperative) ("feat" for features, "fix", "style", "chore", "docs", etc)
      - Be descriptive.
-        - Have a first line with less than *80 characters* and have a second line that is *empty* if you want to add a description.
+     - Don't make the title too long and add commit descriptions if you think the changes need it.
+     - e.g. "feat: add support for X", "fix(config): config parser segfaulting", "docs(typo): fix a typo in README.md"
 
 4. Once you are happy with your changes, submit a pull request.
    - Open the pull request.
-     - Add a short description explaining briefly what you've done (or if it's a work-in-progress - what you need to do)
+   - Add a short description explaining what you've done (or if it's a work-in-progress - what you need to do)
 
 ## Issues
 
@@ -33,7 +39,10 @@ For small fixes or incremental improvements simply fork the repo and follow the
    - Screenshots.
    - Ways to reproduce the issue.
    - Your lidm version.
-     - Your platform (e.g. arch linux or Ubuntu 15.04 x64)
+   - Your platform (e.g. arch linux or Ubuntu 15.04 x64) and init system if you know.
 
 After reporting you should aim to answer questions or clarifications as this helps pinpoint the cause of the issue.
 
+## Other
+
+If you are unsure what category your contribution falls under, feel free to [open an issue](https://github.com//javalsai/lidm/issues/new) or [a discussion](https://github.com//javalsai/lidm/discussions/new) to talk about it.

docs/INSTALL.md

@@ -0,0 +1,175 @@
+# Table of Contents
+
+- [Packages](#packages)
+  - [Void Linux](#void-linux)
+  - [Fedora](#fedora)
+  - [AUR](#aur)
+  - [Nix Flake](#nix-flake)
+  - [Nix Module](#nix-module)
+- [Installing from Source](#installing-from-source)
+
+# Packages
+
+Lidm relies on its community to package lidm for distributions and make the installation easier for everyone. Please raise any issues on the packages themselves and not the source repository.
+
+If you packaged lidm for any distribution not listed here or keep your own version of an inactive package, feel free to contact me to be added here. (could be a GitHub discussion or an email if you don't use GitHub)
+
+These packages just install lidm, once installed you have to enable it. It depends on your init system, but if you're using systemd (most likely), first find your currently active display manager (if any, examples are `sddm`, `gdm`, `ly`) and disable it:
+
+```sh
+systemctl disable <display manager name here>
+```
+
+And then enable lidm:
+
+```sh
+systemctl enable lidm
+```
+
+Lidm now should show on the next boot!
+
+If you are on a TTY and don't wish to reboot, you should be able to use `--now` with both commands. It's likely to kill your current desktop environment if it was launched from it.
+
+## Void Linux
+
+Lidm can be installed from the official Void Linux packages:
+
+```sh
+xbps-install lidm
+```
+
+To enable the service that starts on boot:
+
+```sh
+ln -s /etc/sv/lidm /var/service/
+```
+
+It is recommended to disable any other display managers that are still enabled:
+
+```sh
+touch /etc/sv/lightdm/down # replace lightdm with your previous display manager (e.g., sddm, gdm)
+```
+
+## Fedora
+
+Thanks to @KernelFreeze there's a COPR repo available at <https://copr.fedorainfracloud.org/coprs/celestelove/lidm/> to install lidm. (<https://github.com/javalsai/lidm/discussions/92>)
+
+## AUR
+
+There are several [AUR packages](https://aur.archlinux.org/packages?K=lidm&SeB=n) for most things. You only need to install one of the following:
+
+- `lidm`
+- `lidm-bin`
+- `lidm-git`
+
+Each of those depend on `lidm-service` which is provided by `lidm-systemd` and `lidm-dinit` (you'll have to pick one). I maintain both but I'm open to anyone that actually uses systemd to take the first one.
+
+There's packagers needed for openrc, s6 and runit. If you know how to make AUR packages, feel free to take any of those if you use each init system.
+
+## Nix Flake
+
+You can install by doing
+
+```sh
+nix profile install github:javalsai/lidm
+```
+
+or try it out without installing by:
+
+```sh
+nix run github:javalsai/lidm
+```
+
+## Nix Module
+
+<details>
+<summary>Sidenote</summary>
+
+The nix module lacks on several aspects, if you know much about nix and know
+how to improve this package, feel free to open an issue or a PR to help. The
+nix package maintainer position is open too.
+
+</details>
+
+Lidm includes a nix module in `assets/pkg/nix/module.nix` that you can add
+(along the included nix files) and import in your `configuration.nix`.
+
+Once imported you'll need to add:
+
+```nix
+services.displayManager.enable = true;
+systemd.services.lidm.enable = true;
+```
+
+Optionally, you can configure it setting `services.lidm.config`. You can either
+pass:
+
+- A string to copy the config from a theme in `themes/` with said name
+  (**name**, e.g `"cherry"`).
+- An attribute tree with the same names as the config file, e.g:
+
+```nix
+with config.lidm.keysEnum; {
+    strings = {
+        f_poweroff = "custom_poweroff";
+    };
+
+    behavior = {
+        include_defshell = true;
+        source = [
+            "path1"
+            "path2"
+        ];
+    };
+
+    functions = { poweroff = F1; };
+
+    # etc...
+};
+```
+
+> _it's not necessary to cover all keys and anything can be put there, even if it's not valid config_
+
+# Installing from Source
+
+Firstly, you'll need to build the package, this also includes man pages, default config, themes and other files you might need.
+
+To build it you only need to have some basic packages (should come pre-installed in almost all distros): `make`, `gcc` or another `gcc`ish compiler, and libpam headers. If it builds, it surely works anyways.
+
+```sh
+git clone https://github.com/javalsai/lidm.git
+cd lidm
+make # 👍
+```
+
+> [!NOTE]
+> There are pre-built binaries on the [releases tab](https://github.com/javalsai/lidm/releases) too.
+
+Then you can install the files onto your filesystem with:
+
+```sh
+make install
+```
+
+This will install mostly into `/usr/local` by default, this path is mostly unused nowadays (systemd can load services from it but man usually doesn't find manual pages in there) and could feel like lidm didn't install at all. You can add `PREFIX=/usr` to install along the rest of your system packages if you wish.
+
+And additionally, to install service files (start-up behavior). <sup>[more docs](../assets/services/README.md)</sup>
+
+```sh
+# automatically detects your init system
+# and install service file (for tty7)
+make install-service
+
+# or if you don't like autodetection
+make install-service-systemd # systemd
+make install-service-dinit # dinit
+make install-service-runit # runit (/etc/sv)
+make install-service-runit-etc # runit (/etc/runit/sv)
+make install-service-openrc # openrc
+make install-service-s6 # s6 (/etc/sv)
+make install-service-s6-etc # s6 (/etc/s6/sv)
+
+#  For runit and s6, some distros (e.g. Artix) like to put it in /etc/<init>/sv
+# to better isolate their packages while other distros (e.g. Void) just put it
+# in /etc/sv
+```

docs/PACKAGERS.md

@@ -0,0 +1,78 @@
+This is a guide listing all possible options packagers have to tweak behavior of lidm and the extra stuff to package.
+
+# Components
+
+If you want to package lidm for a distribution you have to package the binary and:
+
+- Man pages ([`../assets/man/`](../assets/man/))
+- Service files ([`../assets/services/`](../assets/services/))
+- PAM (see [#preprocessor-defines](#preprocessor-defines))
+- And optionally you can include some default themes in `/usr` ([`../themes/`](../themes/))
+
+# Preprocessor Defines
+
+Most of the behavior that can be tweaked using preprocessor `#define`s, to include some simply add `CPPFLAGS+='-D{{name}}={{value}}'` to your `make` command. e.g:
+
+```sh
+make \
+    CPPFLAGS+='-DSESSIONS_XSESSIONS=\"/var/empty\"' \
+    CPPFLAGS+='-DSESSIONS_WAYLAND=\"/var/empty\"'
+```
+
+The list of possible `#define`s is:
+
+| Name                       | Default                               | Description                                                                | Env Override?            |
+| -------------------------- | ------------------------------------- | -------------------------------------------------------------------------- | ------------------------ |
+| `PAM_SERVICE_FALLBACK`     | `"login"`                             | Name of the default PAM module to use. Defaults to the distro's `"login"`. | Yes (`LIDM_PAM_SERVICE`) |
+| `SESSIONS_XSESSIONS`       | `"/usr/share/xsessions"`              |                                                                            | No                       |
+| `SESSIONS_XSESSIONS_LOCAL` | `"/usr/local/share/xsessions"`        |                                                                            | No                       |
+| `SESSIONS_WAYLAND`         | `"/usr/share/wayland-sessions"`       |                                                                            | No                       |
+| `SESSIONS_WAYLAND_LOCAL`   | `"/usr/local/share/wayland-sessions"` |                                                                            | No                       |
+| `LIDM_CONF_PATH`           | `"/etc/lidm.ini"`                     | Path of the default configuration.                                         | Yes (`LIDM_CONF`)        |
+| `LOGIN_SHELL`              | `"bash"`                              | Login shell name.                                                          | No                       |
+
+# Other Build Settings
+
+## Compiler
+
+Lidm attempts to support being built by `gcc` and `clang` with preference over the first. However, if you wish to take advantage of LLVM's optimizations over GNU's you can change the compiler with `make CC=clang` or try any other compiler.
+
+## Compiler Flags
+
+Compiler flags should be passed with `CFLAGS`, its `-O3 -Wall` by default so adding anything will overwrite this.
+
+## Build Metadata
+
+`lidm -v` outputs some information about the build version, this can be weaked with `INFO_GIT_REV` and `INFO_BUILD_TS`, by default they are:
+
+```make
+INFO_GIT_REV?=$$(git describe --long --tags --always || echo '?')
+INFO_BUILD_TS?=$$(date +%s)
+```
+
+But this can be changed by just passing those env variables, for example, in the case git is not applicable in the build environment of the package.
+
+## Target Directory
+
+`DESTDIR` can be used to for installation recipes to install on alternative root directories. Along with `PREFIX` (defaults to `/usr/local`, packaging this you'll probably want to make it `/usr`) for systems which don't use the common `/usr` structure. e.g. `make install DESTDIR=$out PREFIX=`
+
+`/etc` is sometimes in that `PREFIX` and sometimes not, be careful.
+
+```txt
+$ fd -t f . --base-directory $out
+bin/lidm
+etc/lidm.ini
+share/man/man1/lidm.1
+share/man/man5/lidm-config.5
+```
+
+# Build Recipes for Packaging
+
+To ease most of the installation process there's several `make` recipes to install man pages and service files, I encpurage you to check their source yourself, but:
+
+- `make` / `make lidm`: Builds the app binary.
+- `make install`: Attempts to install the binary, place a default config file in `/etc/lidm.ini` and install the man pages.
+- `make install-service-(systemd|dinit|runit|openrc|s6)(|-etc)`: Just check the source, service files for different init systems and `-etc` variants for alternative paths. You might need `FORCE=1` in the environment if you are packaging for other init system or scripting.
+- `make print-version`: Outputs the current version in the `Makefile` for scripts that might want to extract that info.
+
+You can choose to use these packages or create your own service files / etc. There's are merely suggestions on what to use.

docs/structure.md

@@ -0,0 +1,89 @@
+# Introduction
+
+This file aims to explain the basic project structure and some code conventions
+and patterns used for contributors. If you plan on contributing a considerable
+amount of code, please read this thoroughly to keep the project behavior
+consistent.
+
+Even if your changes are not very related to the code, this guide can help to
+understand how they can be related to the rest of the project and what side
+changes it can require.
+
+# Structure
+
+The file structure is very simple, you have `.c` files in `src/` with their
+header `.h` counterpart in `include/`, they are listed in the `Makefile` and
+built all together on the same layer.
+
+Each file contains functions aimed to provide some specialized behavior, they
+tend to follow a common prefix (like `vec_` for vector functions) to avoid name
+collisions with themselves.
+
+## Important Files
+
+The `main.c` of course provides the entry point of the program, then each file
+has special functionality, but a special one is `util.h`, is linked with almost
+every file and provides some shared utilities to dealing with UTF-8, dynamic
+Vectors and other stuff.
+
+`log.c` is also an important file as it provides logging utilities for
+debugging, there's no need to deal with it's initialization, it behaves just
+like standard printing utilities but integrated into the configured logfile.
+
+# Debugging
+
+The log module can be easily used by just setting up the `LIDM_LOG`
+environmental variable to the logs output path.
+
+# Header Files
+
+But what if you create a new file? It's important that the definitions are only
+evaluated once by the compiler, even if they are included by several files. For
+this, you can use this simple trick (assume this is for a file named
+`mylib.h`):
+
+```h
+#ifndef MYLIBH_
+#define MYLIBH_
+
+// library contents
+// ...
+
+#endif
+```
+
+It's also a good idea to include brief comments above functions if it's not
+evident what they do and name all parameters.
+
+# Nullability Checks
+
+Nullability checks are not really enforced in the code but it's never a bad
+idea to include them, however, `gcc` doesn't support them under certain
+conditions.
+
+For this you can use `NULLABLE`, `NNULLABLE` and `UNULLABLE` macros from
+`"macros.h"` to conditionally include `_Nullable`, `_Nonnull` and
+`_Null-unspecified` respectively.
+
+# Handling & Support
+
+Every function should properly handle allocation failures (avoid them with
+stack arrays where possible), support UTF-8 strings, use the `log` module
+instead of printing to stdout (messing with the state of the ui) and free all
+lost memory (if it can be lost before reaching the final stage where it execs
+another program, I'm fine with not freeing memory still reachable at the end).
+
+# Code format, style and linting
+
+Be reasonable and follow `clang-format` and `clang-tidy` rules. `clang-tidy`
+can be quite pedantic with the current primitive rules, so feel free to use
+`LINTIGNORE` or discuss if said rule should be enforced in first place.
+
+Also avoid grammar typos and for shell scripts use `shellcheck`, you can run
+this checks with `make pre-commit` if you have the required tools.
+
+# Documentation
+
+Please, also check if there's documentation related to the feature/changes you
+are implementing, could be on markdown or manpages, if there is and you have
+some spare time, it's really helpful to update it; although not enforced.

docs/yubikey.md

@@ -0,0 +1,30 @@
+# Yubikeys
+
+Quick reference explaining how yubikeys work for now.
+
+# Enable
+
+Yubikeys are disabled by default, to enable them activate a keybinding for it (`[functions] fido`) in the config file.
+
+Note that pressing this configured keybinding has no difference from trying to log in with an empty password, there's virtually no difference.
+
+`pam_u2f` must be configured with a registered key (`pamu2fcfg`).
+
+# Extra
+
+All my yubikey knowledge comes from the [pr that implemented this](https://github.com/javalsai/lidm/pull/89), please refer to it for extra details. Contributions to this documentation are welcome (explaining more in detail, potential issues... really anything that improves this).
+
+Allegedly this pam module configuration should work:
+
+```pam
+#%PAM-1.0
+
+auth sufficient pam_u2f.so cue
+auth       requisite    pam_nologin.so
+auth       include      system-local-login
+account    include      system-local-login
+session    include      system-local-login
+password   include      system-local-login
+```
+
+Also, I recommend giving the [arch wiki](https://wiki.archlinux.org/title/YubiKey) a read anyways.

flake.lock

@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1724224976,
-        "narHash": "sha256-Z/ELQhrSd7bMzTO8r7NZgi9g5emh+aRKoCdaAv5fiO0=",
+        "lastModified": 1751637120,
+        "narHash": "sha256-xVNy/XopSfIG9c46nRmPaKfH1Gn/56vQ8++xWA8itO4=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "c374d94f1536013ca8e92341b540eba4c22f9c62",
+        "rev": "5c724ed1388e53cc231ed98330a60eb2f7be4be3",
         "type": "github"
       },
       "original": {

flake.nix

@@ -1,46 +1,46 @@
 {
+  description = "A ✨fully✨ colorful customizable TUI display manager made in C for simplicity.";
+
   inputs = {
     flake-utils.url = "github:numtide/flake-utils";
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
   };
+
   outputs =
-    { flake-utils, nixpkgs, ... }:
+    {
+      flake-utils,
+      nixpkgs,
+      self,
+    }:
     flake-utils.lib.eachDefaultSystem (
       system:
       let
         pkgs = import nixpkgs { inherit system; };
 
         name = "lidm";
-        version = "0.0.2";
-
-        lidm = (
-          pkgs.stdenv.mkDerivation {
-            pname = name;
-            version = version;
+        version = builtins.elemAt (builtins.match "VERSION[[:blank:]]*=[[:space:]]*([^\n]*)\n.*" (builtins.readFile ./Makefile)) 0;
 
+        lidm = pkgs.callPackage assets/pkg/nix/lidm.nix {
+          inherit pkgs;
+          lib = pkgs.lib;
+          config = {
+            inherit version;
             src = ./.;
-
-            nativeBuildInputs = with pkgs; [
-              gcc
-              gnumake
-              linux-pam
-            ];
-
-            makeFlags = [
-              "DESTDIR=$(out)"
-              "PREFIX="
-            ];
-
-            fixupPhase = ''
-              rm -rf $out/etc
-            '';
-          }
-        );
+            xsessions = null;
+            wayland-sessions = null;
+            cfg = null;
+            # cfg = "cherry";
+          };
+        };
       in
       rec {
         defaultApp = flake-utils.lib.mkApp { drv = defaultPackage; };
         defaultPackage = lidm;
         devShell = pkgs.mkShell { buildInputs = lidm.nativeBuildInputs ++ [ pkgs.clang-tools ]; };
+        formatter = nixpkgs.legacyPackages.${system}.nixfmt-tree;
       }
-    );
+    )
+    // {
+      nixosModules.lidm = assets/pkg/nix/module.nix;
+    };
 }

include/auth.h

@@ -1,11 +1,13 @@
-#ifndef _AUTHH_
-#define _AUTHH_
+#ifndef AUTHH_
+#define AUTHH_
 
 #include <stdbool.h>
 
 #include "config.h"
 #include "sessions.h"
 
-bool launch(char *user, char *passwd, struct session session, void (*cb)(void), struct behavior* behavior);
+bool launch(char* NNULLABLE user, char* NNULLABLE passwd,
+            struct session session, void (*NULLABLE cb)(void),
+            struct config* NNULLABLE config);
 
 #endif

include/chvt.h

@@ -1,5 +1,5 @@
-#ifndef _CHVTH_
-#define _CHVTH_
+#ifndef CHVTH_
+#define CHVTH_
 
 #include <fcntl.h>
 #include <linux/kd.h>

include/config.h

@@ -1,82 +1,170 @@
-#ifndef _CONFIGH_
-#define _CONFIGH_
+#ifndef CONFIGH_
+#define CONFIGH_
 
 #include <stdbool.h>
-#include <stdio.h>
+#include <stddef.h>
 
 #include "keys.h"
-#include "util.h"
+#include "macros.h"
+#include "util/vec.h"
+
+enum IntrospectionType {
+  STRING,
+  BOOL,
+  NUMBER,
+  KEY,
+  STRING_ARRAY,
+};
+static const char* NNULLABLE const INTROS_TYS_NAMES[] = {
+    [STRING] = "STRING",
+    [BOOL] = "BOOL",
+    [NUMBER] = "NUMBER",
+    [KEY] = "KEY",
+    [STRING_ARRAY] = "STRING_ARRAY",
+};
+
+struct introspection_item {
+  char* NNULLABLE name;
+  size_t offset;
+  enum IntrospectionType typ;
+};
+
+#define INTROS_ITEM(key, table, ty)   \
+  {                                   \
+      .name = #key,                   \
+      .offset = offsetof(table, key), \
+      .typ = (ty),                    \
+  }
+
+#define STRUCT_BUILDER(cty, name, ty, def, tname) cty name;
+#define DEFAULT_BUILDER(cty, name, ty, def, tname) .name = (def),
+#define INTROS_BUILDER(cty, name, ty, def, tname) \
+  INTROS_ITEM(name, struct table_##tname, ty),
+
+#define BUILD_TABLE(table, TABLE) \
+  struct table_##table {          \
+    TABLE(STRUCT_BUILDER, table)  \
+  }
+#define BUILD_DEFAULT(utable, table, TABLE)                    \
+  static const struct table_##table DEFAULT_TABLE_##utable = { \
+      TABLE(DEFAULT_BUILDER, table)}
+#define BUILD_INTROS(utable, table, TABLE)                           \
+  static const struct introspection_item INTROS_TABLE_##utable[] = { \
+      TABLE(INTROS_BUILDER, table)}
+
+#define BUILD(table, utable, TABLE)    \
+  BUILD_TABLE(table, TABLE);           \
+  BUILD_DEFAULT(utable, table, TABLE); \
+  BUILD_INTROS(utable, table, TABLE);
 
 // should be ansi escape codes under \x1b[...m
 // if not prepared accordingly, it might break
-struct theme_colors {
-  char *bg;
-  char *fg;
-  char *err;
-  char *s_wayland;
-  char *s_xorg;
-  char *s_shell;
-  char *e_hostname;
-  char *e_date;
-  char *e_box;
-  char *e_header;
-  char *e_user;
-  char *e_passwd;
-  char *e_badpasswd;
-  char *e_key;
-};
+#define TABLE_COLORS(F, name)                                      \
+  F(char* NNULLABLE, bg, STRING, "48;2;38;28;28", name)            \
+  F(char* NNULLABLE, fg, STRING, "22;24;38;2;245;245;245", name)   \
+  F(char* NNULLABLE, err, STRING, "1;31", name)                    \
+  F(char* NNULLABLE, s_wayland, STRING, "38;2;255;174;66", name)   \
+  F(char* NNULLABLE, s_xorg, STRING, "38;2;37;175;255", name)      \
+  F(char* NNULLABLE, s_shell, STRING, "38;2;34;140;34", name)      \
+  F(char* NNULLABLE, e_hostname, STRING, "38;2;255;64;64", name)   \
+  F(char* NNULLABLE, e_date, STRING, "38;2;144;144;144", name)     \
+  F(char* NNULLABLE, e_box, STRING, "38;2;122;122;122", name)      \
+  F(char* NNULLABLE, e_header, STRING, "4;38;2;0;255;0", name)     \
+  F(char* NNULLABLE, e_user, STRING, "36", name)                   \
+  F(char* NNULLABLE, e_passwd, STRING, "4;38;2;245;245;205", name) \
+  F(char* NNULLABLE, e_badpasswd, STRING, "3;4;31", name)          \
+  F(char* NNULLABLE, e_key, STRING, "38;2;255;174;66", name)
+
+BUILD(colors, COLORS, TABLE_COLORS);
 
 // even if they're multiple bytes long
 // they should only take up 1 char size on display
-struct theme_chars {
-  char *hb;
-  char *vb;
+#define TABLE_CHARS(F, name)                 \
+  F(char* NNULLABLE, hb, STRING, "─", name)  \
+  F(char* NNULLABLE, vb, STRING, "│", name)  \
+  F(char* NNULLABLE, ctl, STRING, "┌", name) \
+  F(char* NNULLABLE, ctr, STRING, "┐", name) \
+  F(char* NNULLABLE, cbl, STRING, "└", name) \
+  F(char* NNULLABLE, cbr, STRING, "┘", name)
 
-  char *ctl;
-  char *ctr;
-  char *cbl;
-  char *cbr;
-};
+BUILD(chars, CHARS, TABLE_CHARS);
 
-struct theme {
-  struct theme_colors colors;
-  struct theme_chars chars;
-};
+#define TABLE_FUNCTIONS(F, name)        \
+  F(enum Keys, poweroff, KEY, F1, name) \
+  F(enum Keys, reboot, KEY, F2, name)   \
+  F(enum Keys, fido, KEY, NONE, name)   \
+  F(enum Keys, refresh, KEY, F5, name)
 
-struct functions {
-  enum keys poweroff;
-  enum keys reboot;
-  enum keys refresh;
-};
+BUILD(functions, FUNCTIONS, TABLE_FUNCTIONS);
 
-struct strings {
-  char *f_poweroff;
-  char *f_reboot;
-  char *f_refresh;
-  char *e_user;
-  char *e_passwd;
-  char *s_wayland;
-  char *s_xorg;
-  char *s_shell;
-};
+#define TABLE_STRINGS(F, name)                             \
+  F(char* NNULLABLE, f_poweroff, STRING, "poweroff", name) \
+  F(char* NNULLABLE, f_reboot, STRING, "reboot", name)     \
+  F(char* NNULLABLE, f_fido, STRING, "fido", name)         \
+  F(char* NNULLABLE, f_refresh, STRING, "refresh", name)   \
+  F(char* NNULLABLE, e_user, STRING, "user", name)         \
+  F(char* NNULLABLE, e_passwd, STRING, "password", name)   \
+  F(char* NNULLABLE, s_wayland, STRING, "wayland", name)   \
+  F(char* NNULLABLE, s_xorg, STRING, "xorg", name)         \
+  F(char* NNULLABLE, s_shell, STRING, "shell", name)       \
+  F(char* NNULLABLE, opts_pre, STRING, "< ", name)         \
+  F(char* NNULLABLE, opts_post, STRING, " >", name)        \
+  F(char* NNULLABLE, ellipsis, STRING, "…", name)
 
-struct behavior {
-  bool include_defshell;
-  struct Vector source;
-  struct Vector user_source;
-};
+BUILD(strings, STRINGS, TABLE_STRINGS);
 
+#define NULL_VEC    \
+  (struct Vector) { \
+    0, 0, NULL      \
+  }
+#define TABLE_BEHAVIOR(F, name)                               \
+  F(bool, include_defshell, BOOL, true, name)                 \
+  F(struct Vector, source, STRING_ARRAY, NULL_VEC, name)      \
+  F(struct Vector, user_source, STRING_ARRAY, NULL_VEC, name) \
+  F(char* NNULLABLE, timefmt, STRING, "%X %x", name)          \
+  F(long long, refresh_rate, NUMBER, 100, name)               \
+  F(bool, bypass_shell_login, BOOL, false, name)
+
+BUILD(behavior, BEHAVIOR, TABLE_BEHAVIOR);
+
+//// CONFIG
 struct config {
-  struct theme theme;
-  struct functions functions;
-  struct strings strings;
-  struct behavior behavior;
+  struct table_colors colors;
+  struct table_chars chars;
+  struct table_functions functions;
+  struct table_strings strings;
+  struct table_behavior behavior;
 };
 
-bool line_parser(
-    FILE *fd, ssize_t *blksize,
-    u_char (*cb)(char *key,
-                 char *value)); // might use this for parsing .desktop files too
-struct config *parse_config(char *path);
+static const struct config DEFAULT_CONFIG = {
+    .colors = DEFAULT_TABLE_COLORS,
+    .chars = DEFAULT_TABLE_CHARS,
+    .functions = DEFAULT_TABLE_FUNCTIONS,
+    .strings = DEFAULT_TABLE_STRINGS,
+    .behavior = DEFAULT_TABLE_BEHAVIOR,
+};
+
+struct introspection_table {
+  char* NNULLABLE tname;
+  size_t offset;
+  const struct introspection_item* NNULLABLE intros;
+  size_t len;
+};
+
+static const struct introspection_table CONFIG_INSTROSPECTION[] = {
+    {"colors", offsetof(struct config, colors), INTROS_TABLE_COLORS,
+     LEN(INTROS_TABLE_COLORS)},
+    {"chars", offsetof(struct config, chars), INTROS_TABLE_CHARS,
+     LEN(INTROS_TABLE_CHARS)},
+    {"functions", offsetof(struct config, functions), INTROS_TABLE_FUNCTIONS,
+     LEN(INTROS_TABLE_FUNCTIONS)},
+    {"strings", offsetof(struct config, strings), INTROS_TABLE_STRINGS,
+     LEN(INTROS_TABLE_STRINGS)},
+    {"behavior", offsetof(struct config, behavior), INTROS_TABLE_BEHAVIOR,
+     LEN(INTROS_TABLE_BEHAVIOR)},
+};
+
+//// FUNCTIONS
+int parse_config(struct config* NNULLABLE config, char* NNULLABLE path);
 
 #endif

include/desktop.h

@@ -0,0 +1,20 @@
+#ifndef DESKTOPH_
+#define DESKTOPH_
+
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "macros.h"
+
+struct status {
+  bool finish;
+  int ret;
+};
+
+int read_desktop(FILE* NNULLABLE fd, void* UNULLABLE ctx,
+                 struct status (*NNULLABLE cb)(void* UNULLABLE ctx,
+                                               char* NULLABLE table,
+                                               char* NNULLABLE key,
+                                               char* NNULLABLE value));
+
+#endif

include/desktop_exec.h

@@ -0,0 +1,14 @@
+// TODO: rewrite properly
+// NOLINTBEGIN(clang-diagnostic-nullability-completeness)
+
+#ifndef DESKTOP_EXEC_H_
+  #define DESKTOP_EXEC_H_
+
+  #include "macros.h"
+
+char* NULLABLE desktop_as_cmdline(char** args);
+int parse_exec_string(const char* exec_s, int* arg_count, char*** args);
+void free_parsed_args(int arg_count, char** args);
+
+#endif
+// NOLINTEND(clang-diagnostic-nullability-completeness)

include/efield.h

@@ -1,18 +1,19 @@
-#ifndef _EFIELDH_
-#define _EFIELDH_
+#ifndef EFIELDH_
+#define EFIELDH_
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <sys/types.h>
 
+// holds also the max string buffer in itself, not dynamic
 struct editable_field {
-  u_char length;
-  u_char pos;
+  uint8_t pos;
   char content[255];
 };
 
-struct editable_field field_new(char *);
-void field_trim(struct editable_field *, u_char);
-void field_update(struct editable_field *, char *);
-bool field_seek(struct editable_field *, char);
+struct editable_field efield_new(char* content);
+void efield_trim(struct editable_field* self, uint8_t pos);
+void efield_update(struct editable_field* self, char* update);
+bool efield_seek(struct editable_field* self, char seek);
 
 #endif

include/keys.h

@@ -1,9 +1,12 @@
-#ifndef _KEYSH_
-#define _KEYSH_
+#ifndef KEYSH_
+#define KEYSH_
 
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
+#include <sys/time.h>
 
-enum keys {
+enum Keys {
   ESC,
   F1,
   F2,
@@ -32,9 +35,11 @@ enum keys {
   END,
   PAGE_UP,
   PAGE_DOWN,
+  NONE,
 };
 
-static const char *const key_names[] = {
+static const char* const KEY_NAMES[] = {
+    [NONE] = "NONE",
     [ESC] = "ESC",
     [F1] = "F1",
     [F2] = "F2",
@@ -66,11 +71,11 @@ static const char *const key_names[] = {
 };
 
 struct key_mapping {
-  enum keys key;
+  enum Keys key;
   const char* sequences[3];
 };
 
-static const struct key_mapping key_mappings[] = {
+static const struct key_mapping KEY_MAPPINGS[] = {
     {ESC, {"\x1b", NULL}},
     {F1, {"\x1bOP", "\x1b[[A", NULL}},
     {F2, {"\x1bOQ", "\x1b[[B", NULL}},
@@ -101,4 +106,15 @@ static const struct key_mapping key_mappings[] = {
     {PAGE_DOWN, {"\x1b[6~", NULL}},
 };
 
+struct option_keys {
+  bool is_some;
+  enum Keys key;
+};
+
+int find_keyname(enum Keys* at, const char* name);
+struct option_keys find_ansi(const char* seq);
+void read_press(uint8_t* length, char* out);
+// non blocking, waits up to tv or interrupt, returns true if actually read
+bool read_press_nb(uint8_t* length, char* out, struct timeval* tv);
+
 #endif

include/launch_state.h

@@ -0,0 +1,17 @@
+#ifndef LAUNCHSTATEH_
+#define LAUNCHSTATEH_
+
+#include <stdbool.h>
+#include <sys/stat.h>
+
+#include "macros.h"
+
+struct LaunchState {
+  char* NNULLABLE username;
+  char* NNULLABLE session_opt;
+};
+
+int read_launch_state(struct LaunchState* NNULLABLE state);
+bool write_launch_state(struct LaunchState state);
+
+#endif

include/log.h

@@ -0,0 +1,14 @@
+#ifndef LOGH_
+#define LOGH_
+
+#include <stdio.h>
+
+#include "macros.h"
+
+void log_init(FILE* NNULLABLE fd);
+void log_puts(const char* NNULLABLE msg);
+void log_printf(const char* NNULLABLE fmt, ...);
+// NOLINTNEXTLINE(readability-identifier-length)
+void log_perror(const char* NNULLABLE s);
+
+#endif

include/macros.h

@@ -0,0 +1,41 @@
+#ifndef MACROSH_
+#define MACROSH_
+
+// More like constants but I'm not making yet another header file just for this
+#ifndef LIDM_CONF_PATH
+  #define LIDM_CONF_PATH "/etc/lidm.ini"
+#endif
+
+// Do we just replace the compiler with clang??
+#ifdef __clang__
+  #define NULLABLE _Nullable
+#else
+  #define NULLABLE
+#endif
+
+#ifdef __clang__
+  #define NNULLABLE _Nonnull
+#else
+  #define NNULLABLE
+#endif
+
+#ifdef __clang__
+  #define UNULLABLE _Null_unspecified
+#else
+  #define UNULLABLE
+#endif
+
+#ifdef __clang__
+  #define COMPILER_VERSION __VERSION__
+#elif defined(__GNUC__)
+  #define xstr(s) str(s)
+  #define str(s) #s
+
+  #define COMPILER_VERSION \
+    "GCC " xstr(__GNUC__) "." xstr(__GNUC_MINOR__) "." xstr(__GNUC_PATCHLEVEL__)
+#endif
+
+#define LEN(X) (sizeof(X) / sizeof((X)[0]))
+#define UNUSED(x) ((void)(x))
+
+#endif

include/ofield.h

@@ -0,0 +1,23 @@
+#ifndef OFIELD_
+#define OFIELD_
+
+#include <stddef.h>
+#include "efield.h"
+
+// related vector is external, indexing at 1, 0 means empty and hence points to
+// the editable_field
+struct opts_field {
+  size_t opts;
+  size_t current_opt;
+  struct editable_field efield;
+};
+
+struct opts_field ofield_new(size_t opts);
+void ofield_toedit(struct opts_field* self, char* init);
+void ofield_kbd_type(struct opts_field* self, char* typed, char* empty_default);
+bool ofield_opts_seek(struct opts_field* self, char seek);
+bool ofield_seek(struct opts_field* self, char seek);
+
+uint8_t ofield_display_cursor_col(struct opts_field* self, uint8_t maxlen);
+
+#endif

include/pam.h

@@ -0,0 +1,33 @@
+#ifndef PAM_H
+#define PAM_H
+
+#include <pwd.h>
+#include <security/_pam_types.h>
+#include <security/pam_appl.h>
+#include <stdbool.h>
+
+#include "macros.h"
+#include "sessions.h"
+
+#define PAMH_ERR_NOERR 0
+#define PAMH_ERR_ALLOC 1
+#define PAMH_ERR_ERRNO 2
+#define PAMH_ERR_NOERRNO 3
+
+struct pamh_getenv_status {
+  char error_flag;
+  union {
+    char* NULLABLE* NNULLABLE envlist;
+    const char* NNULLABLE errfn;
+  };
+};
+
+// Doesn't include `source`s
+struct pamh_getenv_status pamh_get_complete_env(pam_handle_t* NNULLABLE handle,
+                                                struct passwd* NNULLABLE pw,
+                                                enum SessionType session_typ);
+
+void free_envlist(char* NULLABLE* NNULLABLE envlist);
+pam_handle_t* NULLABLE get_pamh(char* NNULLABLE user, char* NNULLABLE passwd);
+
+#endif /* PAM_H */

include/sessions.h

@@ -1,23 +1,65 @@
-#ifndef _SESSIONSH_
-#define _SESSIONSH_
+#ifndef SESSIONSH_
+#define SESSIONSH_
 
 #include <sys/types.h>
+#include <unistd.h>
 
-#include "util.h"
+#include "macros.h"
+#include "util/vec.h"
 
-enum session_type {
+enum SessionType {
   XORG,
   WAYLAND,
   SHELL,
 };
 
+enum ExecType {
+  EXEC_SHELL,
+  EXEC_DESKTOP,
+};
+
+struct desktop_exec {
+  char* NULLABLE* NNULLABLE args;
+  int arg_count;
+};
+
+struct session_exec {
+  enum ExecType typ;
+  union {
+    char* NNULLABLE shell;
+    struct desktop_exec desktop;
+  };
+};
+
+static inline struct session_exec session_exec_shell(char* NNULLABLE shell) {
+  return (struct session_exec){
+      .typ = EXEC_SHELL,
+      .shell = shell,
+  };
+}
+
+static inline struct session_exec session_exec_desktop(
+    int arg_count, char* NULLABLE* NNULLABLE args) {
+  return (struct session_exec){
+      .typ = EXEC_DESKTOP,
+      .desktop =
+          {
+              .args = args,
+              .arg_count = arg_count,
+          },
+  };
+}
+
 struct session {
-  char *name;
-  char *exec;
-  char *tryexec;
-  enum session_type type;
+  char* NNULLABLE name;
+  struct session_exec exec;
+  enum SessionType type;
 };
 
 struct Vector get_avaliable_sessions();
+int session_exec_exec(struct session_exec* NNULLABLE exec,
+                      char* NULLABLE* NNULLABLE envp);
+int session_exec_login_through_shell(struct session_exec* NNULLABLE exec,
+                                     char* NULLABLE* NNULLABLE envp);
 
 #endif

include/signal_handler.h

@@ -0,0 +1,8 @@
+#ifndef SIGNALHANDLERH_
+#define SIGNALHANDLERH_
+
+// handle SIGTERM by sending SIGTERM to all children, resulting
+// in a graceful graphical shutdown
+void setup_sigterm();
+
+#endif /* SIGNALHANDLERH_ */

include/ui.h

@@ -1,12 +1,57 @@
-#ifndef _UIH_
-#define _UIH_
+#ifndef UIH_
+#define UIH_
 
 #include "config.h"
-#include "util.h"
+#include "ofield.h"
+#include "util/vec.h"
 
-void setup(struct config);
+//    [box_start]
+//    ↓
+// 0 [┌]───────────────────────────────────────────────┐
+// 1  │                                                │
+// 2  │    the-art                2025-06-20 21:40:44  │
+// 3  │                                             |  │
+// 4  │                                             |  │
+// 5  │       xorg   < Default >                    |  │
+// 6  │                                             |  │
+// 7  │       user   javalsai                       |  │
+// 8  │                                             |  │
+// 9  │   password   ________________________________  │
+// 10 │          |                                  |  │
+// 11 └────────────────────────────────────────────────┘
+//    01234567890123456789012345678901234567890123456789
+//    00000000001111111111222222222233333333334444444444
+//    |--|       |   ↑                              |--|[BOX_HMARGIN]
+//    [BOX_HMARGIN]  [VALUES_COL]                    |
+//               |---|[VALUES_SEPR]                  |
+//                  |--------------------------------|[VALUE_MAXLEN]
+
+#define HEAD_ROW 2
+#define SESSION_ROW 5
+#define USER_ROW 7
+#define PASSWD_ROW 9
+
+#define BOX_WIDTH 50
+#define BOX_HEIGHT 12
+#define BOX_HMARGIN 2
+
+#define VALUES_COL 15
+#define VALUES_SEPR 3
+#define VALUE_MAXLEN (BOX_WIDTH - VALUES_COL + 1 - BOX_HMARGIN - 2)
+
+enum Input { SESSION, USER, PASSWD };
+extern const uint8_t INPUTS_N;
+
+void setup(struct config* config);
 int load(struct Vector* users, struct Vector* sessions);
-void print_err(const char *);
-void print_errno(const char *);
+void print_err(const char* /*msg*/);
+void print_errno(const char* /*descr*/);
+void print_pam_msg(const char* msg, int msg_style);
+void clear_pam_msg(void);
+
+void ui_update_field(enum Input focused_input);
+void ui_update_ffield();
+void ui_update_ofield(struct opts_field* self);
+void ui_update_cursor_focus();
 
 #endif

include/ui_state.h

@@ -0,0 +1,29 @@
+#ifndef UISTATEH_
+#define UISTATEH_
+
+#include <stddef.h>
+
+#include "macros.h"
+#include "ui.h"
+
+extern enum Input focused_input;
+
+extern struct opts_field of_session;
+extern struct opts_field of_user;
+extern struct opts_field of_passwd;
+
+extern struct Vector* UNULLABLE gusers;
+extern struct Vector* UNULLABLE gsessions;
+
+struct opts_field* NNULLABLE get_opts_field(enum Input from);
+struct opts_field* NNULLABLE get_opts_ffield();
+
+struct user st_user();
+struct session st_session(bool include_defshell);
+
+void st_ch_focus(char direction);
+void st_ch_of_opts(char direction);
+void st_ch_ef_col(char direction);
+void st_kbd_type(char* NNULLABLE text, bool cfg_include_defshell);
+
+#endif

include/users.h

@@ -1,9 +1,9 @@
-#ifndef _USERSH_
-#define _USERSH_
+#ifndef USERSH_
+#define USERSH_
 
 #include <sys/types.h>
 
-#include "util.h"
+#include "util/vec.h"
 
 struct user {
   char* shell;

include/util.h

@@ -1,31 +0,0 @@
-#ifndef _UTILH_
-#define _UTILH_
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <sys/types.h>
-
-#include "keys.h"
-
-enum keys find_keyname(char *);
-enum keys find_ansi(char *);
-void read_press(u_char *, char *);
-void strcln(char **dest, const char *source);
-
-struct Vector {
-    uint32_t length;
-    uint32_t alloc_len;
-    uint16_t alloc_size;
-    void** pages;
-};
-
-struct Vector vec_new();
-int vec_push(struct Vector*, void* item);
-void vec_free(struct Vector*);
-void vec_clear(struct Vector*);
-void vec_reset(struct Vector*);
-void* vec_pop(struct Vector*); // won't free it, nor shrink vec list space
-void* vec_get(struct Vector*, size_t index);
-
-#endif

include/util/path.h

@@ -0,0 +1,10 @@
+#ifndef UTIL_PATH_H
+#define UTIL_PATH_H
+
+#include "macros.h"
+
+char* NULLABLE search_path(const char* NNULLABLE for_binary);
+int execvpe(const char* NNULLABLE file, char* NULLABLE const argv[NNULLABLE],
+            char* NULLABLE const envp[NNULLABLE]);
+
+#endif /* UTIL_PATH_H */

include/util/utf8.h

@@ -0,0 +1,15 @@
+#ifndef UTIL_UTF8_H
+#define UTIL_UTF8_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+bool utf8_iscont(char byte);
+size_t utf8len(const char* str);
+size_t utf8len_until(const char* str, const char* until);
+size_t utf8trunc(char* str, size_t n);
+const char* utf8back(const char* str);
+const char* utf8seek(const char* str);
+const char* utf8seekn(const char* str, size_t n);
+
+#endif /* UTIL_UTF8_H */

include/util/vec.h

@@ -0,0 +1,26 @@
+#ifndef UTIL_VEC_H
+#define UTIL_VEC_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+struct Vector {
+  uint32_t length;
+  uint32_t capacity;
+  void** pages;
+};
+
+struct Vector vec_from_raw(void** raw);
+void** vec_as_raw(struct Vector self);
+extern const struct Vector VEC_NEW;
+int vec_resize(struct Vector* self, size_t size);
+int vec_reserve(struct Vector* self, size_t size);
+int vec_reserve_exact(struct Vector* self, size_t size);
+int vec_push(struct Vector* self, void* item);
+void vec_free(struct Vector* self);
+void vec_clear(struct Vector* self);
+void vec_reset(struct Vector* self);
+void* vec_pop(struct Vector* self); // won't free it, nor shrink vec list space
+void* vec_get(struct Vector* self, size_t index);
+
+#endif /* UTIL_VEC_H */

services.mk

@@ -0,0 +1,91 @@
+install-service:
+	@if command -v systemctl &> /dev/null; then \
+		make install-service-systemd; \
+	elif command -v dinitctl &> /dev/null; then \
+		make install-service-dinit; \
+	elif command -v sv &> /dev/null; then \
+		if [ -d /etc/sv ]; then \
+			make install-service-runit; \
+		elif [ -d /etc/runit/sv ]; then \
+			make install-service-runit-etc; \
+		else \
+			printf '\033[31m%s\033[0m\n' "Unknown init system structure, skipping service install..." >&2; \
+		fi \
+	elif command -v rc-update &> /dev/null; then \
+		make install-service-openrc; \
+	elif command -v s6-service &> /dev/null; then \
+		if [ -d /etc/sv ]; then \
+			make install-service-s6; \
+		elif [ -d /etc/r6nit/sv ]; then \
+			make install-service-s6-etc; \
+		else \
+			printf '\033[31m%s\033[0m\n' "Unknown init system structure, skipping service install..." >&2; \
+		fi \
+	else \
+		printf '\033[1;31m%s\033[0m\n' "Unknown init system, skipping service install..." >&2; \
+	fi
+
+install-service-systemd:
+	@sed -e 's|ExecStart=/usr/bin/lidm|ExecStart=${DESTDIR}${PREFIX}/bin/lidm|' ./assets/services/systemd.service > ./dist/lidm.service
+	install -Dm644 ./dist/lidm.service ${DESTDIR}${PREFIX}/lib/systemd/system/lidm.service
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 'systemctl enable lidm'"
+install-service-dinit:
+	install -m644 ./assets/services/dinit ${DESTDIR}/etc/dinit.d/lidm
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 'dinitctl enable lidm'"
+install-service-runit:
+	@if [ ! -e /etc/sv ] && [ -d /etc/runit/sv ] && [ -z "$$FORCE" ]; then \
+		printf '\033[31m%s\033[0m\n' "/etc/sv doesn't exist but /etc/runit/sv does" >&2; \
+		printf '\033[31m%s\033[0m\n' "you probably meant to 'make install-service-runit-etc'" >&2; \
+		exit 1; \
+	fi
+	mkdir -p ${DESTDIR}/etc/sv/lidm
+	cp -r --update=all ./assets/services/runit/* ${DESTDIR}/etc/sv/lidm/
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 'ln -s ${DESTDIR}/etc/sv/lidm /var/service' or your distro equivalent"
+install-service-runit-etc:
+	@if [ ! -e /etc/runit/sv ] && [ -d /etc/sv ] && [ -z "$$FORCE" ]; then \
+		printf '\033[31m%s\033[0m\n' "/etc/runit/sv doesn't exist but /etc/sv does" >&2; \
+		printf '\033[31m%s\033[0m\n' "you probably meant to 'make install-service-runit'" >&2; \
+		exit 1; \
+	fi
+	mkdir -p ${DESTDIR}/etc/runit/sv/lidm
+	cp -r --update=all ./assets/services/runit/* ${DESTDIR}/etc/runit/sv/lidm/
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 'ln -s ${DESTDIR}/etc/runit/sv/lidm /run/runit/service' or your distro equivalent"
+install-service-openrc:
+	install -m755 ./assets/services/openrc ${DESTDIR}/etc/init.d/lidm
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 'rc-update add lidm'"
+install-service-s6:
+	@if [ ! -e /etc/sv ] && [ -d /etc/s6/sv ] && [ -z "$$FORCE" ]; then \
+		printf '\033[31m%s\033[0m\n' "/etc/sv doesn't exist but /etc/s6/sv does" >&2; \
+		printf '\033[31m%s\033[0m\n' "you probably meant to 'make install-service-s6-etc'" >&2; \
+		exit 1; \
+	fi
+	mkdir -p ${DESTDIR}/etc/sv/lidm
+	cp -r --update=all ./assets/services/s6/* ${DESTDIR}/etc/sv/lidm/
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 's6-service add default lidm' and 's6-db-reload'"
+install-service-s6-etc:
+	@if [ ! -e /etc/s6/sv ] && [ -d /etc/sv ] && [ -z "$$FORCE" ]; then \
+		printf '\033[31m%s\033[0m\n' "/etc/s6/sv doesn't exist but /etc/sv does" >&2; \
+		printf '\033[31m%s\033[0m\n' "you probably meant to 'make install-service-s6'" >&2; \
+		exit 1; \
+	fi
+	mkdir -p ${DESTDIR}/etc/s6/sv/lidm
+	cp -r --update=all ./assets/services/s6/* ${DESTDIR}/etc/s6/sv/lidm/
+	@printf '\033[1m%s\033[0m\n\n' " don't forget to run 's6-service add default lidm' and 's6-db-reload'"
+
+uninstall-service:
+	rm -rf \
+		${DESTDIR}${PREFIX}/lib/systemd/system/lidm.service \
+		${DESTDIR}/etc/dinit.d/lidm \
+		${DESTDIR}/etc/sv/lidm \
+		${DESTDIR}/etc/runit/sv/lidm \
+		${DESTDIR}/etc/init.d/lidm \
+		${DESTDIR}/etc/s6/sv/lidm
+
+.PHONY: install-service uninstall-service \
+	install-service-s6 \
+	install-service-s6-etc \
+	install-service-dinit \
+	install-service-runit \
+	install-service-runit-etc \
+	install-service-openrc \
+	install-service-systemd

src/auth.c

@@ -1,160 +1,298 @@
+// TODO: handle `fork() == -1`
+
+#include <errno.h>
 #include <grp.h>
 #include <pwd.h>
 #include <security/pam_misc.h>
+#include <signal.h>
+#include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <sys/stat.h>
 #include <sys/wait.h>
+#include <unistd.h>
 
 #include "auth.h"
 #include "config.h"
+#include "log.h"
+#include "macros.h"
+#include "pam.h"
 #include "sessions.h"
 #include "ui.h"
-#include "unistd.h"
-#include "util.h"
+#include "util/path.h"
+#include "util/vec.h"
 
-int pam_conversation(int num_msg, const struct pam_message **msg,
-                     struct pam_response **resp, void *appdata_ptr) {
-  struct pam_response *reply =
-      (struct pam_response *)malloc(sizeof(struct pam_response) * num_msg);
-  for (size_t i = 0; i < num_msg; i++) {
-    reply[i].resp = NULL;
-    reply[i].resp_retcode = 0;
-    if (msg[i]->msg_style == PAM_PROMPT_ECHO_OFF ||
-        msg[i]->msg_style == PAM_PROMPT_ECHO_ON) {
-      char *input = (char *)appdata_ptr;
-      reply[i].resp = strdup(input);
-    }
-  }
-  *resp = reply;
-  return PAM_SUCCESS;
-}
+#define XORG_MESSAGE_LENGTH 16
 
-#define CHECK_PAM_RET(call)                                                    \
-  ret = (call);                                                                \
-  if (ret != PAM_SUCCESS) {                                                    \
-    pam_end(pamh, ret);                                                        \
-    return NULL;                                                               \
-  }
-
-void clear_screen() { printf("\x1b[H\x1b[J"); }
-
-pam_handle_t *get_pamh(char *user, char *passwd) {
-  pam_handle_t *pamh = NULL;
-  struct pam_conv pamc = {pam_conversation, (void *)passwd};
-  int ret;
-
-  CHECK_PAM_RET(pam_start("login", user, &pamc, &pamh))
-  CHECK_PAM_RET(pam_authenticate(pamh, 0))
-  CHECK_PAM_RET(pam_acct_mgmt(pamh, 0))
-  CHECK_PAM_RET(pam_setcred(pamh, PAM_ESTABLISH_CRED))
-  CHECK_PAM_RET(pam_open_session(pamh, 0))
-  CHECK_PAM_RET(pam_setcred(pamh, PAM_REINITIALIZE_CRED))
-
-  return pamh;
-}
-#undef CHECK_PAM_RET
-
-void *shmalloc(size_t size) {
-  return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
-              -1, 0);
-}
-
-void sourceFileTry(char *file) {
-  FILE *file2source = fopen(file, "r");
-  if (file2source == NULL)
+static void try_source_file(struct Vector* NNULLABLE vec_envlist,
+                            char* NNULLABLE filepath) {
+  log_printf("sourcing %s\n", filepath);
+  FILE* file2source = fopen(filepath, "r");
+  if (file2source == NULL) {
+    log_printf("error sourcing %s\n", filepath);
     return;
+  }
 
   char* line = NULL;
   size_t len = 0;
   ssize_t read;
 
   while ((read = getline(&line, &len, file2source)) != -1) {
-    if (read == 0 || (read > 0 && *line == '#'))
-      continue;
-    if (line[read - 1] == '\n')
-      line[read - 1] = '\0';
+    if (read == 0 || (read > 0 && *line == '#')) continue;
+    if (line[read - 1] == '\n') line[read - 1] = '\0';
 
-    /* printf("Retrieved line of length %zu:\n", read); */
-    /* printf("%s\n", line); */
-    for (size_t i = 1; i < read; i++) {
+    for (ssize_t i = 1; i < read; i++) {
       if (line[i] == '=') {
-        /* printf("FOUND '='!\n"); */
-        line[i] = '\0';
-        setenv(line, &line[i + 1], 1);
+        vec_push(vec_envlist, (void*)line);
+        line = NULL;
         break;
       }
     }
   }
 
-  if (line)
-    free(line);
-  fclose(file2source);
+  if (line) free(line);
+  (void)fclose(file2source);
 }
 
-void moarEnv(char *user, struct session session, struct passwd *pw,
-             struct behavior *behavior) {
-  if (chdir(pw->pw_dir) == -1)
-    print_errno("can't chdir to user home");
-
-  setenv("HOME", pw->pw_dir, true);
-  setenv("USER", pw->pw_name, true);
-  setenv("SHELL", pw->pw_shell, true);
-  // TERM
-  setenv("LOGNAME", pw->pw_name, true);
-  // MAIL?
-
-  // PATH?
-
-  char *xdg_session_type;
-  if (session.type == SHELL)
-    xdg_session_type = "tty";
-  if (session.type == XORG)
-    xdg_session_type = "x11";
-  if (session.type == WAYLAND)
-    xdg_session_type = "wayland";
-  setenv("XDG_SESSION_TYPE", xdg_session_type, true);
-
-  printf("\n\n\n\n\x1b[1m");
-  for (size_t i = 0; i < behavior->source.length; i++) {
-    /* printf("DEBUG(source)!!!! %d %s\n", i, (char*)vec_get(&behavior->source,
-     * i)); */
-    sourceFileTry((char *)vec_get(&behavior->source, i));
+static void source_paths(struct Vector* NNULLABLE vec_envlist,
+                         struct Vector* NNULLABLE abs_source,
+                         const char* NULLABLE user_home,
+                         struct Vector* NNULLABLE user_source) {
+  for (size_t i = 0; i < abs_source->length; i++) {
+    char* path = vec_get(abs_source, i);
+    try_source_file(vec_envlist, path);
   }
-  /* printf("\n"); */
-  if (pw->pw_dir) {
-    uint home_len = strlen(pw->pw_dir);
-    for (size_t i = 0; i < behavior->user_source.length; i++) {
-      char *file2sourcepath = (char *)vec_get(&behavior->user_source, i);
-      char *newbuf =
-          malloc(home_len + strlen(file2sourcepath) + 2); // nullbyte and slash
-      if (newbuf == NULL)
-        continue; // can't bother
-      strcpy(newbuf, pw->pw_dir);
-      newbuf[home_len] = '/'; // assume pw_dir doesn't start with '/' :P
-      strcpy(&newbuf[home_len + 1], file2sourcepath);
 
-      /* printf("DEBUG(user_source)!!!! %d %s\n", i, newbuf); */
-      sourceFileTry(newbuf);
-      free(newbuf);
+  if (user_home)
+    for (size_t i = 0; i < user_source->length; i++) {
+      char* path = NULL;
+      asprintf(&path, "%s/%s", user_home, (char*)vec_get(user_source, i));
+      if (!path) {
+        log_puts("alloc failure on user source\n");
+        continue;
+      }
+      try_source_file(vec_envlist, path);
+      free(path);
+    }
+  else {
+    log_puts("user has no home\n");
   }
 }
 
-  /*char *buf;*/
-  /*size_t bsize = snprintf(NULL, 0, "/run/user/%d", pw->pw_uid) + 1;*/
-  /*buf = malloc(bsize);*/
-  /*snprintf(buf, bsize, "/run/user/%d", pw->pw_uid);*/
-  /*setenv("XDG_RUNTIME_DIR", buf, true);*/
-  /*setenv("XDG_SESSION_CLASS", "user", true);*/
-  /*setenv("XDG_SESSION_ID", "1", true);*/
-  /*setenv("XDG_SESSION_DESKTOP", , true);*/
-  /*setenv("XDG_SEAT", "seat0", true);*/
+struct child_msg {
+  char* msg;
+  int _errno;
+  bool err;
+};
+
+/// block until X returns the display number or an error occurs
+static bool x_get_display(const int xorg_pipefd[2], int* display) {
+  char buffer[XORG_MESSAGE_LENGTH];
+  bool status;
+
+  close(xorg_pipefd[1]);
+  ssize_t bytes_read = read(xorg_pipefd[0], buffer, sizeof(buffer) - 1);
+  buffer[bytes_read] = '\0';
+
+  if (bytes_read > 0) {
+    char* endptr;
+    int val = (int)strtol(buffer, &endptr, 10);
+    if (endptr == buffer) {
+      (void)fputs("failed to parse Xorg display response\n", stderr);
+      status = false;
+    } else {
+      *display = val;
+      status = true;
+    }
+  } else if (bytes_read == 0) {
+    (void)fputs("Xorg pipe closed\n", stderr);
+    status = false;
+  } else {
+    perror("read");
+    status = false;
   }
 
+  close(xorg_pipefd[0]);
+  return status;
+}
+
+/// small helper to push dyn arr
+static void push_dyn_arr(void*** arr, void* item) {
+  struct Vector vec = vec_from_raw(*arr);
+  vec_push(&vec, item);
+  *arr = vec_as_raw(vec);
+}
+
+// TODO: properly pass this down
+extern int vt;
+
+static void start_xorg_server(struct passwd* pw, char** NNULLABLE envlist,
+                              int xorg_pipefd[2]) {
+  close(xorg_pipefd[0]);
+  if (!pw->pw_dir) _exit(EXIT_FAILURE);
+  // !!!!!!!!!! ATTENTION: this fails silently, of course add failure msgs but
+  // for now I can't so be careful
+  if (vt == -1) _exit(EXIT_FAILURE);
+
+  // pass the pipe so Xorg can write the DISPLAY value in there
+  char* fd_str;
+  asprintf(&fd_str, "%d", xorg_pipefd[1]);
+  if (!fd_str) _exit(EXIT_FAILURE);
+
+  char* vt_path;
+  asprintf(&vt_path, "vt%d", vt);
+  if (!vt_path) {
+    free(fd_str);
+    _exit(EXIT_FAILURE);
+  }
+
+  char* xorg_path = search_path("Xorg");
+  if (!xorg_path) {
+    (void)fputs("couldn't find Xorg binary in PATH, sure it's installed?\n",
+                stderr);
+    _exit(EXIT_FAILURE);
+  }
+
+  int exit = execle(xorg_path, xorg_path, "-displayfd", fd_str, vt_path, NULL,
+                    envlist);
+  perror("exec");
+
+  free(vt_path);
+  free(fd_str);
+  free(xorg_path);
+  _exit(exit);
+}
+
+// TODO: add error msgs
+/// returns on completion
+static void launch_with_xorg_server(struct config* config,
+                                    struct session_exec* NNULLABLE exec,
+                                    struct passwd* pw,
+                                    char** NNULLABLE envlist) {
+  int xorg_pipefd[2];
+  if (pipe(xorg_pipefd) == -1) _exit(EXIT_FAILURE);
+
+  (void)fflush(NULL);
+  pid_t xorg_pid = fork();
+  if (xorg_pid == 0) {
+    start_xorg_server(pw, envlist, xorg_pipefd);
+  }
+
+  int display = 0;
+  if (!x_get_display(xorg_pipefd, &display)) {
+    (void)fputs("failed to get X display, aborting\n", stderr);
+    int status;
+    waitpid(xorg_pid, &status, 0);
+    _exit(EXIT_FAILURE);
+  }
+
+  char* display_env;
+  asprintf(&display_env, "DISPLAY=:%d", display);
+  if (!display_env) {
+    (void)fputs("failure allocating memory for DISPLAY string\n", stderr);
+    _exit(EXIT_FAILURE);
+  }
+  // convert back for convenient push-ing
+  push_dyn_arr((void***)&envlist, display_env);
+  if (!envlist) {
+    (void)fputs("failure allocating memory for DISPLAY env\n", stderr);
+    _exit(EXIT_FAILURE);
+  }
+
+  (void)fflush(NULL);
+  pid_t xorg_session_pid = fork();
+  if (xorg_session_pid == 0) {
+    if (config->behavior.bypass_shell_login)
+      session_exec_exec(exec, envlist);
+    else
+      session_exec_login_through_shell(exec, envlist);
+
+    perror("session exec error");
+    (void)fputs("failure calling session\n", stderr);
+    _exit(EXIT_FAILURE);
+  }
+
+  // looks weird, waiting on -1 should wait on any child and then just check if
+  // its xorg server or the session and kill the other waiting on it
+  pid_t pid;
+  int status; // not even read for now
+  while ((pid = waitpid(-1, &status, 0)) > 0) {
+    if (pid == xorg_pid || pid == xorg_session_pid) {
+      pid_t pid_to_kill = pid ^ xorg_pid ^ xorg_session_pid;
+      if (pid == xorg_pid) printf("Xorg server died\n");
+      if (pid == xorg_session_pid) printf("Xorg session died\n");
+
+      kill(pid_to_kill, SIGTERM);
+      waitpid(pid_to_kill, &status, 0);
+
+      break;
+    }
+  }
+}
+
+#define SEND_MSG(MSG)                                   \
+  {                                                     \
+    write(pipefd[1], &(MSG), sizeof(struct child_msg)); \
+    close(pipefd[1]);                                   \
+  }
+#define SEND_ERR(MSG)                                                      \
+  {                                                                        \
+    write(pipefd[1],                                                       \
+          &(struct child_msg){.msg = (MSG), ._errno = errno, .err = true}, \
+          sizeof(struct child_msg));                                       \
+    close(pipefd[1]);                                                      \
+    _exit(EXIT_FAILURE);                                                   \
+  }
+#define DUMMY_READ()                          \
+  {                                           \
+    char _dummy;                              \
+    read(pipefd[0], &_dummy, sizeof(_dummy)); \
+  }
+inline static void forked(struct config* config, int pipefd[2],
+                          struct passwd* pw, char* NNULLABLE user,
+                          struct session* NNULLABLE session,
+                          char** NNULLABLE envlist) {
+  if (chdir(pw->pw_dir) == -1) SEND_ERR("chdir");
+  if (setgid(pw->pw_gid) == -1) SEND_ERR("setgid");
+  if (initgroups(user, pw->pw_gid) == -1) SEND_ERR("initgroups");
+  if (setuid(pw->pw_uid) == -1) SEND_ERR("setuid");
+
+  SEND_MSG((struct child_msg){.err = false});
+  DUMMY_READ();
+  close(pipefd[0]);
+
+  if (!getenv("PATH")) {
+    size_t path_size = confstr(_CS_PATH, NULL, 0);
+    char* path_env = malloc(path_size);
+    confstr(_CS_PATH, path_env, path_size);
+    setenv("PATH", path_env, 1);
+    free(path_env);
+  }
+
+  log_printf(" [I] using shell login?: %s",
+             config->behavior.bypass_shell_login ? "true" : "false");
+  if (session->type == XORG) {
+    launch_with_xorg_server(config, &session->exec, pw, envlist);
+    _exit(EXIT_SUCCESS);
+  } else {
+    if (config->behavior.bypass_shell_login)
+      session_exec_exec(&session->exec, envlist);
+    else
+      session_exec_login_through_shell(&session->exec, envlist);
+    perror("session exec error");
+    _exit(EXIT_FAILURE);
+  }
+}
+#undef SEND_MSG
+#undef SEND_ERR
+#undef DUMMY_READ
+
+// NOLINTBEGIN(readability-function-cognitive-complexity)
 bool launch(char* user, char* passwd, struct session session, void (*cb)(void),
-            struct behavior *behavior) {
+            struct config* config) {
   struct passwd* pw = getpwnam(user);
   if (pw == NULL) {
     print_err("could not get user info");
@@ -163,96 +301,66 @@ bool launch(char *user, char *passwd, struct session session, void (*cb)(void),
 
   pam_handle_t* pamh = get_pamh(user, passwd);
   if (pamh == NULL) {
-    print_err("error on pam authentication");
+    print_pam_msg("authentication failed", PAM_ERROR_MSG);
+    return false;
+  }
+  clear_pam_msg();
+
+  struct pamh_getenv_status env_ret =
+      pamh_get_complete_env(pamh, pw, session.type);
+  if (env_ret.error_flag != PAMH_ERR_NOERR) {
+    if (env_ret.error_flag == PAMH_ERR_ALLOC) {
+      print_err("allocator error");
+    } else if (env_ret.error_flag == PAMH_ERR_ERRNO) {
+      print_errno(env_ret.errfn);
+    } else if (env_ret.error_flag == PAMH_ERR_NOERRNO) {
+      print_err(env_ret.errfn);
+    }
     return false;
   }
 
-  bool *reach_session = shmalloc(sizeof(bool));
-  if (reach_session == NULL) {
-    perror("error allocating shared memory");
+  struct Vector envlist_vec = vec_from_raw((void**)env_ret.envlist);
+
+  source_paths(&envlist_vec, &config->behavior.source, pw->pw_dir,
+               &config->behavior.user_source);
+  char** envlist = (char**)vec_as_raw(envlist_vec);
+  if (!envlist) {
+    print_err("vec alloc error");
     return false;
   }
-  *reach_session = false;
+
+  int pipefd[2];
+  pipe(pipefd);
 
   uint pid = fork();
-  if (pid == 0) { // child
-    char *TERM = NULL;
-    char *_GETTERM = getenv("TERM");
-    if (_GETTERM != NULL)
-      strcln(&TERM, _GETTERM);
-    if (clearenv() != 0) {
-      print_errno("clearenv");
-      _exit(EXIT_FAILURE);
+  if (pid == 0)
+    forked(config, pipefd, pw, user, &session, envlist);
+  else {
+    struct child_msg msg;
+    read(pipefd[0], &msg, sizeof(struct child_msg));
+    close(pipefd[0]);
+    if (msg.err) {
+      errno = msg._errno;
+      print_errno(msg.msg);
+      return false;
     }
 
-    char **envlist = pam_getenvlist(pamh);
-    if (envlist == NULL) {
-      print_errno("pam_getenvlist");
-      _exit(EXIT_FAILURE);
-    }
-    for (size_t i = 0; envlist[i] != NULL; i++) {
-      putenv(envlist[i]);
-    }
-    // FIXME: path hotfix
-    putenv("PATH=/bin:/usr/bin");
-    if (TERM != NULL) {
-      setenv("TERM", TERM, true);
-      free(TERM);
-    }
+    if (cb) cb();
+    printf("\x1b[0m\x1b[H\x1b[J");
+    (void)fflush(stdout);
+    close(pipefd[1]);
 
-    free(envlist);
-    moarEnv(user, session, pw, behavior);
-
-    // TODO: chown stdin to user
-    // does it inherit stdin from parent and
-    // does parent need to reclaim it after
-    // this dies?
-
-    if (setgid(pw->pw_gid) == -1) {
-      print_errno("setgid");
-      _exit(EXIT_FAILURE);
-    }
-    if (initgroups(user, pw->pw_gid) == -1) {
-      print_errno("initgroups");
-      _exit(EXIT_FAILURE);
-    }
-
-    if (setuid(pw->pw_uid) == -1) {
-      perror("setuid");
-      _exit(EXIT_FAILURE);
-    }
-
-    if (cb != NULL)
-      cb();
-
-    *reach_session = true;
-
-    // TODO: these will be different due to TryExec
-    // and, Exec/TryExec might contain spaces as args
-    printf("\x1b[0m");
-    if (session.type == SHELL) {
-      clear_screen();
-      fflush(stdout);
-      execlp(session.exec, session.exec, NULL);
-    } else if (session.type == XORG || session.type == WAYLAND) {
-      clear_screen();
-      fflush(stdout);
-      execlp(session.exec, session.exec, NULL);
-    }
-    perror("execl error");
-    fprintf(stderr, "failure calling session\n");
-  } else {
-    waitpid(pid, NULL, 0);
+    int exit_code;
+    waitpid((pid_t)pid, &exit_code, 0);
 
     pam_setcred(pamh, PAM_DELETE_CRED);
     pam_close_session(pamh, 0);
     pam_end(pamh, PAM_SUCCESS);
 
-    if (*reach_session == false) {
-      return false;
-    } else
+    if (exit_code != 0) return false;
     exit(0);
   }
 
   return true;
 }
+// NOLINTEND(readability-function-cognitive-complexity)

src/chvt.c

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 
 #include "chvt.h"
+#include "macros.h"
 
 static char* vterms[] = {"/dev/tty", "/dev/tty0", "/dev/vc/0", "/dev/systty",
                          "/dev/console"};
@@ -11,26 +12,29 @@ static char *vterms[] = {"/dev/tty", "/dev/tty0", "/dev/vc/0", "/dev/systty",
 int chvt_str(char* str) {
   char* err;
   errno = 0;
+  // NOLINTNEXTLINE(readability-identifier-length)
   long i = strtol(str, &err, 10);
   if (errno) {
     perror("strol");
     return -1;
   }
   // I'm not gonna elaborate on this....
-  if (i > INT_MAX || i < INT_MIN || *err)
-    return -1;
+  if (i > INT_MAX || i < INT_MIN || *err) return -1;
 
   return chvt((int)i);
 }
 
+int vt = -1;
 int chvt(int n) {
-  fprintf(stderr, "activating vt %d\n", n);
+  (void)fprintf(stderr, "activating vt %d\n", n);
+  vt = n;
+  // NOLINTNEXTLINE(readability-identifier-length)
   char c = 0;
-  for (size_t i = 0; i < sizeof(vterms) / sizeof(vterms[0]); i++) {
+  for (size_t i = 0; i < LEN(vterms); i++) {
     int fd = open(vterms[i], O_RDWR);
     if (fd >= 0 && isatty(fd) && ioctl(fd, KDGKBTYPE, &c) == 0 && c < 3) {
       if (ioctl(fd, VT_ACTIVATE, n) < 0 || ioctl(fd, VT_WAITACTIVE, n) < 0) {
-        fprintf(stderr, "Couldn't activate vt %d\n", n);
+        (void)fprintf(stderr, "Couldn't activate vt %d\n", n);
         return -1;
       }
       return 0;
@@ -38,6 +42,7 @@ int chvt(int n) {
     close(fd);
   }
 
-  fprintf(stderr, "Couldn't get a file descriptor referring to the console.\n");
+  (void)fputs("Couldn't get a file descriptor referring to the console.\n",
+              stderr);
   return -1;
 }

src/config.c

@@ -1,143 +1,256 @@
+#include <errno.h>
+#include <linux/fs.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "config.h"
-#include "util.h"
+#include "desktop.h"
+#include "keys.h"
+#include "log.h"
+#include "macros.h"
+#include "util/vec.h"
 
-bool line_parser(FILE *fd, ssize_t *blksize,
-                 u_char (*cb)(char *key, char *value)) {
-  size_t opt_size = 4096;
-  if (blksize != NULL)
-    opt_size = *blksize;
+#define UPPER_HALF_BYTE 4
+int parse_hex(char* _at, char x1, char x2) {
+  // make linter happy
+  uint8_t* at = (uint8_t*)_at;
 
-  while (true) {
-    size_t alloc_size = opt_size;
-    char *buf = malloc(alloc_size);
-    if (buf == NULL)
-      return false;
-    ssize_t read_size = getline(&buf, &alloc_size, fd);
-    if (read_size == -1) {
-      free(buf);
+  *at = 0;
+
+  if ('0' <= x1 && x1 <= '9') {
+    *at += (x1 - '0') << UPPER_HALF_BYTE;
+  } else if ('A' <= x1 && x1 <= 'F') {
+    *at += (x1 - 'A' + 10) << UPPER_HALF_BYTE;
+  } else if ('a' <= x1 && x1 <= 'f') {
+    *at += (x1 - 'a' + 10) << UPPER_HALF_BYTE;
+  } else {
+    return -1;
+  }
+
+  if ('0' <= x2 && x2 <= '9') {
+    *at += (x2 - '0');
+  } else if ('A' <= x2 && x2 <= 'F') {
+    *at += (x2 - 'A' + 10);
+  } else if ('a' <= x2 && x2 <= 'f') {
+    *at += (x2 - 'a' + 10);
+  } else {
+    return -1;
+  }
+
+  return 0;
+}
+
+struct parser_error {
+  const char* NULLABLE msg;
+  size_t col;
+};
+
+#define FAIL(str)                \
+  return (struct parser_error) { \
+    str, p - raw                 \
+  }
+#define NOFAIL return (struct parser_error){NULL, 0}
+struct parser_error parse_str_inplace(char* raw) {
+  // reader pointer
+  char* p = raw; // NOLINT(readability-identifier-length)
+  if (*p != '"') FAIL("Strign not quoted");
+  p++;
+
+  // writer iterator, by nature will always be under the reader
+  size_t i = 0; // NOLINT(readability-identifier-length)
+  while (*p != '\0') {
+    if (*p == '"') {
+      if (p[1] == '\0') {
+        raw[i] = '\0';
+        NOFAIL;
+      }
+      FAIL("String finished but there's content after");
+    }
+    if (*p == '\\') {
+      p++;
+      if (*p == '\0') break;
+      switch (*p) {
+        case '\\':
+          raw[i++] = '\\';
+          break;
+        case 't':
+          raw[i++] = '\t';
+          break;
+        case 'n':
+          raw[i++] = '\n';
+          break;
+        case '\"':
+          raw[i++] = '\"';
+          break;
+        case '\'':
+          raw[i++] = '\'';
+          break;
+        case 'x':
+          if (p[1] == '\0' || p[2] == '\0') goto unfinished;
+          if (parse_hex(&raw[i++], p[1], p[2]) != 0)
+            FAIL("Invalid hex escape sequence");
+          p += 2;
+          break;
+        default:
+          FAIL("Invalid escape variant");
+      }
+    } else
+      raw[i++] = *p;
+
+    p++;
+  }
+
+unfinished:
+  FAIL("Unfinished string");
+}
+#undef FAIL
+#undef NOFAIL
+
+#define FAIL(str) return (struct parser_error){str, 0}
+#define NOFAIL return (struct parser_error){NULL, 0}
+union typ_ptr {
+  char** string;
+  long long* number;
+  bool* boolean;
+  enum Keys* key;
+  struct Vector* vec;
+  uintptr_t ptr;
+};
+struct parser_error parse_key(enum IntrospectionType typ, union typ_ptr at,
+                              char* key) {
+  char* aux_str = NULL;
+  struct parser_error aux_err;
+
+  switch (typ) {
+    case STRING:
+      aux_str = strdup(key);
+      if (!aux_str) FAIL("allocation failure");
+      aux_err = parse_str_inplace(aux_str);
+      if (aux_err.msg) {
+        free(aux_str);
+        return aux_err;
+      }
+      // FIXME: it be broken, prob the ptr arithmetic or smth, we mem leak
+      // instead 😎 If the ptr is not the default it means it was prev
+      // allocated, we should free if (*(char**)((uintptr_t)(&default_config) +
+      // offset) != *at.string) {
+      //   free(*at.string);
+      // }
+      *at.string = aux_str;
+      break;
+    case BOOL:
+      if (strcmp(key, "true") == 0)
+        *at.boolean = true;
+      else if (strcmp(key, "false") == 0)
+        *at.boolean = false;
+      else {
+        FAIL("Invalid key value, wasn't 'true' nor 'false'");
+      }
+      break;
+    case NUMBER:
+      errno = 0;
+      *at.number = strtol(key, NULL, 10);
+      if (errno) {
+        FAIL("strtol failed");
+      }
+      break;
+    case KEY:
+      // NOLINTNEXTLINE(performance-no-int-to-ptr)
+      if (find_keyname(at.key, key) != 0) {
+        FAIL("Keyboard KEY name not found");
+      }
+      break;
+    case STRING_ARRAY:
+      aux_str = strdup(key);
+      if (!aux_str) FAIL("allocation failure");
+      aux_err = parse_str_inplace(aux_str);
+      if (aux_err.msg) {
+        free(aux_str);
+        return aux_err;
+      }
+      vec_push(at.vec, aux_str);
       break;
   }
 
-    uint read;
-    char *key = malloc(read_size);
-    if (key == NULL) {
-      free(buf);
-      return false;
+  NOFAIL;
 }
-    if ((read = sscanf(buf, "%[^ ] = %[^\n]\n", key, buf)) != 0) {
-      u_char ret = cb(key, buf);
-      if (ret & 0b0100)
-        free(key);
-      if (ret & 0b0010)
-        free(buf);
-      if (ret & 0b1000)
-        return false;
-      if (ret & 0b0001)
+#undef FAIL
+#undef NOFAIL
+
+// NOLINTBEGIN(readability-identifier-length,readability-function-cognitive-complexity)
+struct status config_line_handler(void* _config, char* table, char* k,
+                                  char* v) {
+  struct config* config = (struct config*)_config;
+  struct status ret = {.finish = false};
+
+  const struct introspection_table* this_intros_table = NULL;
+  for (size_t i = 0; i < LEN(CONFIG_INSTROSPECTION); i++) {
+    if (table == NULL) {
+      if (table != CONFIG_INSTROSPECTION[i].tname) continue;
+    } else if (strcmp(CONFIG_INSTROSPECTION[i].tname, table) != 0)
+      continue;
+    this_intros_table = &CONFIG_INSTROSPECTION[i];
     break;
   }
+  if (this_intros_table == NULL) {
+    log_printf("[E] table '%s' is not part of the config\n", table);
+    return ret;
   }
 
-  return true;
+  const struct introspection_item* this_intros_key = NULL;
+  for (size_t i = 0; i < this_intros_table->len; i++) {
+    if (strcmp(this_intros_table->intros[i].name, k) != 0) continue;
+    this_intros_key = &this_intros_table->intros[i];
+    break;
+  }
+  if (this_intros_key == NULL) {
+    log_printf("[E] key '%s' is not part of the table '%s' in config\n", k,
+               table);
+    return ret;
   }
 
-struct config *__config;
-u_char config_line_handler(char *k, char *v) {
-  if (strcmp(k, "colors.bg") == 0)
-    __config->theme.colors.bg = v;
-  else if (strcmp(k, "colors.fg") == 0)
-    __config->theme.colors.fg = v;
-  else if (strcmp(k, "colors.err") == 0)
-    __config->theme.colors.err = v;
-  else if (strcmp(k, "colors.s_wayland") == 0)
-    __config->theme.colors.s_wayland = v;
-  else if (strcmp(k, "colors.s_xorg") == 0)
-    __config->theme.colors.s_xorg = v;
-  else if (strcmp(k, "colors.s_shell") == 0)
-    __config->theme.colors.s_shell = v;
-  else if (strcmp(k, "colors.e_hostname") == 0)
-    __config->theme.colors.e_hostname = v;
-  else if (strcmp(k, "colors.e_date") == 0)
-    __config->theme.colors.e_date = v;
-  else if (strcmp(k, "colors.e_box") == 0)
-    __config->theme.colors.e_box = v;
-  else if (strcmp(k, "colors.e_header") == 0)
-    __config->theme.colors.e_header = v;
-  else if (strcmp(k, "colors.e_user") == 0)
-    __config->theme.colors.e_user = v;
-  else if (strcmp(k, "colors.e_passwd") == 0)
-    __config->theme.colors.e_passwd = v;
-  else if (strcmp(k, "colors.e_badpasswd") == 0)
-    __config->theme.colors.e_badpasswd = v;
-  else if (strcmp(k, "colors.e_key") == 0)
-    __config->theme.colors.e_key = v;
-  else if (strcmp(k, "chars.hb") == 0)
-    __config->theme.chars.hb = v;
-  else if (strcmp(k, "chars.vb") == 0)
-    __config->theme.chars.vb = v;
-  else if (strcmp(k, "chars.ctl") == 0)
-    __config->theme.chars.ctl = v;
-  else if (strcmp(k, "chars.ctr") == 0)
-    __config->theme.chars.ctr = v;
-  else if (strcmp(k, "chars.cbl") == 0)
-    __config->theme.chars.cbl = v;
-  else if (strcmp(k, "chars.cbr") == 0)
-    __config->theme.chars.cbr = v;
-  else if (strcmp(k, "functions.poweroff") == 0)
-    __config->functions.poweroff = find_keyname(v);
-  else if (strcmp(k, "functions.reboot") == 0)
-    __config->functions.reboot = find_keyname(v);
-  else if (strcmp(k, "functions.refresh") == 0)
-    __config->functions.refresh = find_keyname(v);
-  else if (strcmp(k, "strings.f_poweroff") == 0)
-    __config->strings.f_poweroff = v;
-  else if (strcmp(k, "strings.f_reboot") == 0)
-    __config->strings.f_reboot = v;
-  else if (strcmp(k, "strings.f_refresh") == 0)
-    __config->strings.f_refresh = v;
-  else if (strcmp(k, "strings.e_user") == 0)
-    __config->strings.e_user = v;
-  else if (strcmp(k, "strings.e_passwd") == 0)
-    __config->strings.e_passwd = v;
-  else if (strcmp(k, "strings.s_wayland") == 0)
-    __config->strings.s_wayland = v;
-  else if (strcmp(k, "strings.s_xorg") == 0)
-    __config->strings.s_xorg = v;
-  else if (strcmp(k, "strings.s_shell") == 0)
-    __config->strings.s_shell = v;
-  else if (strcmp(k, "behavior.include_defshell") == 0)
-    __config->behavior.include_defshell = strcmp(v, "true") == 0;
-  else if (strcmp(k, "behavior.source") == 0)
-    vec_push(&__config->behavior.source, v);
-  else if (strcmp(k, "behavior.user_source") == 0)
-    vec_push(&__config->behavior.user_source, v);
+  size_t offset = this_intros_table->offset + this_intros_key->offset;
+  union typ_ptr k_addr = {.ptr = (uintptr_t)config + offset};
+
+  log_printf("[I] parsing [%s.%s] as %s\n", table, k,
+             INTROS_TYS_NAMES[this_intros_key->typ]);
+  struct parser_error err = parse_key(this_intros_key->typ, k_addr, v);
+  if (err.msg != NULL) {
+    log_printf("[E] cfg parser, failed to parse [%s.%s] (%s): %s\n", table, k,
+               INTROS_TYS_NAMES[this_intros_key->typ], err.msg);
+    log_printf("%s\n%*c^\n", v, err.col);
+    return ret;
+  }
+
+  if (this_intros_key->typ == NUMBER)
+    log_printf("[I] cfg parsed [%s.%s] (%lld)\n", table, k, *k_addr.number);
+  else if (this_intros_key->typ == STRING)
+    log_printf("[I] cfg parsed [%s.%s] (%s)\n", table, k, *k_addr.string);
   else
-    return 0b1111;
+    log_printf("[I] cfg parsed [%s.%s]\n", table, k);
 
-  return 0b100;
+  return ret;
 }
+// NOLINTEND(readability-identifier-length,readability-function-cognitive-complexity)
 
-struct config *parse_config(char *path) {
-  struct stat sb;
+int parse_config(struct config* NNULLABLE config, char* NNULLABLE path) {
   FILE* fd = fopen(path, "r");
-  if (fd == NULL || (stat(path, &sb) == -1)) {
-    perror("fopen");
-    return NULL;
+  if (fd == NULL) {
+    log_perror("fopen");
+    log_printf(" [I] No config, place one at " LIDM_CONF_PATH
+               " or set the LIDM_CONF env variable\n");
+    return 0; // Its fine now anyways
   }
 
-  __config = malloc(sizeof(struct config));
-  __config->behavior.source = vec_new();
-  __config->behavior.user_source = vec_new();
+  bool ret = read_desktop(fd, config, config_line_handler);
+  (void)fclose(fd);
 
-  if (__config == NULL)
-    return NULL;
-  bool ret = line_parser(fd, (ssize_t *)&sb.st_blksize, config_line_handler);
-  if (!ret) {
-    free(__config);
-    return NULL;
-  }
-
-  return __config;
+  if (!ret) return -1;
+  return 0;
 }

src/desktop.c

@@ -0,0 +1,84 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "desktop.h"
+
+char* trim_str(char* str) {
+  while (*str == ' ' || *str == '\t')
+    str++;
+
+  size_t i = strlen(str); // NOLINT(readability-identifier-length)
+  while (i > 0) {
+    if (str[i - 1] != ' ' && str[i - 1] != '\t' && str[i - 1] != '\n') break;
+    i--;
+  }
+  str[i] = '\0';
+
+  return str;
+}
+
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
+int read_desktop(FILE* fd, void* ctx,
+                 struct status (*cb)(void* ctx, char* table, char* key,
+                                     char* value)) {
+  char* table_name = NULL;
+
+  bool ret = -1;
+  char* buf = NULL;
+  size_t alloc_size = 0;
+  size_t read_size;
+  while ((read_size = getline(&buf, &alloc_size, fd)) > 0) {
+    ret = 0;
+
+    char* buf_start = trim_str(buf);
+    size_t indent_size = buf_start - buf;
+
+    if (read_size - indent_size < 1) continue;
+    if (*buf_start == '#') continue;
+
+    if (*buf_start == '[' && buf_start[strlen(buf_start) - 1] == ']') {
+      if (table_name != NULL) free(table_name);
+      buf_start[strlen(buf_start) - 1] = '\0';
+      table_name = strdup(buf_start + 1);
+      if (table_name == NULL) {
+        ret = -1;
+        break;
+      }
+    } else {
+      // Find '='
+      size_t eq_idx = 0;
+      while (buf_start[eq_idx] != '\0') {
+        if (buf_start[eq_idx] == '=') break;
+        eq_idx++;
+      }
+      // impossible with a min len of 1 (empty line)
+      if (eq_idx == 0) continue;
+      // Check its not end
+      if (buf_start[eq_idx] != '=') {
+        ret = -1;
+        break;
+      }
+
+      // Key & Value
+      char* key = buf_start;
+      buf_start[eq_idx] = '\0'; // the equal
+      key = trim_str(key);
+      char* value = &buf_start[eq_idx + 1];
+      if (buf_start[read_size - 1] == '\n') buf_start[read_size - 1] = '\0';
+      value = trim_str(value);
+
+      // Callback
+      struct status cb_ret = cb(ctx, table_name, key, value);
+      if (cb_ret.finish) {
+        ret = cb_ret.ret;
+        break;
+      }
+    }
+  }
+
+  if (table_name != NULL) free(table_name);
+  if (buf != NULL) free(buf);
+  return ret;
+}

src/desktop_exec.c

@@ -0,0 +1,220 @@
+// TODO: rewrite properly
+// NOLINTBEGIN(clang-diagnostic-nullability-completeness)
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "desktop_exec.h"
+#include "macros.h"
+#include "util/path.h"
+
+// constants for exec string parsing
+#define MAX_ARGS 100
+// ARG_LENGTH is the initial length of a parsed argument
+#define ARG_LENGTH 64
+
+char* NULLABLE desktop_as_cmdline(char** args) {
+  if (args[0] == NULL) return NULL;
+  size_t fmtd_len = 0;
+
+  char** ptr = args;
+  while (*ptr) {
+    fmtd_len += strlen(*ptr) + 1;
+    ptr++;
+  }
+  fmtd_len -= 1;
+
+  char* fmt_cmdline = malloc(fmtd_len + 1);
+  if (!fmt_cmdline) return NULL;
+
+  size_t fmting_len = 0;
+  ptr = args;
+  while (*ptr) {
+    char* nbyte = stpcpy(&fmt_cmdline[fmting_len], *ptr);
+    *nbyte = ' ';
+
+    fmting_len += nbyte - &fmt_cmdline[fmting_len] + 1;
+    ptr++;
+  }
+  fmt_cmdline[fmting_len - 1] = '\0';
+
+  return fmt_cmdline;
+}
+
+// parse Exec=/bin/prog arg1 arg2\ with\ spaces
+void free_parsed_args(int arg_count, char** args) {
+  if (!args) return;
+  for (int i = 0; i < arg_count; i++) {
+    free(args[i]);
+  }
+  free((void*)args);
+}
+
+/* small closure-like struct to pass state to helper functions */
+struct ctx {
+  char** pcur;
+  size_t* pcur_len;
+  size_t* pcur_cap;
+  char*** pargv;
+  int* pargc;
+};
+/* append_char(state, ch) -> 0 on error, 1 on success */
+int append_char(struct ctx* st, char ch) {
+  char** pcur = st->pcur;
+  size_t* plen = st->pcur_len;
+  size_t* pcap = st->pcur_cap;
+  if (*plen + 1 >= *pcap) {
+    size_t newcap = *pcap ? (*pcap) * 2 : ARG_LENGTH;
+    char* cur = (char*)realloc(*pcur, newcap);
+    if (!cur) return 0;
+    *pcur = cur;
+    *pcap = newcap;
+  }
+  (*pcur)[(*plen)++] = ch;
+  return 1;
+}
+
+/* push_arg(state) -> 0 on error, 1 on success */
+int push_arg(struct ctx* st) {
+  char** pcur = st->pcur;
+  size_t* plen = st->pcur_len;
+  size_t* pcap = st->pcur_cap;
+  char*** pargv = st->pargv;
+  int* pargc = st->pargc;
+
+  if (*pargc > MAX_ARGS) {
+    return 1;
+  }
+  if (!*pcur) {
+    char* empty = strdup("");
+    if (!empty) return 0;
+    char** na = (char**)realloc((void*)*pargv, sizeof(char*) * ((*pargc) + 1));
+    if (!na) {
+      free(empty);
+      return 0;
+    }
+    *pargv = na;
+    (*pargv)[(*pargc)++] = empty;
+    return 1;
+  }
+  if (!append_char(st, '\0')) return 0;
+  char* final = (char*)realloc(*pcur, *plen);
+  if (!final) final = *pcur;
+  *pcur = NULL;
+  *plen = 0;
+  *pcap = 0;
+  char** na = (char**)realloc((void*)*pargv, sizeof(char*) * ((*pargc) + 1));
+  if (!na) {
+    free(final);
+    return 0;
+  }
+  *pargv = na;
+  (*pargv)[(*pargc)++] = final;
+  return 1;
+}
+
+/* Return codes:
+   0 = success
+   1 = bad args
+   2 = memory
+   3 = syntax
+  Important: call free_parsed_args afterwards to free the passed ***args
+*/
+
+// NOLINTBEGIN(readability-function-cognitive-complexity)
+int parse_exec_string(const char* exec_s, int* arg_count, char*** args) {
+  if (!exec_s || !args || !arg_count) return 1;
+  *args = NULL;
+  *arg_count = 0;
+
+  size_t len = strlen(exec_s);
+  size_t idx = 0;
+  char* cur = NULL;
+  size_t cur_len = 0;
+  size_t cur_cap = 0;
+  char** argv = NULL;
+  int argc = 0;
+  int in_quote = 0;
+
+  struct ctx ctx;
+  ctx.pcur = &cur;
+  ctx.pcur_len = &cur_len;
+  ctx.pcur_cap = &cur_cap;
+  ctx.pargv = &argv;
+  ctx.pargc = &argc;
+
+  while (idx < len) {
+    char cur_c = exec_s[idx];
+    if (!in_quote && (cur_c == ' ' || cur_c == '\t' || cur_c == '\n')) {
+      if (cur_cap) {
+        if (!push_arg(&ctx)) goto nomem;
+      }
+      idx++;
+      continue;
+    }
+    if (!in_quote && cur_c == '"') {
+      in_quote = 1;
+      idx++;
+      continue;
+    }
+    if (in_quote && cur_c == '"') {
+      in_quote = 0;
+      idx++;
+      continue;
+    }
+
+    if (cur_c == '\\') {
+      if (idx + 1 >= len) goto syntax_err;
+      if (!append_char(&ctx, exec_s[idx + 1])) goto nomem;
+      idx += 2;
+      continue;
+    }
+
+    if (cur_c == '%') {
+      if (idx + 1 >= len) goto syntax_err;
+      if (exec_s[idx + 1] == '%') {
+        if (!append_char(&ctx, '%')) goto nomem;
+        idx += 2;
+        continue;
+      }
+      /* drop any %X */
+      idx += 2;
+      continue;
+    }
+
+    if (!append_char(&ctx, cur_c)) goto nomem;
+    idx++;
+  }
+
+  if (in_quote) goto syntax_err;
+  if (cur_cap) {
+    if (!push_arg(&ctx)) goto nomem;
+  }
+  char** na = (char**)realloc((void*)argv, sizeof(char*) * (argc + 1));
+  if (!na) goto nomem;
+  argv = na;
+  argv[argc] = NULL;
+
+  *args = argv;
+  *arg_count = argc;
+  return 0;
+
+nomem:
+  if (cur) free(cur);
+  free_parsed_args(argc, argv);
+  *args = NULL;
+  *arg_count = 0;
+  return 2;
+
+syntax_err:
+  if (cur) free(cur);
+  free_parsed_args(argc, argv);
+  *args = NULL;
+  *arg_count = 0;
+  return 3;
+}
+// NOLINTEND(readability-function-cognitive-complexity)
+// NOLINTEND(clang-diagnostic-nullability-completeness)

src/efield.c

@@ -2,77 +2,79 @@
 
 #include "efield.h"
 #include "ui.h"
+#include "util/utf8.h"
 
-struct editable_field field_new(char *content) {
-  struct editable_field __efield;
+struct editable_field efield_new(char* content) {
+  struct editable_field efield;
   if (content != NULL) {
-    __efield.length = __efield.pos = strlen(content);
-    memcpy(__efield.content, content, __efield.length);
+    efield.pos = strlen(content);
+    memcpy(efield.content, content, strlen(content) + 1);
   } else {
-    field_trim(&__efield, 0);
-  }
-  __efield.content[__efield.length] = '\0';
-  return __efield;
+    efield_trim(&efield, 0);
   }
 
-void field_trim(struct editable_field *field, u_char pos) {
-  field->length = field->pos = pos;
-  field->content[field->length] = '\0';
+  return efield;
 }
 
-void field_update(struct editable_field *field, char *update) {
-  u_char insert_len = strlen(update);
-  if (insert_len == 0)
-    return;
+void efield_trim(struct editable_field* self, uint8_t pos) {
+  self->pos = pos;
+  self->content[pos + 1] = '\0';
+}
+
+#define BACKSPACE_CODE 127
+void efield_update(struct editable_field* self, char* update) {
+  uint8_t insert_len = strlen(update);
+  if (insert_len == 0) return;
+
+  if (self->pos > strlen(self->content))
+    self->pos = strlen(self->content); // WTF tho
 
-  if (field->pos > field->length)
-    field->pos = field->length; // WTF
   if (insert_len == 1) {
     // backspace
-    if (*update == 127) {
-      if (field->pos == 0)
-        return;
-      if (field->pos < field->length) {
-        memmove(&field->content[field->pos - 1], &field->content[field->pos],
-                field->length - field->pos);
-      }
-      (field->pos)--;
-      (field->length)--;
-      field->content[field->length] = '\0';
+    if (*update == BACKSPACE_CODE) {
+      if (self->pos == 0) return;
+      char* curr = &self->content[self->pos];
+      char* prev = (char*)utf8back(curr);
+      memmove(prev, curr, strlen(self->content) - self->pos + 1);
+
+      self->pos -= curr - prev;
       return;
     }
+    // TODO: Del
   }
 
   // append
-  if (field->length + field->pos >= 255) {
+  if (strlen(update) + self->pos + 1 >= 255) {
     print_err("field too long");
   }
-  if (field->pos < field->length) {
-    // move with immediate buffer
-    memmove(&field->content[field->pos + insert_len],
-            &field->content[field->pos], field->length - field->pos);
-  }
-  memcpy(&field->content[field->pos], update, insert_len);
 
-  field->pos += insert_len;
-  field->length += insert_len;
-  field->content[field->length] = '\0';
+  // move the after pos, including nullbyte
+  memmove(&self->content[self->pos + insert_len], &self->content[self->pos],
+          strlen(self->content) - self->pos + 1);
+  memcpy(&self->content[self->pos], update, insert_len);
+
+  self->pos += insert_len;
 }
 
 // returns bool depending if it was able to "use" the seek
-bool field_seek(struct editable_field *field, char seek) {
-  if (field->length == 0)
-    return false;
+bool efield_seek(struct editable_field* self, char seek) {
+  if (*self->content == '\0') return false;
+  if (seek == 0) return false;
 
-  if (seek < 0 && -seek > field->pos)
-    field->pos = 0;
-  else if (seek > 0 && 255 - field->pos < seek)
-    field->pos = 255;
-  else
-    field->pos += seek;
+  uint8_t count = seek < 0 ? -seek : seek;
+  char* ptr = &self->content[self->pos];
+  char* start = ptr;
 
-  if (field->pos > field->length)
-    field->pos = field->length;
-
-  return true;
+  while (count-- > 0) {
+    if (seek < 0) {
+      if (ptr == self->content) break;
+      ptr = (char*)utf8back(ptr);
+    } else {
+      if (*ptr == '\0') break;
+      ptr = (char*)utf8seek(ptr);
+    }
+  }
+
+  self->pos = (uint8_t)(ptr - self->content);
+  return ptr != start;
 }

src/keys.c

@@ -0,0 +1,77 @@
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "keys.h"
+#include "macros.h"
+#include "ui.h"
+
+static int selret_magic();
+
+int find_keyname(enum Keys* at, const char* name) {
+  for (size_t i = 0; i < LEN(KEY_MAPPINGS); i++) {
+    if (strcmp(KEY_NAMES[i], name) == 0) {
+      *at = (enum Keys)i;
+      return 0;
+    }
+  }
+
+  return -1;
+}
+
+struct option_keys find_ansi(const char* seq) {
+  for (size_t i = 0; i < LEN(KEY_MAPPINGS); i++) {
+    struct key_mapping mapping = KEY_MAPPINGS[i];
+    for (size_t j = 0; mapping.sequences[j] != NULL; j++) {
+      if (strcmp(mapping.sequences[j], seq) == 0) {
+        return (struct option_keys){
+            .is_some = true,
+            .key = (enum Keys)i,
+        };
+      }
+    }
+  }
+  return (struct option_keys){.is_some = false};
+}
+
+void read_press(uint8_t* length, char* out) {
+  *length = 0;
+
+  while (true) {
+    if (read(STDIN_FILENO, &out[(*length)++], 1) != 1) {
+      print_errno("read error");
+      sleep(3);
+      exit(1);
+    }
+    int selret = selret_magic();
+    if (selret == -1) {
+      print_errno("selret error");
+    } else if (selret != 1) {
+      out[*length] = '\0';
+      return;
+    }
+  }
+}
+
+bool read_press_nb(uint8_t* length, char* out, struct timeval* tv) {
+  fd_set fds;
+  FD_ZERO(&fds);
+  FD_SET(STDIN_FILENO, &fds);
+  errno = 0;
+  int ret = select(STDIN_FILENO + 1, &fds, NULL, NULL, tv);
+  if (errno || ret <= 0) return false;
+
+  read_press(length, out);
+  return true;
+}
+
+// https://stackoverflow.com/a/48040042
+static int selret_magic() {
+  fd_set set;
+  struct timeval timeout;
+  FD_ZERO(&set);
+  FD_SET(STDIN_FILENO, &set);
+  timeout.tv_sec = 0;
+  timeout.tv_usec = 0;
+  return select(1, &set, NULL, NULL, &timeout);
+}

src/launch_state.c

@@ -0,0 +1,54 @@
+// Small file for saving last selection
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "launch_state.h"
+
+#define STATE_DIR "/var/lib/lidm"
+#define STATE_FILE "/var/lib/lidm/state"
+
+#define RWXR_X___ 0750
+
+int read_launch_state(struct LaunchState* NNULLABLE state) {
+  FILE* state_fd = fopen(STATE_FILE, "r");
+  if (state_fd == NULL) return -1;
+
+  *state = (struct LaunchState){
+      .username = NULL,
+      .session_opt = NULL,
+  };
+
+  size_t num = 0;
+  ssize_t chars = getline(&state->username, &num, state_fd);
+  if (chars < 0) goto fail;
+  if (state->username[chars] == '\n') state->username[chars] = 0;
+
+  num = 0;
+  chars = getline(&state->session_opt, &num, state_fd);
+  if (chars < 0) {
+    free(state->session_opt);
+    goto fail;
+  }
+  if (state->session_opt[chars] == '\n') state->session_opt[chars] = 0;
+
+  (void)fclose(state_fd);
+  return 0;
+
+fail:
+  (void)fclose(state_fd);
+  return -1;
+}
+
+bool write_launch_state(struct LaunchState state) {
+  FILE* state_fd = fopen(STATE_FILE, "w");
+  if (state_fd == NULL) {
+    if (mkdir(STATE_DIR, RWXR_X___) == -1) return false;
+    state_fd = fopen(STATE_FILE, "w");
+    if (state_fd == NULL) return false;
+  }
+  (void)fprintf(state_fd, "%s\n%s\n", state.username, state.session_opt);
+  (void)fclose(state_fd);
+  return true;
+}

src/log.c

@@ -0,0 +1,39 @@
+#include <errno.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "log.h"
+
+static FILE* logger_out = NULL;
+
+void log_init(FILE* fd) {
+  if (logger_out) (void)fclose(logger_out);
+  (void)setvbuf(fd, NULL, _IONBF, 0);
+  logger_out = fd;
+}
+
+void log_puts(const char* msg) {
+  if (!logger_out) return;
+  (void)fputs(msg, logger_out);
+}
+
+void log_printf(const char* fmt, ...) {
+  if (!logger_out) return;
+
+  va_list args;
+  va_start(args, fmt);
+
+  (void)vfprintf(logger_out, fmt, args);
+
+  va_end(args);
+}
+
+// NOLINTNEXTLINE(readability-identifier-length)
+void log_perror(const char* s) {
+  if (!logger_out) return;
+
+  if (s)
+    (void)fprintf(logger_out, "%s: %s\n", s, strerror(errno));
+  else
+    (void)fprintf(logger_out, "%s\n", strerror(errno));
+}

src/main.c

@@ -1,33 +1,94 @@
 #include <pwd.h>
 #include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
+#include <time.h>
 #include <unistd.h>
 
 #include "chvt.h"
 #include "config.h"
+#include "log.h"
+#include "macros.h"
 #include "sessions.h"
+#include "signal_handler.h"
 #include "ui.h"
 #include "users.h"
-#include "util.h"
+#include "util/vec.h"
+
+#define DATESTR_MAXBUFSIZE 0x20
 
 int main(int argc, char* argv[]) {
-  if (argc == 2)
-    chvt_str(argv[1]);
+  // Logger
+  char* log_output = getenv("LIDM_LOG");
+  if (log_output) {
+    FILE* log_fd = fopen(log_output, "w");
+    if (!log_fd) {
+      perror("fopen");
+      (void)fputs("failed to open logfile in write mode", stderr);
+      return -1;
+    }
 
+    log_init(log_fd);
+    log_puts("Starting log:");
+  }
+
+  if (argc == 2) {
+    if (strcmp(argv[1], "-v") == 0 || strcmp(argv[1], "--version") == 0) {
+      // NOLINTBEGIN(clang-analyzer-deadcode.DeadStores)
+      char* version = "?";
+      char* revision = "?";
+      char* builddate = "?";
+      char* compilever = "?";
+      // NOLINTEND(clang-analyzer-deadcode.DeadStores)
+#ifdef LIDM_VERSION
+      version = LIDM_VERSION;
+#endif
+#ifdef LIDM_GIT_REV
+      revision = LIDM_GIT_REV;
+#endif
+#ifdef LIDM_BUILD_TS
+      time_t ts = LIDM_BUILD_TS;
+      char date_buf[DATESTR_MAXBUFSIZE];
+      builddate = date_buf;
+      if (strftime(date_buf, 0xff, "%Y-%m-%dT%H:%M:%SZ", localtime(&ts)) > 0)
+        builddate = date_buf;
+#endif
+#ifdef COMPILER_VERSION
+      compilever = COMPILER_VERSION;
+#endif
+      printf("lidm version %s (git %s, build date %s, compiler %s)\n", version,
+             revision, builddate, compilever);
+      return 0;
+    }
+    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
+      printf(
+          "Usage: lidm [vt number]\n"
+          "Options:\n"
+          "  -h, --help     Display help menu\n"
+          "  -v, --version  Display version information\n");
+      return 0;
+    }
+    // Chvt
+    chvt_str(argv[1]);
+  }
+
+  // Copy
+  struct config config = DEFAULT_CONFIG;
   char* conf_override = getenv("LIDM_CONF");
-  struct config *config =
-      parse_config(conf_override == NULL ? "/etc/lidm.ini" : conf_override);
-  if (config == NULL) {
-    fprintf(stderr, "error parsing config\n");
+  char* conf_path = conf_override ? conf_override : LIDM_CONF_PATH;
+  if (parse_config(&config, conf_path) != 0) {
+    (void)fputs("error parsing config\n", stderr);
     return 1;
   }
-  setup(*config);
+  setup(&config);
 
   struct Vector users = get_human_users();
   struct Vector sessions = get_avaliable_sessions();
 
+  setup_sigterm();
+
   int ret = load(&users, &sessions);
-  if (ret == 0)
-    execl(argv[0], argv[0], NULL);
+  if (ret == 0) execl(argv[0], argv[0], NULL);
 }

src/ofield.c

@@ -0,0 +1,76 @@
+#include <stddef.h>
+
+#include "efield.h"
+#include "ofield.h"
+#include "ui.h"
+#include "util/utf8.h"
+
+struct opts_field ofield_new(size_t opts) {
+  if (opts == 0) {
+    return (struct opts_field){
+        .opts = 0,
+        .current_opt = 0,
+        .efield = efield_new(""),
+    };
+  }
+
+  return (struct opts_field){
+      .opts = opts,
+      .current_opt = 1,
+  };
+}
+
+void ofield_toedit(struct opts_field* self, char* init) {
+  self->current_opt = 0;
+  self->efield = efield_new(init);
+}
+
+void ofield_kbd_type(struct opts_field* self, char* typed,
+                     char* empty_default) {
+  if (self->current_opt != 0) ofield_toedit(self, empty_default);
+  efield_update(&self->efield, typed);
+}
+
+bool ofield_opts_seek(struct opts_field* self, char seek) {
+  // no options or (a single option but its selected instead of on edit)
+  if (self->opts == 0 || (self->opts == 1 && self->current_opt != 0))
+    return false;
+
+  self->current_opt =
+      1 + ((self->current_opt - 1 + seek + self->opts) % self->opts);
+  ui_update_ofield(self);
+  return true;
+}
+
+bool ofield_seek(struct opts_field* self, char seek) {
+  if (self->current_opt == 0) {
+    if (efield_seek(&self->efield, seek)) {
+      return true;
+    }
+  }
+
+  if (self->opts == 0) return false;
+  ofield_opts_seek(self, seek);
+  return true;
+}
+
+uint8_t ofield_display_cursor_col(struct opts_field* self, uint8_t maxlen) {
+  if (self->current_opt == 0) {
+    uint8_t display_len = utf8len(self->efield.content);
+    uint8_t pos = utf8len_until(self->efield.content,
+                                &self->efield.content[self->efield.pos]);
+
+    if (display_len > maxlen) {
+      if (pos < maxlen / 2) {
+        return pos;
+      }
+      if (display_len - pos < maxlen / 2) {
+        return maxlen - (display_len - pos);
+      }
+      return maxlen / 2;
+    }
+
+    return pos;
+  }
+  return 0;
+}

src/pam.c

@@ -0,0 +1,197 @@
+#include <pwd.h>
+#include <security/_pam_types.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "log.h"
+#include "macros.h"
+#include "pam.h"
+#include "sessions.h"
+#include "ui.h"
+
+struct envpair {
+  const char* NNULLABLE name;
+  char* NULLABLE value;
+};
+
+char* NULLABLE make_env_kv(const char* NNULLABLE key, char* NNULLABLE value) {
+  char* buf = NULL;
+  asprintf(&buf, "%s=%s", key, value);
+  return buf;
+}
+
+void free_envlist(char** NNULLABLE envlist) {
+  for (char** ptr = envlist; *ptr; ptr++)
+    free(*ptr);
+  free((void*)envlist);
+}
+
+// NULL when allocation failure
+// in any case, envlist would be freed after this function
+char** NULLABLE merge_envlist(char** NNULLABLE envlist, struct envpair extra[],
+                              size_t extra_len) {
+  size_t envlist_len = 0;
+  while (envlist[envlist_len])
+    envlist_len++;
+
+  size_t nonnullelems = 0;
+  for (size_t i = 0; i < extra_len; i++) {
+    if (extra[i].value) nonnullelems++;
+  }
+
+  size_t new_envlist_len = envlist_len + nonnullelems + 1;
+  char** new_envlist =
+      (char**)realloc((void*)envlist, sizeof(char*) * new_envlist_len);
+  if (!new_envlist) {
+    free_envlist(envlist);
+    return NULL;
+  }
+
+  // NOLINTNEXTLINE(readability-identifier-length)
+  size_t k = 0;
+  for (size_t i = 0; i < extra_len; i++) {
+    if (!extra[i].value) continue;
+    char* env_kv = make_env_kv(extra[i].name, extra[i].value);
+    if (!env_kv) goto free_new_envlist_extra;
+    new_envlist[envlist_len + k++] = env_kv;
+  }
+
+  new_envlist[envlist_len + nonnullelems] = NULL;
+  return new_envlist;
+
+free_new_envlist_extra:
+  for (size_t j = 0; j < envlist_len + k; j++) {
+    free(new_envlist[envlist_len + j]);
+  }
+  free((void*)new_envlist);
+  return NULL;
+}
+
+char* NULLABLE xdg_ssession_type_str(enum SessionType typ) {
+  char* xdg_session_type = NULL;
+  if (typ == SHELL) xdg_session_type = "tty";
+  if (typ == XORG) xdg_session_type = "x11";
+  if (typ == WAYLAND) xdg_session_type = "wayland";
+  return xdg_session_type;
+}
+
+#define FAIL_ALLOC()                                                  \
+  {                                                                   \
+    return (struct pamh_getenv_status){.error_flag = PAMH_ERR_ALLOC}; \
+  }
+#define FAIL(ERR, ERRFN)                                                       \
+  {                                                                            \
+    return (struct pamh_getenv_status){.error_flag = (ERR), .errfn = (ERRFN)}; \
+  }
+
+struct pamh_getenv_status pamh_get_complete_env(pam_handle_t* handle,
+                                                struct passwd* NNULLABLE pw,
+                                                enum SessionType session_typ) {
+  char** raw_envlist = pam_getenvlist(handle);
+  if (!raw_envlist) FAIL(PAMH_ERR_ERRNO, "pam_getenvlist");
+
+  char** ptr = raw_envlist;
+  while (*ptr)
+    log_printf("[I] got pam env %s\n", *(ptr++));
+
+  struct envpair extra_env[] = {
+      {"TERM", getenv("TERM")},
+      {"PATH", getenv("PATH")},
+      {"HOME", pw->pw_dir},
+      {"USER", pw->pw_name},
+      {"SHELL", pw->pw_shell},
+      {"LOGNAME", pw->pw_name},
+      {"XDG_SESSION_TYPE", xdg_ssession_type_str(session_typ)}};
+
+  char** envlist = merge_envlist(raw_envlist, extra_env, LEN(extra_env));
+  if (!envlist) FAIL_ALLOC();
+  return (struct pamh_getenv_status){
+      .error_flag = PAMH_ERR_NOERR,
+      .envlist = envlist,
+  };
+}
+
+#undef FAIL
+#undef FAIL_ALLOC
+
+///////////////
+
+struct pam_conv_data {
+  char* password;
+  void (*display_pam_msg)(const char* msg, int msg_style);
+};
+
+int pam_conversation(int num_msg, const struct pam_message** msg,
+                     struct pam_response** resp, void* appdata_ptr) {
+  struct pam_response* reply = malloc(sizeof(struct pam_response) * num_msg);
+  if (!reply) {
+    return PAM_BUF_ERR;
+  }
+
+  struct pam_conv_data* conv_data = (struct pam_conv_data*)appdata_ptr;
+
+  for (int i = 0; i < num_msg; i++) {
+    reply[i].resp = NULL;
+    reply[i].resp_retcode = 0;
+
+    switch (msg[i]->msg_style) {
+      case PAM_PROMPT_ECHO_OFF:
+      case PAM_PROMPT_ECHO_ON:
+        reply[i].resp = strdup(conv_data->password);
+        if (!reply[i].resp) {
+          for (int j = 0; j < i; j++)
+            free(reply[j].resp);
+          free(reply);
+          return PAM_BUF_ERR;
+        }
+        break;
+
+      case PAM_TEXT_INFO:
+      case PAM_ERROR_MSG:
+        if (conv_data->display_pam_msg && msg[i]->msg) {
+          conv_data->display_pam_msg(msg[i]->msg, msg[i]->msg_style);
+        }
+        break;
+
+      default:
+        break;
+    }
+  }
+  *resp = reply;
+  return PAM_SUCCESS;
+}
+
+#ifndef PAM_SERVICE_FALLBACK
+  #define PAM_SERVICE_FALLBACK "login"
+#endif
+
+#define CHECK_PAM_RET(call) \
+  ret = (call);             \
+  if (ret != PAM_SUCCESS) { \
+    pam_end(pamh, ret);     \
+    return NULL;            \
+  }
+pam_handle_t* get_pamh(char* user, char* passwd) {
+  pam_handle_t* pamh = NULL;
+  struct pam_conv_data conv_data = {.password = passwd,
+                                    .display_pam_msg = print_pam_msg};
+  struct pam_conv pamc = {pam_conversation, (void*)&conv_data};
+  int ret;
+
+  char* pam_service_override = getenv("LIDM_PAM_SERVICE");
+  char* pam_service_name =
+      pam_service_override ? pam_service_override : PAM_SERVICE_FALLBACK;
+
+  CHECK_PAM_RET(pam_start(pam_service_name, user, &pamc, &pamh))
+  CHECK_PAM_RET(pam_authenticate(pamh, 0))
+  CHECK_PAM_RET(pam_acct_mgmt(pamh, 0))
+  CHECK_PAM_RET(pam_setcred(pamh, PAM_ESTABLISH_CRED))
+  CHECK_PAM_RET(pam_open_session(pamh, 0))
+  CHECK_PAM_RET(pam_setcred(pamh, PAM_REINITIALIZE_CRED))
+
+  return pamh;
+}
+#undef CHECK_PAM_RET

src/sessions.c

@@ -1,3 +1,4 @@
+#include <errno.h>
 #include <ftw.h>
 #include <limits.h>
 #include <stdbool.h>
@@ -6,116 +7,214 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <unistd.h>
 
+#include "config.h"
+#include "desktop.h"
+#include "desktop_exec.h"
+#include "log.h"
+#include "macros.h"
 #include "sessions.h"
-#include "util.h"
+#include "util/path.h"
+#include "util/vec.h"
 
 struct source_dir {
-  enum session_type type;
+  enum SessionType type;
   char* dir;
 };
-static const struct source_dir sources[] = {
-    {XORG, "/usr/share/xsessions"},
-    {WAYLAND, "/usr/share/wayland-sessions"},
-};
 
-static struct session __new_session(enum session_type type, char *name,
-                                    const char *exec, const char *tryexec) {
-  struct session __session;
-  __session.type = type;
-  strcln(&__session.name, name);
-  strcln(&__session.exec, exec);
-  strcln(&__session.tryexec, tryexec);
-
-  return __session;
-}
+#ifndef SESSIONS_XSESSIONS
+  #define SESSIONS_XSESSIONS "/usr/share/xsessions"
+#endif
+#ifndef SESSIONS_XSESSIONS_LOCAL
+  #define SESSIONS_XSESSIONS_LOCAL "/usr/local/share/xsessions"
+#endif
+#ifndef SESSIONS_WAYLAND
+  #define SESSIONS_WAYLAND "/usr/share/wayland-sessions"
+#endif
+#ifndef SESSIONS_WAYLAND_LOCAL
+  #define SESSIONS_WAYLAND_LOCAL "/usr/local/share/wayland-sessions"
+#endif
+static const struct source_dir SOURCES[] = {{XORG, SESSIONS_XSESSIONS},
+                                            {XORG, SESSIONS_XSESSIONS_LOCAL},
+                                            {WAYLAND, SESSIONS_WAYLAND},
+                                            {WAYLAND, SESSIONS_WAYLAND_LOCAL}};
 
 static struct Vector* cb_sessions = NULL;
 
-// NOTE: commented printf's here would be nice to have debug logs if I ever
-// implement it
-static enum session_type session_type;
-static int fn(const char *fpath, const struct stat *sb, int typeflag) {
-  if (sb == NULL || !S_ISREG(sb->st_mode))
-    return 0;
+struct ctx_typ {
+  char* NULLABLE name;
+  char* NULLABLE exec;
+  char* NULLABLE tryexec;
+};
+struct status cb(void* _ctx, char* NULLABLE table, char* key, char* value) {
+  struct ctx_typ* ctx = (struct ctx_typ*)_ctx;
+  struct status ret;
+  ret.finish = false;
+
+  if (table == NULL) return ret;
+  if (strcmp(table, "Desktop Entry") != 0) return ret;
+
+  char** NULLABLE copy_at = NULL;
+  if (strcmp(key, "Name") == 0) {
+    if (ctx->name == NULL) copy_at = &ctx->name;
+  } else if (strcmp(key, "Exec") == 0) {
+    if (ctx->exec == NULL) copy_at = &ctx->exec;
+  } else if (strcmp(key, "TryExec") == 0) {
+    if (ctx->tryexec == NULL) copy_at = &ctx->tryexec;
+  }
+
+  if (copy_at != NULL) {
+    *copy_at = strdup(value);
+    if (*copy_at == NULL) {
+      log_perror("strdup");
+      log_puts("[E] failed to allocate memory");
+      ret.finish = true;
+      ret.ret = -1;
+    }
+  }
+
+  if (ctx->name != NULL && ctx->exec != NULL && ctx->tryexec != NULL) {
+    ret.finish = true;
+    ret.ret = 0;
+  }
+
+  return ret;
+}
+
+// also, always return 0 or we will break parsing and we don't want a bad
+// desktop file to break all possible sessions
+static enum SessionType session_type;
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
+static int fn(const char* fpath, const struct stat* sb, int typeflag) {
+  UNUSED(sb);
+
+  // guessing symlink behavior
+  //  - FTW_PHYS if set doesn't follow symlinks, so ftw() has no flags and it
+  //  follows symlinks, we should never get to handle that
+  if (typeflag != FTW_F) return 0;
+  log_printf("[I]  found file %s\n", fpath);
+
+  struct ctx_typ ctx = {
+      .name = NULL,
+      .exec = NULL,
+      .tryexec = NULL,
+  };
 
-  /*printf("gonna open %s\n", fpath);*/
   FILE* fd = fopen(fpath, "r");
   if (fd == NULL) {
-    perror("fopen");
-    fprintf(stderr, "error opening file (r) '%s'\n", fpath);
+    log_perror("fopen");
+    log_printf("[E] error opening file '%s' for read\n", fpath);
     return 0;
   }
 
-  u_char found = 0;
-  size_t alloc_size = sb->st_blksize;
+  int ret = read_desktop(fd, &ctx, &cb);
+  // any error
+  if (ret < 0) goto err_close;
 
-  char *name_buf = NULL;
-  char *exec_buf = NULL;
-  char *tryexec_buf = NULL;
-  // This should be made a specific function
-  while (true) {
-    char *buf = malloc(sb->st_blksize);
-    ssize_t read_size = getline(&buf, &alloc_size, fd);
-    if (read_size == -1) {
-      free(buf);
-      break;
-    }
+  (void)fclose(fd);
 
-    uint read;
-    char *key = malloc(read_size);
-    if ((read = sscanf(buf, "%[^=]=%[^\n]\n", key, buf)) != 0) {
-      if (strcmp(key, "Name") == 0) {
-        found &= 0b001;
-        name_buf = realloc(buf, read);
-      } else if (strcmp(key, "Exec") == 0) {
-        found &= 0b010;
-        exec_buf = realloc(buf, read);
-      } else if (strcmp(key, "TryExec") == 0) {
-        found &= 0b100;
-        tryexec_buf = realloc(buf, read);
-      } else
-        free(buf);
-    } else
-      free(buf);
-    free(key);
-
-    if (found == 0b111)
-      break;
-  }
-  /*printf("\nend parsing...\n");*/
-
-  fclose(fd);
+  // TODO: filter based on tryexec
+  // https://specifications.freedesktop.org/desktop-entry-spec/latest/recognized-keys.html
+  free(ctx.tryexec);
 
   // just add this to the list
-  if (name_buf != NULL && exec_buf != NULL) {
-    struct session *session_i = malloc(sizeof (struct session));
-    *session_i = __new_session(session_type, name_buf, exec_buf,
-                               tryexec_buf == NULL ? "" : tryexec_buf);
-    vec_push(cb_sessions, session_i);
+  if (ctx.name != NULL && ctx.exec != NULL) {
+    struct session* this_session = malloc(sizeof(struct session));
+    if (this_session == NULL) return 0;
+
+    int arg_count;
+    char** args;
+    int parse_status = parse_exec_string(ctx.exec, &arg_count, &args);
+    if (parse_status != 0 || arg_count == 0 || !args[0]) {
+      log_printf("[E] parsing exec string '%s': %d\n", ctx.exec, parse_status);
+      free(this_session);
+      goto err_parsing;
+    }
+    free(ctx.exec);
+
+    *this_session = (struct session){
+        .name = ctx.name,
+        .exec = session_exec_desktop(arg_count, args),
+        .type = session_type,
+    };
+
+    vec_push(cb_sessions, this_session);
   }
 
-  if (name_buf != NULL)
-    free(name_buf);
-  if (exec_buf != NULL)
-    free(exec_buf);
-  if (tryexec_buf != NULL)
-    free(tryexec_buf);
+  return 0;
 
+err_close:
+  (void)fclose(fd);
+err_parsing:
+  log_printf("[E] format error parsing %s", fpath);
   return 0;
 }
 
 // This code is designed to be run purely single threaded
+#define LIKELY_BOUND_SESSIONS 8
 struct Vector get_avaliable_sessions() {
-  struct Vector sessions = vec_new();
+  struct Vector sessions = VEC_NEW;
+  vec_reserve(&sessions, LIKELY_BOUND_SESSIONS);
 
   cb_sessions = &sessions;
-  for (size_t i = 0; i < (sizeof(sources) / sizeof(sources[0])); i++) {
-    /*printf("recurring into %s\n", sources[i].dir);*/
-    session_type = sources[i].type;
-    ftw(sources[i].dir, &fn, 1);
+  for (size_t i = 0; i < LEN(SOURCES); i++) {
+    log_printf("[I] parsing into %s\n", SOURCES[i].dir);
+    session_type = SOURCES[i].type;
+    ftw(SOURCES[i].dir, &fn, 1);
   }
   cb_sessions = NULL;
 
   return sessions;
 }
+
+int session_exec_exec(struct session_exec* NNULLABLE exec,
+                      char* NULLABLE* NNULLABLE envp) {
+  switch (exec->typ) {
+    case EXEC_SHELL: {
+      char* argv[] = {exec->shell, NULL};
+      return execvpe(exec->shell, argv, envp);
+    }
+    case EXEC_DESKTOP:
+      return execvpe(exec->desktop.args[0], exec->desktop.args, envp);
+    default:
+      __builtin_unreachable();
+  }
+}
+
+/// So the reason this doesn't use the user shell is because that can really be
+/// anything, also assuming it were fish for example, it can't execute posix
+/// shell files and that leaves it out of most `/etc/profile.d/` scripts.
+///
+/// I'll just default to bash for now as it's able to source almost everything
+/// and takes most flags. Maybe will try to make this more sophisticated in the
+/// future.
+///
+/// This respects errno. Even also works as any exec family function.
+#ifndef LOGIN_SHELL
+  #define LOGIN_SHELL "bash"
+#endif
+// This triggers login behavior
+#define LOGIN_SHELL_ARG0 "-" LOGIN_SHELL
+int session_exec_login_through_shell(struct session_exec* NNULLABLE exec,
+                                     char* NULLABLE* NNULLABLE envp) {
+  switch (exec->typ) {
+    case EXEC_SHELL: {
+      char* argv[] = {LOGIN_SHELL_ARG0, "-c", exec->shell, NULL};
+      return execvpe(LOGIN_SHELL, argv, envp);
+    }
+    case EXEC_DESKTOP: {
+      char* name = desktop_as_cmdline(exec->desktop.args);
+      if (!name) {
+        errno = EINVAL;
+        return -1;
+      }
+      char* argv[] = {LOGIN_SHELL_ARG0, "-c", name, NULL};
+      int ret = execvpe(LOGIN_SHELL, argv, envp);
+      free(name);
+      return ret;
+    }
+    default:
+      __builtin_unreachable();
+  }
+}

src/signal_handler.c

@@ -0,0 +1,29 @@
+#include <errno.h>
+#include <stddef.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "signal_handler.h"
+
+static void handle_sigterm(int sig) {
+  (void)sig;
+
+  (void)signal(SIGTERM, SIG_IGN);
+  kill(-getpgrp(), SIGTERM);
+
+  int status;
+  while (waitpid(-1, &status, 0) > 0 || errno == EINTR) {
+  }
+
+  _exit(0);
+}
+
+void setup_sigterm() {
+  setpgid(0, 0);
+
+  struct sigaction sa;
+  sa.sa_handler = handle_sigterm;
+  sigemptyset(&sa.sa_mask);
+  sa.sa_flags = 0;
+  sigaction(SIGTERM, &sa, NULL);
+}

src/ui.c

@@ -1,10 +1,15 @@
 // i'm sorry
 // really sorry
 
+#include <asm-generic/errno.h>
 #include <errno.h>
+#include <limits.h>
 #include <pwd.h>
+#include <security/pam_appl.h>
 #include <signal.h>
 #include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -19,54 +24,56 @@
 #include "auth.h"
 #include "efield.h"
 #include "keys.h"
+#include "launch_state.h"
+#include "log.h"
+#include "macros.h"
+#include "ofield.h"
 #include "sessions.h"
 #include "ui.h"
+#include "ui_state.h"
 #include "users.h"
-#include "util.h"
+#include "util/utf8.h"
 
-static void print_box();
-static void print_footer();
-static void restore_all();
-static void signal_handler(int);
-
-const uint boxw = 50;
-const uint boxh = 12;
+const uint8_t INPUTS_N = 3;
 
 struct uint_point {
   uint x;
   uint y;
 };
 
-static void print_session(struct uint_point, struct session, bool);
-static void print_user(struct uint_point, struct user, bool);
-static void print_passwd(struct uint_point, uint, bool);
+static void print_box();
+static void print_head();
+static void print_footer();
+static void restore_all();
+static void signal_handler(int code);
 
-enum input { SESSION, USER, PASSWD };
-static u_char inputs_n = 3;
+static void print_session(struct session session, bool multiple);
+static void print_user(struct user user, bool multiple);
+static void print_passwd(uint length, bool err);
+static void scratch_print_ui();
 
 // ansi resource: https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797
 static struct termios orig_term;
 static struct termios term;
 static struct winsize window;
 
-static struct theme theme;
-static struct functions functions;
-static struct strings strings;
-static struct behavior behavior;
-void setup(struct config __config) {
-  ioctl(STDOUT_FILENO, TIOCGWINSZ, &window);
+#define INNER_BOX_OUT_MARGIN 2
+struct config* g_config = NULL;
 
-  // 2 padding top and bottom for footer and vertical compensation
-  // 2 padding left & right to not overflow footer width
-  if (window.ws_row < boxh + 4 || window.ws_col < boxw + 4) {
-    fprintf(stderr, "\x1b[1;31mScreen too small\x1b[0m\n");
-    exit(1);
+static volatile sig_atomic_t need_resize = 0;
+
+static void process_sigwinch(int signal) {
+  UNUSED(signal);
+  need_resize = 1;
 }
 
-  theme = __config.theme;
-  functions = __config.functions;
-  strings = __config.strings;
-  behavior = __config.behavior;
+static inline void draw_bg() {
+  // apply bg color to all screen
+  printf("\x1b[%sm\x1b[2J", g_config->colors.bg);
+}
+
+void setup(struct config* config) {
+  g_config = config;
 
   tcgetattr(STDOUT_FILENO, &orig_term);
   term = orig_term; // save term
@@ -74,498 +81,535 @@ void setup(struct config __config) {
   term.c_lflag &= ~(ICANON | ECHO);
   tcsetattr(STDOUT_FILENO, TCSANOW, &term);
 
-  // save cursor pos, save screen, set color and reset screen
-  // (applying color to all screen)
-  printf("\x1b[s\x1b[?47h\x1b[%s;%sm\x1b[2J", theme.colors.bg, theme.colors.fg);
+  // save cursor pos, save screen
+  printf("\x1b[s\x1b[?47h");
+  draw_bg();
 
-  print_footer();
-  atexit(restore_all);
-  signal(SIGINT, signal_handler);
+  (void)atexit(restore_all);
+  (void)signal(SIGINT, signal_handler);
+  (void)signal(SIGWINCH, process_sigwinch);
+  (void)fflush(stdout);
 }
 
-static struct uint_point box_start() {
-  struct uint_point __start;
-  __start.x = (window.ws_col - boxw) / 2 + 1;
-  __start.y = (window.ws_row - boxh) / 2 + 1;
-  return __start;
-}
+static struct uint_point box_start = {.x = 0, .y = 0};
 
-static char *fmt_time() {
-  time_t t = time(NULL);
-  struct tm tm = *localtime(&t);
+#define STRFTIME_PREALLOC 64
+#define TM_YEAR_EPOCH 1900
+static char* fmt_time(const char* fmt) {
+  time_t tme = time(NULL);
+  struct tm tm = *localtime(&tme);
 
-  size_t bsize =
-      snprintf(NULL, 0, "%d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900,
-               tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec) +
-      1;
-  char *buf = malloc(bsize);
-  snprintf(buf, bsize, "%d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900,
-           tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+  size_t alloc_size = STRFTIME_PREALLOC;
+  char* buf = malloc(alloc_size);
+  if (!buf) return NULL;
+  while (true) {
+    if (strftime(buf, alloc_size, fmt, &tm) != 0 && strlen(fmt) != 0)
       return buf;
-}
 
-// TODO: handle buffers longer than the buffer (cut str to the end, change
-// cursor pos...) should just overlap for now
-
-// ugh, this represent a field which might have options
-// opts is the amount of other options possible (0 will behave as a passwd)
-// aaaand (it's an abstract idea, letme think), also holds the status of a
-// custom content, like custom launch command or user or smth
-struct opt_field {
-  uint opts;
-  uint current_opt; // 0 is edit mode btw
-  struct editable_field efield;
-};
-void print_ofield(struct opt_field *focused_input);
-
-static struct opt_field ofield_new(uint opts) {
-  struct opt_field __field;
-  __field.opts = opts;
-  __field.current_opt = 1;
-  if (opts == 0) {
-    __field.current_opt = 0;
-    __field.efield = field_new("");
+    alloc_size *= 2;
+    char* nbuf = realloc(buf, alloc_size);
+    if (!nbuf) {
+      free(buf);
+      return NULL;
     }
-  return __field;
-}
-static void ofield_toedit(struct opt_field *ofield, char *init) {
-  ofield->current_opt = 0;
-  ofield->efield = field_new(init);
-}
-static void ofield_type(struct opt_field *ofield, char *new, char *startstr) {
-  if (ofield->current_opt != 0)
-    ofield_toedit(ofield, startstr);
-  field_update(&ofield->efield, new);
-}
-// true if it changed anything, single opt fields return false
-static bool ofield_opt_seek(struct opt_field *ofield, char seek) {
-  // TODO: think this
-  if (ofield->opts == 0 || (ofield->opts == 1 && ofield->current_opt != 0))
-    return false;
-
-  ofield->current_opt =
-      1 + ((ofield->current_opt - 1 + seek + ofield->opts) % ofield->opts);
-
-  print_ofield(ofield);
-  return true;
-}
-// true in case it was able to "use" the seek (a empty only editable field
-// wouldn't)
-static bool ofield_seek(struct opt_field *ofield, char seek) {
-  if (ofield->current_opt == 0) {
-    if (field_seek(&ofield->efield, seek)) {
-      return true;
+    buf = nbuf;
   }
 }
 
-  if (ofield->opts == 0)
-    return false;
+char* trunc_gethostname(size_t maxlen, const char* const ELLIPSIS) {
+  if (utf8len(ELLIPSIS) > maxlen) return NULL;
+  size_t alloc_size = HOST_NAME_MAX + strlen(ELLIPSIS) + 1;
+  char* buf = malloc(alloc_size);
+  if (!buf) return NULL;
 
-  ofield_opt_seek(ofield, seek);
-
-  return true;
-}
-
-static u_char ofield_max_displ_pos(struct opt_field *ofield) {
-  // TODO: set max cursor pos too
-  // keep in mind that also have to keep in mind scrolling and ughhh, mentally
-  // blocked, but this is complex
-  if (ofield->current_opt == 0)
-    return ofield->efield.pos;
-  else
-    return 0;
-}
-
-enum input focused_input = PASSWD;
-struct opt_field of_session;
-struct opt_field of_user;
-struct opt_field of_passwd;
-
-struct Vector *gusers;
-struct Vector *gsessions;
-
-// not *that* OF tho
-struct opt_field *get_of(enum input from) {
-  if (from == SESSION)
-    return &of_session;
-  if (from == USER)
-    return &of_user;
-  if (from == PASSWD)
-    return &of_passwd;
+  if (gethostname(buf, alloc_size) != 0) {
+    free(buf);
     return NULL;
   }
 
-void ffield_cursor_focus() {
-  struct uint_point bstart = box_start();
-  u_char line = bstart.y;
-  u_char row = bstart.x + 15;
+  if (utf8len(buf) > maxlen) {
+    size_t end = utf8trunc(buf, maxlen - utf8len(ELLIPSIS));
+    strcpy(&buf[end], ELLIPSIS);
+  }
+  return buf;
+}
+
+void ui_update_cursor_focus() {
+  uint8_t line = box_start.y;
+  uint8_t col = box_start.x + VALUES_COL;
+
+  struct opts_field* ofield = get_opts_ffield();
+  uint8_t maxlen = VALUE_MAXLEN;
+  if (ofield->opts > 1) {
+    maxlen -= utf8len(g_config->strings.opts_pre) +
+              utf8len(g_config->strings.opts_post);
+  }
+  col += ofield_display_cursor_col(ofield, maxlen);
+  if (ofield->opts > 1) col += utf8len(g_config->strings.opts_pre);
 
   // rows in here quite bodged
   if (focused_input == SESSION) {
-    line += 5;
-    row += (of_session.opts > 1) * 2;
+    line += SESSION_ROW;
   } else if (focused_input == USER) {
-    line += 7;
-    row += (of_user.opts > 1) * 2;
+    line += USER_ROW;
   } else if (focused_input == PASSWD)
-    line += 9;
+    line += PASSWD_ROW;
 
-  struct opt_field *ofield = get_of(focused_input);
-  row += ofield->current_opt == 0 ? ofield_max_displ_pos(ofield) : 0;
-
-  printf("\x1b[%d;%dH", line, row);
-  fflush(stdout);
+  (void)printf("\x1b[%d;%dH", line, col);
 }
 
-struct user get_current_user() {
-  if (of_user.current_opt != 0)
-    return *(struct user*)vec_get(gusers, of_user.current_opt - 1);
-  else {
-    struct user custom_user;
-    custom_user.shell = "/usr/bin/bash";
-    custom_user.username = custom_user.display_name = of_user.efield.content;
-    return custom_user;
-  }
-}
-
-struct session get_current_session() {
-  if (of_session.current_opt != 0) {
-    // this is for the default user shell :P, not the greatest
-    // implementation but I want to get his done
-    if (behavior.include_defshell &&
-        of_session.current_opt == gsessions->length + 1) {
-      struct session shell_session;
-      shell_session.type = SHELL;
-      shell_session.exec = shell_session.name = get_current_user().shell;
-      return shell_session;
-    } else
-      return *(struct session*)vec_get(gsessions, of_session.current_opt - 1);
-  } else {
-    struct session custom_session;
-    custom_session.type = SHELL;
-    custom_session.name = custom_session.exec = of_session.efield.content;
-    return custom_session;
-  }
-}
-
-void print_field(enum input focused_input) {
-  struct uint_point origin = box_start();
-
+void ui_update_field(enum Input focused_input) {
   if (focused_input == PASSWD) {
-    print_passwd(origin, of_passwd.efield.length, false);
+    print_passwd(utf8len(of_passwd.efield.content), false);
   } else if (focused_input == SESSION) {
-    print_session(origin, get_current_session(), of_session.opts > 1);
+    print_session(st_session(g_config->behavior.include_defshell),
+                  of_session.opts > 1);
   } else if (focused_input == USER) {
-    print_user(origin, get_current_user(), of_user.opts > 1);
-    print_field(SESSION);
+    print_user(st_user(), of_user.opts > 1);
+    ui_update_field(SESSION);
   }
 
-  ffield_cursor_focus();
+  ui_update_cursor_focus();
 }
 
-void print_ffield() { print_field(focused_input); }
-void print_ofield(struct opt_field *ofield) {
-  enum input input;
-  if (ofield == &of_session)
+void ui_update_ffield() {
+  ui_update_field(focused_input);
+}
+
+void ui_update_ofield(struct opts_field* NNULLABLE self) {
+  enum Input input;
+  if (self == &of_session)
     input = SESSION;
-  else if (ofield == &of_user)
+  else if (self == &of_user)
     input = USER;
-  else if (ofield == &of_passwd)
+  else if (self == &of_passwd)
     input = PASSWD;
   else
     return;
 
-  print_field(input);
+  ui_update_field(input);
 }
 
-// true = forward, false = backward
-void ffield_move(bool direction) {
-  if (direction)
-    focused_input = (focused_input + 1 + inputs_n) % inputs_n;
-  else
-    focused_input = (focused_input - 1 + inputs_n) % inputs_n;
+/// draw everything
+void scratch_print_ui() {
+  ioctl(STDOUT_FILENO, TIOCGWINSZ, &window);
+  box_start = (struct uint_point){
+      .x = ((window.ws_col - BOX_WIDTH) / 2) + 1, // looks better
+      .y = ((window.ws_row - BOX_HEIGHT) / 2),    // leave more space under
+  };
 
-  ffield_cursor_focus();
+  if (window.ws_row < BOX_HEIGHT + (INNER_BOX_OUT_MARGIN * 2) ||
+      window.ws_col < BOX_WIDTH + (INNER_BOX_OUT_MARGIN * 2)) {
+    printf("\033[2J\033[H"); // Clear screen
+    printf("\x1b[1;31mScreen too small\x1b[0m\n");
+    printf("\x1b[%s;%sm\x1b[2J", g_config->colors.bg, g_config->colors.fg);
+    return;
   }
 
-// tf I'm doing
-void ffield_change_opt(bool direction) {
-  struct opt_field *ffield = get_of(focused_input);
-  if (focused_input == PASSWD)
-    ffield = &of_session;
-  if (!ofield_opt_seek(ffield, direction ? 1 : -1)) {
-    if (focused_input == PASSWD || focused_input == SESSION)
-      ofield_opt_seek(&of_user, direction ? 1 : -1);
-    else
-      ofield_opt_seek(&of_session, direction ? 1 : -1);
-  }
-}
-void ffield_change_pos(bool direction) {
-  struct opt_field *ffield = get_of(focused_input);
-  if (!ofield_seek(ffield, direction ? 1 : -1))
-    if (!ofield_opt_seek(&of_session, direction ? 1 : -1))
-      ofield_opt_seek(&of_user, direction ? 1 : -1);
+  printf("\033[2J\033[H\033c"); // Clear screen
+  draw_bg();
 
-  ffield_cursor_focus();
-}
-
-void ffield_type(char *text) {
-  struct opt_field *field = get_of(focused_input);
-  char *start = "";
-  if (focused_input == USER && of_user.current_opt != 0)
-    start = get_current_user().username;
-  if (focused_input == SESSION && of_session.current_opt != 0 &&
-      get_current_session().type == SHELL)
-    start = get_current_session().exec;
-
-  ofield_type(field, text, start);
-  print_ffield();
+  /// PRINTING
+  // printf box
+  print_box();
+
+  print_head();
+  print_footer();
+
+  ui_update_field(SESSION);
+  ui_update_field(USER);
+  ui_update_field(PASSWD);
+  ui_update_cursor_focus();
 }
 
+#define MS_PER_S 1000
+#define US_PER_MS 1000
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
 int load(struct Vector* users, struct Vector* sessions) {
+  long long ms_time = g_config->behavior.refresh_rate;
+  ms_time = ms_time < 0 ? 0 : ms_time;
+
   /// SETUP
   gusers = users;
   gsessions = sessions;
 
-  // hostnames larger won't render properly
-  char *hostname = malloc(16);
-  if (gethostname(hostname, 16) != 0) {
-    free(hostname);
-    hostname = "unknown";
-  } else {
-    hostname = realloc(hostname, strlen(hostname) + 1);
-  }
-
-  of_session = ofield_new(sessions->length + behavior.include_defshell);
+  of_session =
+      ofield_new(sessions->length + g_config->behavior.include_defshell);
   of_user = ofield_new(users->length);
   of_passwd = ofield_new(0);
 
-  /// PRINTING
-  const struct uint_point boxstart = box_start();
+  of_user.current_opt = users->length > 0;
+  of_session.current_opt = sessions->length > 0;
+  struct LaunchState initial_state;
+  if (read_launch_state(&initial_state) == 0) {
+    for (size_t i = 0; i < users->length; i++) {
+      struct user* user_i = (struct user*)vec_get(users, i);
+      if (strcmp(user_i->username, initial_state.username) == 0) {
+        of_user.current_opt = i + 1;
+        break;
+      }
+    }
 
-  // printf box
-  print_box();
+    for (size_t i = 0; i < sessions->length; i++) {
+      struct session* session_i = (struct session*)vec_get(sessions, i);
+      if (strcmp(session_i->name, initial_state.session_opt) == 0) {
+        of_session.current_opt = i + 1;
+        break;
+      }
+    }
+    if (g_config->behavior.include_defshell) {
+      if (strcmp(st_user().shell, initial_state.session_opt) == 0)
+        of_session.current_opt = sessions->length + 1;
+    }
 
-  // put hostname
-  printf("\x1b[%d;%dH\x1b[%sm%s\x1b[%sm", boxstart.y + 2,
-         boxstart.x + 12 - (uint)strlen(hostname), theme.colors.e_hostname,
-         hostname, theme.colors.fg);
+    free(initial_state.username);
+    free(initial_state.session_opt);
+  }
 
-  // put date
-  char *fmtd_time = fmt_time();
-  printf("\x1b[%d;%dH\x1b[%sm%s\x1b[%sm", boxstart.y + 2,
-         boxstart.x + boxw - 3 - (uint)strlen(fmtd_time), theme.colors.e_date,
-         fmtd_time, theme.colors.fg);
-
-  print_field(SESSION);
-  print_field(USER);
-  print_field(PASSWD);
-  ffield_cursor_focus();
+  scratch_print_ui();
 
   /// INTERACTIVE
-  u_char len;
-  char seq[256];
+  uint8_t len;
+  char seq[0xff];
   uint esc = 0;
   while (true) {
-    read_press(&len, seq);
+    if (need_resize) {
+      need_resize = 0;
+      scratch_print_ui();
+    } else {
+      // partial refresh
+      print_head();
+      ui_update_cursor_focus();
+    }
+
+    struct timeval tv;
+    tv.tv_usec = (ms_time % MS_PER_S) * US_PER_MS;
+    tv.tv_sec = ms_time / MS_PER_S;
+
+    (void)fflush(stdout);
+    if (!read_press_nb(&len, seq, &tv)) continue;
     if (*seq == '\x1b') {
-      enum keys ansi_code = find_ansi(seq);
-      if (ansi_code != -1) {
-        if (ansi_code == ESC) {
+      struct option_keys ansi_code = find_ansi(seq);
+      if (ansi_code.is_some) {
+        enum Keys ansi_key = ansi_code.key;
+        if (ansi_key == ESC) {
           esc = 2;
-        } else if (ansi_code == functions.refresh) {
+        } else if (ansi_key == g_config->functions.refresh) {
           restore_all();
           return 0;
-        } else if (ansi_code == functions.reboot) {
+        } else if (ansi_key == g_config->functions.reboot) {
           restore_all();
           reboot(RB_AUTOBOOT);
           exit(0);
-        } else if (ansi_code == functions.poweroff) {
+        } else if (ansi_key == g_config->functions.poweroff) {
           restore_all();
           reboot(RB_POWER_OFF);
           exit(0);
-        } else if (ansi_code == A_UP || ansi_code == A_DOWN) {
-          ffield_move(ansi_code == A_DOWN);
-        } else if (ansi_code == A_RIGHT || ansi_code == A_LEFT) {
+        } else if (g_config->functions.fido != NONE &&
+                   ansi_key == g_config->functions.fido) {
+          bool successful_write = write_launch_state((struct LaunchState){
+              .username = st_user().username,
+              .session_opt =
+                  st_session(g_config->behavior.include_defshell).name,
+          });
+          if (!successful_write) log_puts("[E] failed to write launch state");
+
+          if (!launch(st_user().username, "",
+                      st_session(g_config->behavior.include_defshell),
+                      &restore_all, g_config)) {
+            print_passwd(utf8len(of_passwd.efield.content), true);
+            ui_update_cursor_focus();
+          } else {
+            scratch_print_ui();
+          }
+        } else if (ansi_key == A_UP || ansi_key == A_DOWN) {
+          st_ch_focus(ansi_key == A_DOWN ? 1 : -1);
+        } else if (ansi_key == A_RIGHT || ansi_key == A_LEFT) {
           if (esc)
-            ffield_change_opt(ansi_code == A_RIGHT);
+            st_ch_of_opts(ansi_key == A_RIGHT ? 1 : -1);
           else
-            ffield_change_pos(ansi_code == A_RIGHT);
+            st_ch_ef_col(ansi_key == A_RIGHT ? 1 : -1);
         }
       }
     } else {
       if (len == 1 && *seq == '\n') {
-        if (!launch(get_current_user().username, of_passwd.efield.content,
-                    get_current_session(), &restore_all, &behavior)) {
-          print_passwd(box_start(), of_passwd.efield.length, true);
-          ffield_cursor_focus();
+        bool successful_write = write_launch_state((struct LaunchState){
+            .username = st_user().username,
+            .session_opt = st_session(g_config->behavior.include_defshell).name,
+        });
+        if (!successful_write) log_puts("[E] failed to write launch state");
+
+        if (!launch(st_user().username, of_passwd.efield.content,
+                    st_session(g_config->behavior.include_defshell),
+                    &restore_all, g_config)) {
+          print_passwd(utf8len(of_passwd.efield.content), true);
+          ui_update_cursor_focus();
+        } else {
+          scratch_print_ui();
         }
       } else
-        ffield_type(seq);
+        st_kbd_type(seq, g_config->behavior.include_defshell);
     }
 
-    if (esc != 0)
-      esc--;
+    if (esc != 0) esc--;
   }
 }
 
-static char *line_cleaner = NULL;
-static void clean_line(struct uint_point origin, uint line) {
-  if (line_cleaner == NULL) {
-    line_cleaner = malloc((boxw - 2) * sizeof(char) + 1);
-    memset(line_cleaner, 32, boxw - 2);
-    line_cleaner[boxw - 2] = 0;
-  }
-  printf("\x1b[%d;%dH", origin.y + line, origin.x + 1);
-  printf("%s", line_cleaner);
+void clean_line(struct uint_point origin, uint line) {
+  // - outline + nullbyte
+  static char line_cleaner[BOX_WIDTH - 2 + 1] = {
+      [0 ... BOX_WIDTH - 2 - 1] = ' ', [BOX_WIDTH - 2] = '\0'};
+  printf("\x1b[%d;%dH%s", origin.y + line, origin.x + 1, line_cleaner);
 }
 
-// TODO: session_len > 32
-static void print_session(struct uint_point origin, struct session session,
-                          bool multiple) {
-  clean_line(origin, 5);
-  const char *session_type;
+uint8_t get_render_pos_offset(struct opts_field* self, uint8_t maxlen) {
+  if (self->current_opt != 0) return 0;
+
+  uint8_t pos = utf8len_until(self->efield.content,
+                              &self->efield.content[self->efield.pos]);
+  return pos - ofield_display_cursor_col(self, maxlen);
+}
+
+void print_head() {
+  char* fmtd_time = fmt_time(g_config->behavior.timefmt);
+  size_t len_tm = utf8len(fmtd_time);
+
+  // calculate the space available for the host name
+  ssize_t hostname_size = BOX_WIDTH - (BOX_HMARGIN * 2) - len_tm - VALUES_SEPR;
+  if (hostname_size < 0) hostname_size = 0;
+
+  // hostname doesn't just change on runtime,
+  // but the length of the time string might
+  static char* NULLABLE hostname = NULL;
+  static ssize_t hostname_calcd_size;
+
+  // save the truncated hostname and the length it truncated to,
+  // if said length changes recalculate this (and free previous str)
+  if (!hostname || hostname_calcd_size != hostname_size) {
+    if (hostname) free(hostname);
+    hostname = trunc_gethostname(hostname_size, g_config->strings.ellipsis);
+    hostname_calcd_size = hostname_size;
+  }
+
+  clean_line(box_start, HEAD_ROW);
+
+  // put hostname
+  if (hostname_size)
+    printf("\x1b[%dG\x1b[%sm%s\x1b[%sm", box_start.x + 1 + BOX_HMARGIN,
+           g_config->colors.e_hostname, hostname ? hostname : "unknown",
+           g_config->colors.fg);
+
+  // put date
+  printf("\x1b[%dG\x1b[%sm%s\x1b[%sm",
+         box_start.x + BOX_WIDTH - 1 - BOX_HMARGIN - (uint)len_tm,
+         g_config->colors.e_date, fmtd_time, g_config->colors.fg);
+
+  free(fmtd_time);
+}
+
+void print_session(struct session session, bool multiple) {
+  clean_line(box_start, SESSION_ROW);
+
+  const char* NNULLABLE session_type;
   if (session.type == XORG) {
-    session_type = strings.s_xorg;
+    session_type = g_config->strings.s_xorg;
   } else if (session.type == WAYLAND) {
-    session_type = strings.s_wayland;
+    session_type = g_config->strings.s_wayland;
+  } else if (session.type == SHELL) {
+    session_type = g_config->strings.s_shell;
   } else {
-    session_type = strings.s_shell;
+    __builtin_unreachable();
   }
+
+  // already in the box, - 1 bcs no need to step over margin, same reasoning in
+  // other places
   printf("\r\x1b[%luC\x1b[%sm%s\x1b[%sm",
-         (ulong)(origin.x + 11 - strlen(session_type)), theme.colors.e_header,
-         session_type, theme.colors.fg);
+         (ulong)(box_start.x + VALUES_COL - VALUES_SEPR -
+                 utf8len(session_type) - 1),
+         g_config->colors.e_header, session_type, g_config->colors.fg);
 
   char* session_color;
   if (session.type == XORG) {
-    session_color = theme.colors.s_xorg;
+    session_color = g_config->colors.s_xorg;
   } else if (session.type == WAYLAND) {
-    session_color = theme.colors.s_wayland;
+    session_color = g_config->colors.s_wayland;
   } else {
-    session_color = theme.colors.s_shell;
+    session_color = g_config->colors.s_shell;
   }
 
+  char* toprint = session.name;
   if (multiple) {
-    printf("\r\x1b[%dC< \x1b[%sm%s\x1b[%sm >", origin.x + 14, session_color,
-           session.name, theme.colors.fg);
+    uint8_t maxlen = VALUE_MAXLEN - utf8len(g_config->strings.opts_pre) -
+                     utf8len(g_config->strings.opts_post);
+    toprint += get_render_pos_offset(&of_session, maxlen);
+    size_t printlen = utf8seekn(toprint, maxlen) - toprint;
+
+    printf("\r\x1b[%dC%s\x1b[%sm%.*s\x1b[%sm%s", box_start.x + VALUES_COL - 1,
+           g_config->strings.opts_pre, session_color, (int)printlen, toprint,
+           g_config->colors.fg, g_config->strings.opts_post);
   } else {
-    printf("\r\x1b[%dC\x1b[%sm%s\x1b[%sm", origin.x + 14, session_color,
-           session.name, theme.colors.fg);
+    toprint += get_render_pos_offset(&of_session, VALUE_MAXLEN);
+    size_t printlen = utf8seekn(toprint, VALUE_MAXLEN) - toprint;
+    printf("\r\x1b[%dC\x1b[%sm%.*s\x1b[%sm", box_start.x + VALUES_COL - 1,
+           session_color, (int)printlen, toprint, g_config->colors.fg);
   }
 }
 
-// TODO: user_len > 32
-static void print_user(struct uint_point origin, struct user user,
-                       bool multiple) {
-  clean_line(origin, 7);
+void print_user(struct user user, bool multiple) {
+  clean_line(box_start, USER_ROW);
   printf("\r\x1b[%luC\x1b[%sm%s\x1b[%sm",
-         (ulong)(origin.x + 11 - strlen(strings.e_user)), theme.colors.e_header,
-         strings.e_user, theme.colors.fg);
+         (ulong)(box_start.x + VALUES_COL - VALUES_SEPR -
+                 utf8len(g_config->strings.e_user) - 1),
+         g_config->colors.e_header, g_config->strings.e_user,
+         g_config->colors.fg);
 
-  char *user_color = theme.colors.e_user;
+  char* user_color = g_config->colors.e_user;
 
+  char* toprint = user.display_name;
   if (multiple) {
-    printf("\r\x1b[%dC< \x1b[%sm%s\x1b[%sm >", origin.x + 14, user_color,
-           user.display_name, theme.colors.fg);
+    uint8_t maxlen = VALUE_MAXLEN - utf8len(g_config->strings.opts_pre) -
+                     utf8len(g_config->strings.opts_post);
+    toprint += get_render_pos_offset(&of_session, maxlen);
+    size_t printlen = utf8seekn(toprint, maxlen) - toprint;
+
+    printf("\r\x1b[%dC%s\x1b[%sm%.*s\x1b[%sm%s", box_start.x + VALUES_COL - 1,
+           g_config->strings.opts_pre, user_color, (int)printlen, toprint,
+           g_config->colors.fg, g_config->strings.opts_post);
   } else {
-    printf("\r\x1b[%dC\x1b[%sm%s\x1b[%sm", origin.x + 14, user_color,
-           user.display_name, theme.colors.fg);
+    toprint += get_render_pos_offset(&of_user, VALUE_MAXLEN);
+    size_t printlen = utf8seekn(toprint, VALUE_MAXLEN) - toprint;
+    printf("\r\x1b[%dC\x1b[%sm%.*s\x1b[%sm", box_start.x + VALUES_COL - 1,
+           user_color, (int)printlen, toprint, g_config->colors.fg);
   }
 }
 
-static char passwd_prompt[33];
-// TODO: passwd_len > 32
-static void print_passwd(struct uint_point origin, uint length, bool err) {
-  clean_line(origin, 9);
+void print_passwd(uint length, bool err) {
+  char passwd_prompt[VALUE_MAXLEN + 1];
+  clean_line(box_start, PASSWD_ROW);
   printf("\r\x1b[%luC\x1b[%sm%s\x1b[%sm",
-         (ulong)(origin.x + 11 - strlen(strings.e_passwd)),
-         theme.colors.e_header, strings.e_passwd, theme.colors.fg);
+         (ulong)(box_start.x + VALUES_COL - VALUES_SEPR -
+                 utf8len(g_config->strings.e_passwd) - 1),
+         g_config->colors.e_header, g_config->strings.e_passwd,
+         g_config->colors.fg);
 
   char* pass_color;
   if (err)
-    pass_color = theme.colors.e_badpasswd;
+    pass_color = g_config->colors.e_badpasswd;
   else
-    pass_color = theme.colors.e_passwd;
+    pass_color = g_config->colors.e_passwd;
 
-  ulong prompt_len = sizeof(passwd_prompt);
-  ulong actual_len = length > prompt_len ? prompt_len : length;
-  memset(passwd_prompt, ' ', prompt_len);
+  ulong actual_len = length > VALUE_MAXLEN ? VALUE_MAXLEN : length;
+  memset(passwd_prompt, ' ', VALUE_MAXLEN);
   memset(passwd_prompt, '*', actual_len);
-  passwd_prompt[32] = 0;
+  passwd_prompt[VALUE_MAXLEN] = '\0';
 
-  printf("\r\x1b[%dC\x1b[%sm", origin.x + 14, pass_color);
+  printf("\r\x1b[%dC\x1b[%sm", box_start.x + VALUES_COL - 1, pass_color);
   printf("%s", passwd_prompt);
 
-  printf("\x1b[%sm", theme.colors.fg);
+  printf("\x1b[%sm", g_config->colors.fg);
 }
 
-static void print_empty_row(uint w, uint n, char *edge1, char *edge2) {
+static void print_empty_row(uint wid, uint n, char* edge1, char* edge2) {
   for (size_t i = 0; i < n; i++) {
-    printf("%s\x1b[%dC%s\x1b[%dD\x1b[1B", edge1, w, edge2, w + 2);
+    printf("%s\x1b[%dC%s\x1b[%dD\x1b[1B", edge1, wid, edge2, wid + 2);
   }
 }
 
-static void print_row(uint w, uint n, char *edge1, char *edge2, char *filler) {
+static void print_row(uint wid, uint n, char* edge1, char* edge2,
+                      char* filler) {
   for (size_t i = 0; i < n; i++) {
     printf("%s", edge1);
-    for (size_t i = 0; i < w; i++) {
+    for (size_t i = 0; i < wid; i++) {
       printf("%s", filler);
     }
-    printf("%s\x1b[%dD\x1b[1B", edge2, w + 2);
+    printf("%s\x1b[%dD\x1b[1B", edge2, wid + 2);
   }
 }
 
 static void print_box() {
-  // TODO: check min sizes
-  const struct uint_point bstart = box_start();
-
-  printf("\x1b[%d;%dH\x1b[%sm", bstart.y, bstart.x, theme.colors.e_box);
-  fflush(stdout);
-  print_row(boxw - 2, 1, theme.chars.ctl, theme.chars.ctr, theme.chars.hb);
-  print_empty_row(boxw - 2, boxh - 2, theme.chars.vb, theme.chars.vb);
-  print_row(boxw - 2, 1, theme.chars.cbl, theme.chars.cbr, theme.chars.hb);
-  printf("\x1b[%sm", theme.colors.fg);
-  fflush(stdout);
+  printf("\x1b[%d;%dH\x1b[%sm", box_start.y, box_start.x,
+         g_config->colors.e_box);
+  print_row(BOX_WIDTH - 2, 1, g_config->chars.ctl, g_config->chars.ctr,
+            g_config->chars.hb);
+  print_empty_row(BOX_WIDTH - 2, BOX_HEIGHT - 2, g_config->chars.vb,
+                  g_config->chars.vb);
+  print_row(BOX_WIDTH - 2, 1, g_config->chars.cbl, g_config->chars.cbr,
+            g_config->chars.hb);
+  printf("\x1b[%sm", g_config->colors.fg);
 }
 
 static void print_footer() {
-  size_t bsize = snprintf(NULL, 0, "%s %s  %s %s  %s %s", strings.f_poweroff,
-                          key_names[functions.poweroff], strings.f_reboot,
-                          key_names[functions.reboot], strings.f_refresh,
-                          key_names[functions.refresh]);
+  bool fido_enabled = g_config->functions.fido != NONE;
+
+  size_t bsize = utf8len(g_config->strings.f_poweroff) +
+                 utf8len(KEY_NAMES[g_config->functions.poweroff]) +
+                 utf8len(g_config->strings.f_reboot) +
+                 utf8len(KEY_NAMES[g_config->functions.reboot]) +
+                 utf8len(g_config->strings.f_refresh) +
+                 utf8len(KEY_NAMES[g_config->functions.refresh]);
+
+  bsize += (2 * 2) + (3 * 1);
+
+  if (fido_enabled) {
+    bsize += utf8len(g_config->strings.f_fido) +
+             utf8len(KEY_NAMES[g_config->functions.fido]) + 2 + 1;
+  }
 
   uint row = window.ws_row - 1;
   uint col = window.ws_col - 2 - bsize;
-  printf("\x1b[%3$d;%4$dH%8$s \x1b[%1$sm%5$s\x1b[%2$sm  %9$s "
-         "\x1b[%1$sm%6$s\x1b[%2$sm  %10$s \x1b[%1$sm%7$s\x1b[%2$sm",
-         theme.colors.e_key, theme.colors.fg, row, col,
-         key_names[functions.poweroff], key_names[functions.reboot],
-         key_names[functions.refresh], strings.f_poweroff, strings.f_reboot,
-         strings.f_refresh);
-  fflush(stdout);
+
+  printf("\x1b[%d;%dH%s \x1b[%sm%s\x1b[%sm  %s \x1b[%sm%s\x1b[%sm  ", row, col,
+         g_config->strings.f_poweroff, g_config->colors.e_key,
+         KEY_NAMES[g_config->functions.poweroff], g_config->colors.fg,
+         g_config->strings.f_reboot, g_config->colors.e_key,
+         KEY_NAMES[g_config->functions.reboot], g_config->colors.fg);
+
+  if (fido_enabled) {
+    printf("%s \x1b[%sm%s\x1b[%sm  ", g_config->strings.f_fido,
+           g_config->colors.e_key, KEY_NAMES[g_config->functions.fido],
+           g_config->colors.fg);
+  }
+
+  printf("%s \x1b[%sm%s\x1b[%sm", g_config->strings.f_refresh,
+         g_config->colors.e_key, KEY_NAMES[g_config->functions.refresh],
+         g_config->colors.fg);
 }
 
 void print_err(const char* msg) {
-  struct uint_point origin = box_start();
-  fprintf(stderr, "\x1b[%d;%dH%s(%d): %s", origin.y - 1, origin.x, msg, errno,
-          strerror(errno));
+  (void)fprintf(stderr, "\x1b[%d;%dH%s(%d): %s", box_start.y - 1, box_start.x,
+                msg, errno, strerror(errno));
+}
+
+void print_pam_msg(const char* msg, int msg_style) {
+  uint row = box_start.y + BOX_HEIGHT + 1;
+  const char* color =
+      (msg_style == PAM_ERROR_MSG) ? g_config->colors.err : g_config->colors.fg;
+  printf("\x1b[%d;%dH\x1b[K\x1b[%sm%.*s\x1b[%sm", row, box_start.x, color,
+         BOX_WIDTH, msg, g_config->colors.fg);
+  (void)fflush(stdout);
+}
+
+void clear_pam_msg(void) {
+  uint row = box_start.y + BOX_HEIGHT + 1;
+  printf("\x1b[%d;%dH\x1b[K", row, box_start.x);
+  (void)fflush(stdout);
 }
 
 void print_errno(const char* descr) {
-  struct uint_point origin = box_start();
   if (descr == NULL)
-    fprintf(stderr, "\x1b[%d;%dH\x1b[%smunknown error(%d): %s", origin.y - 1,
-            origin.x, theme.colors.err, errno, strerror(errno));
+    (void)fprintf(stderr, "\x1b[%d;%dH\x1b[%smunknown error(%d): %s",
+                  box_start.y - 1, box_start.x, g_config->colors.err, errno,
+                  strerror(errno));
   else {
-    fprintf(stderr, "\x1b[%d;%dH\x1b[%sm%s(%d): %s", origin.y - 1, origin.x,
-            theme.colors.err, descr, errno, strerror(errno));
+    (void)fprintf(stderr, "\x1b[%d;%dH\x1b[%sm%s(%d): %s", box_start.y - 1,
+                  box_start.x, g_config->colors.err, descr, errno,
+                  strerror(errno));
   }
 }
 
 void restore_all() {
   // restore cursor pos, restore screen and show cursor
-  printf("\x1b[u\x1b[?47l\x1b[?25h");
-  fflush(stdout);
+  (void)printf("\x1b[u\x1b[?47l\x1b[?25h");
   tcsetattr(STDOUT_FILENO, TCSANOW, &orig_term);
 }
 

src/ui_state.c

@@ -0,0 +1,95 @@
+#include "ui_state.h"
+#include "ofield.h"
+#include "sessions.h"
+#include "ui.h"
+#include "users.h"
+
+enum Input focused_input = PASSWD;
+
+struct Vector* gusers;
+struct Vector* gsessions;
+
+struct opts_field of_session;
+struct opts_field of_user;
+struct opts_field of_passwd;
+
+struct opts_field* NNULLABLE get_opts_field(enum Input from) {
+  if (from == SESSION) return &of_session;
+  if (from == USER) return &of_user;
+  if (from == PASSWD) return &of_passwd;
+  __builtin_unreachable();
+}
+
+struct opts_field* NNULLABLE get_opts_ffield() {
+  return get_opts_field(focused_input);
+}
+
+struct user st_user() {
+  if (of_user.current_opt != 0)
+    return *(struct user*)vec_get(gusers, of_user.current_opt - 1);
+
+  struct user custom_user;
+  custom_user.shell = "/usr/bin/bash";
+  custom_user.username = custom_user.display_name = of_user.efield.content;
+  return custom_user;
+}
+struct session st_session(bool include_defshell) {
+  if (of_session.current_opt != 0) {
+    // this is for the default user shell :P, not the greatest
+    // implementation but I want to get his done
+    if (include_defshell && of_session.current_opt == gsessions->length + 1) {
+      struct session shell_session;
+      shell_session.type = SHELL;
+      shell_session.exec =
+          session_exec_shell(shell_session.name = st_user().shell);
+      return shell_session;
+    }
+
+    return *(struct session*)vec_get(gsessions, of_session.current_opt - 1);
+  }
+
+  struct session custom_session;
+  custom_session.type = SHELL;
+  custom_session.exec =
+      session_exec_shell(custom_session.name = of_session.efield.content);
+  return custom_session;
+}
+
+void st_ch_focus(char direction) {
+  focused_input = (focused_input + direction) % INPUTS_N;
+  ui_update_cursor_focus();
+}
+
+void st_ch_of_opts(char direction) {
+  struct opts_field* ffield = get_opts_ffield();
+  if (focused_input == PASSWD) ffield = &of_session;
+  if (!ofield_opts_seek(ffield, direction)) {
+    if (focused_input == PASSWD || focused_input == SESSION)
+      ofield_opts_seek(&of_user, direction);
+    else
+      ofield_opts_seek(&of_session, direction);
+  }
+}
+
+void st_ch_ef_col(char direction) {
+  struct opts_field* ffield = get_opts_ffield();
+  if (!ofield_seek(ffield, direction))
+    if (!ofield_opts_seek(&of_session, direction))
+      ofield_opts_seek(&of_user, direction);
+
+  ui_update_cursor_focus();
+  ui_update_ffield();
+}
+
+void st_kbd_type(char* text, bool cfg_include_defshell) {
+  struct opts_field* field = get_opts_ffield();
+  char* start = "";
+  if (focused_input == USER && of_user.current_opt != 0)
+    start = st_user().username;
+  if (focused_input == SESSION && of_session.current_opt != 0 &&
+      st_session(cfg_include_defshell).type == SHELL)
+    start = st_session(cfg_include_defshell).exec.shell;
+
+  ofield_kbd_type(field, text, start);
+  ui_update_ffield();
+}

src/users.c

@@ -1,36 +1,64 @@
 #include <pwd.h>
 #include <stdbool.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 
+#include "log.h"
+#include "macros.h"
 #include "users.h"
-#include "util.h"
+#include "util/vec.h"
 
-static struct user __new_user(struct passwd *p) {
-  struct user __user;
-  strcln(&__user.shell, p->pw_shell);
-  strcln(&__user.username, p->pw_name);
-  if (p->pw_gecos[0] == '\0')
-    __user.display_name = __user.username;
-  else
-    strcln(&__user.display_name, p->pw_gecos);
+// NOLINTNEXTLINE(readability-identifier-length)
+int build_user(struct user* NNULLABLE user, struct passwd* p) {
+  char* shell = strdup(p->pw_shell);
+  char* username = strdup(p->pw_name);
+  char* displayname;
+  if (strlen(p->pw_gecos) == 0)
+    displayname = username;
+  else {
+    displayname = strdup(p->pw_gecos);
+  }
+  if (!shell || !username || !displayname) {
+    free(shell);
+    free(username);
+    if (displayname != username) free(displayname);
+    // actually tidy struggles with the line i have avobe
+    // NOLINTNEXTLINE(clang-analyzer-unix.Malloc)
+    return -1;
+  }
 
-  return __user;
+  *user = (struct user){
+      .shell = shell,
+      .username = username,
+      .display_name = displayname,
+  };
+
+  return 0;
 }
 
 // This code is designed to be run purely single threaded
+#define LIKELY_BOUND_USERS 4
 struct Vector get_human_users() {
-  struct Vector users = vec_new();
+  struct Vector users = VEC_NEW;
+  vec_reserve(&users, LIKELY_BOUND_USERS);
 
-  struct passwd *pwd;
+  struct passwd* NULLABLE pwd;
   while ((pwd = getpwent()) != NULL) {
-    if (!(pwd->pw_dir && strncmp(pwd->pw_dir, "/home/", 6) == 0))
+    log_printf("[I] handling user %s\n", pwd->pw_name);
+    // `- 1` bcs sizeof counts the nullbyte
+    if (pwd->pw_dir &&
+        strncmp(pwd->pw_dir, "/home/", sizeof("/home/") - 1) != 0)
       continue;
+    log_printf("[I]  found %s\n", pwd->pw_name);
 
     struct user* user_i = malloc(sizeof(struct user));
-    *user_i = __new_user(pwd);
+    if (user_i == NULL) continue; // malloc error
+
+    if (build_user(user_i, pwd) != 0) {
+      log_printf("[E] failed to allocate allocate memory for %s\n",
+                 pwd->pw_name);
+    }
     vec_push(&users, user_i);
   }
 

src/util.c

@@ -1,127 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include "keys.h"
-#include "ui.h"
-#include "util.h"
-
-static int selret_magic();
-
-void strcln(char **dest, const char *source) {
-  *dest = malloc(strlen(source) + sizeof(char));
-  strcpy(*dest, source);
-}
-
-enum keys find_keyname(char *name) {
-  for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
-    if (strcmp(key_names[i], name) == 0)
-      return (enum keys)i;
-  }
-
-  perror("key not found");
-  exit(1);
-}
-
-enum keys find_ansi(char *seq) {
-  for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
-    struct key_mapping mapping = key_mappings[i];
-    for (size_t j = 0; mapping.sequences[j] != NULL; j++) {
-      if (strcmp(mapping.sequences[j], seq) == 0) {
-        return (enum keys)i;
-      }
-    }
-  }
-  return -1;
-}
-
-// https://stackoverflow.com/a/48040042
-void read_press(u_char *length, char *out) {
-  *length = 0;
-
-  while (true) {
-    if (read(STDIN_FILENO, &out[(*length)++], 1) != 1) {
-      print_errno("read error");
-      sleep(3);
-      exit(1);
-    }
-    int selret = selret_magic();
-    if (selret == -1) {
-      print_errno("selret error");
-    } else if (selret != 1) {
-      out[*length] = '\0';
-      return;
-    }
-  }
-}
-
-static int selret_magic() {
-  fd_set set;
-  struct timeval timeout;
-  FD_ZERO(&set);
-  FD_SET(STDIN_FILENO, &set);
-  timeout.tv_sec = 0;
-  timeout.tv_usec = 0;
-  return select(1, &set, NULL, NULL, &timeout);
-}
-
-
-// Vector shii
-struct Vector vec_new() {
-  struct Vector vec;
-  vec_clear(&vec);
-  return vec;
-}
-
-int vec_push(struct Vector* vec, void* item) {
-  if (vec->length >= vec->alloc_len) {
-    uint32_t new_size = vec->alloc_len + vec->alloc_size;
-    void **new_location = realloc(vec->pages, vec->alloc_size);
-    if (new_location != NULL) {
-      vec->alloc_size = new_size;
-      vec->pages = new_location;
-    } else {
-      return -1;
-    }
-  }
-
-  vec->pages[vec->length] = item;
-  vec->length++;
-  return 0;
-}
-
-void vec_free(struct Vector* vec) {
-  while(vec->length > 0)
-    free(vec->pages[--vec->length]);
-
-  vec_clear(vec);
-}
-
-void vec_clear(struct Vector* vec) {
-  free(vec->pages);
-  vec_reset(vec);
-}
-
-void vec_reset(struct Vector* vec) {
-  vec->length = 0;
-  vec->alloc_len = 0;
-  vec->alloc_size = 4096; // 4KiB page size?
-  vec->pages = NULL;
-}
-
-void* vec_pop(struct Vector* vec) {
-  if (vec->length == 0)
-    return NULL;
-
-  return vec->pages[--vec->length];
-}
-
-void* vec_get(struct Vector* vec, size_t index) {
-  if (index >= vec->length)
-    return NULL;
-
-  return vec->pages[index];
-}

src/util/path.c

@@ -0,0 +1,64 @@
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "util/path.h"
+
+// returns NULL on any error
+// otherwise it returns the absolute path of the program that MUST BE FREED
+//
+// Should be almost completely posix compliant, except it won't resolve empty
+// PATH entries relative to the cwd
+char* NULLABLE search_path(const char* NNULLABLE for_binary) {
+  if (strchr(for_binary, '/') != NULL) {
+    // skip absolute paths
+    return strdup(for_binary);
+  }
+  char* path_env = getenv("PATH");
+  if (!path_env) return NULL;
+  char* path = strdup(path_env);
+  if (!path) return NULL;
+
+  char* tok = strtok(path, ":");
+  while (tok) {
+    char* bin_path;
+    asprintf(&bin_path, "%s/%s", tok, for_binary);
+    if (!bin_path) {
+      free(path);
+      return NULL;
+    }
+
+    struct stat stat_buf;
+    if (stat(bin_path, &stat_buf) == 0 && access(bin_path, X_OK) == 0) {
+      free(path);
+      return bin_path;
+    }
+
+    free(bin_path);
+    tok = strtok(NULL, ":");
+  }
+
+  free(path);
+  return NULL;
+}
+
+// This is present in glibc ONLY with GNU extensions, this aims to provide a
+// musl compatible variant.
+//
+// Respects errno of exec functions family.
+int execvpe(const char* NNULLABLE file, char* NULLABLE const argv[NNULLABLE],
+            char* NULLABLE const envp[NNULLABLE]) {
+  char* path = search_path(file);
+  if (!path) {
+    errno = ENOENT;
+    return -1;
+  }
+  int ret = execve(path, argv, envp);
+  free(path);
+  return ret;
+}

src/util/utf8.c

@@ -0,0 +1,62 @@
+#include "util/utf8.h"
+
+#define UTF8_CONT_MSK 0b11000000
+#define UTF8_CONT_VAL 0b10000000
+bool utf8_iscont(char byte) {
+  return (byte & UTF8_CONT_MSK) == UTF8_CONT_VAL;
+}
+
+size_t utf8len(const char* str) {
+  size_t len = 0;
+  while (*str != '\0') {
+    if (!utf8_iscont(*(str++))) len++;
+  }
+
+  return len;
+}
+
+size_t utf8len_until(const char* str, const char* until) {
+  size_t len = 0;
+  while (str < until) {
+    if (!utf8_iscont(*(str++))) len++;
+  }
+
+  return len;
+}
+
+size_t utf8trunc(char* str, size_t n) {
+  size_t bytes = 0;
+  while (true) {
+    if (str[bytes] == '\0') break;
+    if (utf8_iscont(str[bytes])) {
+      bytes++;
+      continue;
+    }
+    if (n == 0) {
+      str[bytes] = '\0';
+      break;
+    }
+    bytes++;
+    n--;
+  }
+  return bytes;
+}
+
+const char* utf8back(const char* str) {
+  while (utf8_iscont(*(--str))) {
+  }
+  return str;
+}
+const char* utf8seek(const char* str) {
+  while (utf8_iscont(*(++str))) {
+  }
+  return str;
+}
+
+const char* utf8seekn(const char* str, size_t n) {
+  while (n > 0 && *str != '\0') {
+    str = utf8seek(str);
+    n--;
+  }
+  return str;
+}

src/util/vec.c

@@ -0,0 +1,96 @@
+#include <stdlib.h>
+
+#include "util/vec.h"
+
+const struct Vector VEC_NEW = {
+    .length = 0,
+    .capacity = 0,
+    .pages = NULL,
+};
+
+struct Vector vec_from_raw(void** raw) {
+  size_t len = 0;
+  while (raw[len])
+    len++;
+
+  return (struct Vector){
+      .length = len,
+      .capacity = len,
+      .pages = raw,
+  };
+}
+
+void** vec_as_raw(struct Vector self) {
+  if (vec_push(&self, NULL) != 0) return NULL;
+  return self.pages;
+}
+
+int vec_resize(struct Vector* self, size_t size) {
+  void** new_location =
+      (void**)realloc((void*)self->pages, size * sizeof(void*));
+  if (new_location != NULL) {
+    if (self->length > size) self->length = size;
+    self->capacity = size;
+    self->pages = new_location;
+  } else {
+    return -1;
+  }
+  return 0;
+}
+
+int vec_reserve(struct Vector* self, size_t size) {
+  uint32_t new_capacity = self->capacity;
+  while (self->length + size > new_capacity) {
+    new_capacity = new_capacity + (new_capacity >> 1) +
+                   1; // cap * 1.5 + 1; 0 1 2 4 7 11...
+  }
+  return vec_resize(self, new_capacity);
+}
+
+int vec_reserve_exact(struct Vector* self, size_t size) {
+  uint32_t needed_capacity = self->length + size;
+  if (self->capacity < needed_capacity) {
+    return vec_resize(self, needed_capacity);
+  }
+  return 0;
+}
+
+int vec_push(struct Vector* self, void* item) {
+  int res_ret = vec_reserve(self, 1);
+  if (res_ret != 0) return res_ret;
+
+  self->pages[self->length++] = item;
+  return 0;
+}
+
+void vec_free(struct Vector* self) {
+  while (self->length > 0)
+    free(self->pages[--self->length]);
+
+  vec_clear(self);
+}
+
+void vec_clear(struct Vector* self) {
+  free((void*)self->pages);
+  vec_reset(self);
+}
+
+void vec_reset(struct Vector* self) {
+  *self = (struct Vector){
+      .length = 0,
+      .capacity = 0,
+      .pages = NULL,
+  };
+}
+
+void* vec_pop(struct Vector* self) {
+  if (self->length == 0) return NULL;
+
+  return self->pages[--self->length];
+}
+
+void* vec_get(struct Vector* self, size_t index) {
+  if (index >= self->length) return NULL;
+
+  return self->pages[index];
+}

themes/README.md

@@ -1,5 +1,21 @@
 # Themes
 
+## catppuccin-frappe.ini
+
+![catppuccin-frappe.ini theme](./screenshots/catppuccin-frappe.png)
+
+## catppuccin-latte.ini
+
+![catppuccin-latte.ini theme](./screenshots/catppuccin-latte.png)
+
+## catppuccin-macchiato.ini
+
+![catppuccin-macchiato.ini theme](./screenshots/catppuccin-macchiato.png)
+
+## catppuccin-mocha.ini
+
+![catppuccin-mocha.ini theme](./screenshots/catppuccin-mocha.png)
+
 ## cherry.ini
 
 ![cherry.ini theme](./screenshots/cherry.png)
@@ -16,6 +32,14 @@
 
 ![kanagawa-wave.ini theme](./screenshots/kanagawa-wave.png)
 
+## minimal.ini
+
+![minimal.ini theme](./screenshots/minimal.png)
+
+> [!WARNING]
+> This theme **heavily** relies on terminal rendering. It's just to show
+> customizability, a TTY won't render this properly
+
 ## nature.ini
 
 ![nature.ini theme](./screenshots/nature.png)

themes/catppuccin-frappe.ini

@@ -0,0 +1,24 @@
+##############################################
+#                                            #
+#              Catppuccin Theme              #
+#                                            #
+##############################################
+
+# Catppuccin Frappé
+# This theme was created by: Catppuccin Org! <3
+
+[colors]
+bg          = "23;24;25;48;2;48;52;70"
+fg          = "22;23;24;25;29;38;2;198;208;245"
+err         = "1;4;23;24;25;38;2;231;130;132"
+s_wayland   = "3;22;24;25;38;2;202;158;230"
+s_xorg      = "3;22;24;25;38;2;202;158;230"
+s_shell     = "3;22;24;25;38;2;244;184;228"
+e_hostname  = "1;3;24;25;29;38;2;242;213;207"
+e_date      = "3;22;24;25;29;38;2;165;173;206"
+e_box       = "1;23;24;25;29;38;2;115;121;148"
+e_header    = "1;3;24;25;29;38;2;239;159;118"
+e_user      = "3;22;24;25;29;38;2;140;170;238"
+e_passwd    = "1;23;24;25;29;38;2;166;209;137"
+e_badpasswd = "1;9;23;24;25;38;2;231;130;132"
+e_key       = "22;23;24;25;38;2;129;200;190"

themes/catppuccin-latte.ini

@@ -0,0 +1,24 @@
+##############################################
+#                                            #
+#              Catppuccin Theme              #
+#                                            #
+##############################################
+
+# Catppuccin Latte
+# This theme was created by: Catppuccin Org! <3
+
+[colors]
+bg          = "23;24;25;48;2;239;241;245"
+fg          = "22;23;24;25;29;38;2;76;79;105"
+err         = "1;4;23;24;25;38;2;210;15;57"
+s_wayland   = "3;22;24;25;38;2;136;57;239"
+s_xorg      = "3;22;24;25;38;2;136;57;239"
+s_shell     = "3;22;24;25;38;2;234;118;203"
+e_hostname  = "1;3;24;25;29;38;2;220;138;120"
+e_date      = "3;22;24;25;29;38;2;108;111;133"
+e_box       = "1;23;24;25;29;38;2;156;160;176"
+e_header    = "1;3;24;25;29;38;2;254;100;11"
+e_user      = "3;22;24;25;29;38;2;30;102;245"
+e_passwd    = "1;23;24;25;29;38;2;64;160;43"
+e_badpasswd = "1;9;23;24;25;38;2;210;15;57"
+e_key       = "22;23;24;25;38;2;23;146;153"

themes/catppuccin-macchiato.ini

@@ -0,0 +1,24 @@
+##############################################
+#                                            #
+#              Catppuccin Theme              #
+#                                            #
+##############################################
+
+# Catppuccin Macchiato
+# This theme was created by: Catppuccin Org! <3
+
+[colors]
+bg          = "23;24;25;48;2;36;39;58"
+fg          = "22;23;24;25;29;38;2;202;211;245"
+err         = "1;4;23;24;25;38;2;237;135;150"
+s_wayland   = "3;22;24;25;38;2;198;160;246"
+s_xorg      = "3;22;24;25;38;2;198;160;246"
+s_shell     = "3;22;24;25;38;2;245;189;230"
+e_hostname  = "1;3;24;25;29;38;2;244;219;214"
+e_date      = "3;22;24;25;29;38;2;165;173;203"
+e_box       = "1;23;24;25;29;38;2;110;115;141"
+e_header    = "1;3;24;25;29;38;2;245;169;127"
+e_user      = "3;22;24;25;29;38;2;138;173;244"
+e_passwd    = "1;23;24;25;29;38;2;166;218;149"
+e_badpasswd = "1;9;23;24;25;38;2;237;135;150"
+e_key       = "22;23;24;25;38;2;139;213;202"

themes/catppuccin-mocha.ini

@@ -0,0 +1,24 @@
+##############################################
+#                                            #
+#              Catppuccin Theme              #
+#                                            #
+##############################################
+
+# Catppuccin Mocha
+# This theme was created by: Catppuccin Org! <3
+
+[colors]
+bg          = "23;24;25;48;2;30;30;46"
+fg          = "22;23;24;25;29;38;2;205;214;244"
+err         = "1;4;23;24;25;38;2;243;139;168"
+s_wayland   = "3;22;24;25;38;2;203;166;247"
+s_xorg      = "3;22;24;25;38;2;203;166;247"
+s_shell     = "3;22;24;25;38;2;245;194;231"
+e_hostname  = "1;3;24;25;29;38;2;245;224;220"
+e_date      = "3;22;24;25;29;38;2;166;173;200"
+e_box       = "1;23;24;25;29;38;2;108;112;134"
+e_header    = "1;3;24;25;29;38;2;250;179;135"
+e_user      = "3;22;24;25;29;38;2;137;180;250"
+e_passwd    = "1;23;24;25;29;38;2;166;227;161"
+e_badpasswd = "1;9;23;24;25;38;2;243;139;168"
+e_key       = "22;23;24;25;38;2;148;226;213"

themes/catppuccin.tera

@@ -0,0 +1,35 @@
+---
+whiskers:
+  version: ^2.5.1
+  matrix:
+    - flavor
+  filename: catppuccin-{{ flavor.identifier }}.ini
+---
+{%- macro rgb(col) -%}
+2;{{ col.rgb.r }};{{ col.rgb.g }};{{ col.rgb.b }}
+{%- endmacro rgb -%}
+
+##############################################
+#                                            #
+#              Catppuccin Theme              #
+#                                            #
+##############################################
+
+# Catppuccin {{flavor.name}}
+# This theme was created by: Catppuccin Org! <3
+
+[colors]
+bg          = "23;24;25;48;{{ self::rgb(col=base) }}"
+fg          = "22;23;24;25;29;38;{{ self::rgb(col=text) }}"
+err         = "1;4;23;24;25;38;{{ self::rgb(col=red) }}"
+s_wayland   = "3;22;24;25;38;{{ self::rgb(col=mauve) }}"
+s_xorg      = "3;22;24;25;38;{{ self::rgb(col=mauve) }}"
+s_shell     = "3;22;24;25;38;{{ self::rgb(col=pink) }}"
+e_hostname  = "1;3;24;25;29;38;{{ self::rgb(col=rosewater) }}"
+e_date      = "3;22;24;25;29;38;{{ self::rgb(col=subtext0) }}"
+e_box       = "1;23;24;25;29;38;{{ self::rgb(col=overlay0) }}"
+e_header    = "1;3;24;25;29;38;{{ self::rgb(col=peach) }}"
+e_user      = "3;22;24;25;29;38;{{ self::rgb(col=blue) }}"
+e_passwd    = "1;23;24;25;29;38;{{ self::rgb(col=green) }}"
+e_badpasswd = "1;9;23;24;25;38;{{ self::rgb(col=red) }}"
+e_key       = "22;23;24;25;38;{{ self::rgb(col=teal) }}"

themes/cherry.ini

@@ -1,35 +1,49 @@
-colors.bg = 48;2;77;33;55
-colors.fg = 22;3;24;38;2;245;245;245
-colors.err = 1;31
-colors.s_wayland = 38;2;255;174;66
-colors.s_xorg = 38;2;37;175;255
-colors.s_shell = 32
-colors.e_hostname = 1;23;38;5;197
-colors.e_date = 31
-colors.e_box = 31
-colors.e_header = 1;4;38;5;204
-colors.e_user = 38;5;51
-colors.e_passwd = 4;2;38;5;203
-colors.e_badpasswd = 4;31
-colors.e_key = 1;23;38;5;197
-chars.hb = ─
-chars.vb = │
-chars.ctl = ┌
-chars.ctr = ┐
-chars.cbl = └
-chars.cbr = ┘
-functions.poweroff = F1
-functions.reboot = F2
-functions.refresh = F5
-strings.f_poweroff = poweroff
-strings.f_reboot = reboot
-strings.f_refresh = refresh
-strings.e_user = user
-strings.e_passwd = password
-strings.s_wayland = wayland
-strings.s_xorg = xorg
-strings.s_shell = shell
-behavior.include_defshell = true
-behavior.source = /etc/lidm.env
-behavior.source = /etc/locale.conf
-behavior.user_source = .lidm.env
+[colors]
+bg = "48;2;77;33;55"
+fg = "22;3;24;38;2;245;245;245"
+# err = "1;31"
+# s_wayland = "38;2;255;174;66"
+# s_xorg = "38;2;37;175;255"
+s_shell = "32"
+e_hostname = "1;23;38;5;197"
+e_date = "31"
+e_box = "31"
+e_header = "1;4;38;5;204"
+e_user = "38;5;51"
+e_passwd = "4;2;38;5;203"
+e_badpasswd = "4;31"
+e_key = "1;23;38;5;197"
+
+[chars]
+# hb = "─"
+# vb = "│"
+# ctl = "┌"
+# ctr = "┐"
+# cbl = "└"
+# cbr = "┘"
+
+[functions]
+# poweroff = F1
+# reboot = F2
+# refresh = F5
+
+[strings]
+# f_poweroff = "poweroff"
+# f_reboot = "reboot"
+# f_refresh = "refresh"
+# e_user = "user"
+# e_passwd = "password"
+# s_wayland = "wayland"
+# s_xorg = "xorg"
+# s_shell = "shell"
+# opts_pre = "< "
+# opts_post = " >"
+# ellipsis = "…"
+
+[behavior]
+# include_defshell = true
+# timefmt = "%X %x"
+# refresh_rate = 100
+source = "/etc/lidm.env"
+source = "/etc/locale.conf"
+user_source = ".lidm.env"

themes/default.ini

@@ -1,35 +1,51 @@
-colors.bg = 48;2;38;28;28
-colors.fg = 22;24;38;2;245;245;245
-colors.err = 1;31
-colors.s_wayland = 38;2;255;174;66
-colors.s_xorg = 38;2;37;175;255
-colors.s_shell = 38;2;34;140;34
-colors.e_hostname = 38;2;255;64;64
-colors.e_date = 38;2;144;144;144
-colors.e_box = 38;2;122;122;122
-colors.e_header = 4;38;2;0;255;0
-colors.e_user = 36
-colors.e_passwd = 4;38;2;245;245;205
-colors.e_badpasswd = 3;4;31
-colors.e_key = 38;2;255;174;66
-chars.hb = ─
-chars.vb = │
-chars.ctl = ┌
-chars.ctr = ┐
-chars.cbl = └
-chars.cbr = ┘
-functions.poweroff = F1
-functions.reboot = F2
-functions.refresh = F5
-strings.f_poweroff = poweroff
-strings.f_reboot = reboot
-strings.f_refresh = refresh
-strings.e_user = user
-strings.e_passwd = password
-strings.s_wayland = wayland
-strings.s_xorg = xorg
-strings.s_shell = shell
-behavior.include_defshell = true
-behavior.source = /etc/lidm.env
-behavior.source = /etc/locale.conf
-behavior.user_source = .lidm.env
+[colors]
+# bg = "48;2;38;28;28"
+# fg = "22;24;38;2;245;245;245"
+# err = "1;31"
+# s_wayland = "38;2;255;174;66"
+# s_xorg = "38;2;37;175;255"
+# s_shell = "38;2;34;140;34"
+# e_hostname = "38;2;255;64;64"
+# e_date = "38;2;144;144;144"
+# e_box = "38;2;122;122;122"
+# e_header = "4;38;2;0;255;0"
+# e_user = "36"
+# e_passwd = "4;38;2;245;245;205"
+# e_badpasswd = "3;4;31"
+# e_key = "38;2;255;174;66"
+
+[chars]
+# hb = "─"
+# vb = "│"
+# ctl = "┌"
+# ctr = "┐"
+# cbl = "└"
+# cbr = "┘"
+
+[functions]
+# poweroff = F1
+# reboot = F2
+# fido = NONE
+# refresh = F5
+
+[strings]
+# f_poweroff = "poweroff"
+# f_reboot = "reboot"
+# f_fido = "fido"
+# f_refresh = "refresh"
+# e_user = "user"
+# e_passwd = "password"
+# s_wayland = "wayland"
+# s_xorg = "xorg"
+# s_shell = "shell"
+# opts_pre = "< "
+# opts_post = " >"
+# ellipsis = "…"
+
+[behavior]
+# include_defshell = true
+# timefmt = "%X %x"
+# refresh_rate = 100
+source = "/etc/lidm.env"
+source = "/etc/locale.conf"
+user_source = ".lidm.env"

themes/kanagawa-dragon.ini

@@ -1,35 +1,49 @@
-colors.bg = 48;2;24;22;22
-colors.fg = 22;24;38;2;185;185;185
-colors.err = 1;31
-colors.s_wayland = 38;2;255;174;66
-colors.s_xorg = 38;2;37;175;255
-colors.s_shell = 38;2;34;140;34
-colors.e_hostname = 38;2;208;189;156
-colors.e_date = 38;2;144;144;144
-colors.e_box = 38;2;122;122;122
-colors.e_header = 4;38;2;126;146;178
-colors.e_user = 38;2;148;89;84
-colors.e_passwd = 4;38;2;245;245;205
-colors.e_badpasswd = 3;4;31
-colors.e_key = 38;2;255;174;66
-chars.hb = ─
-chars.vb = │
-chars.ctl = ┌
-chars.ctr = ┐
-chars.cbl = └
-chars.cbr = ┘
-functions.poweroff = F1
-functions.reboot = F2
-functions.refresh = F5
-strings.f_poweroff = poweroff
-strings.f_reboot = reboot
-strings.f_refresh = refresh
-strings.e_user = user
-strings.e_passwd = password
-strings.s_wayland = wayland
-strings.s_xorg = xorg
-strings.s_shell = shell
-behavior.include_defshell = true
-behavior.source = /etc/lidm.env
-behavior.source = /etc/locale.conf
-behavior.user_source = .lidm.env
+[colors]
+bg = "48;2;24;22;22"
+fg = "22;24;38;2;185;185;185"
+# err = "1;31"
+# s_wayland = "38;2;255;174;66"
+# s_xorg = "38;2;37;175;255"
+# s_shell = "38;2;34;140;34"
+e_hostname = "38;2;208;189;156"
+e_date = "38;2;144;144;144"
+# e_box = "38;2;122;122;122"
+e_header = "4;38;2;126;146;178"
+e_user = "38;2;148;89;84"
+# e_passwd = "4;38;2;245;245;205"
+# e_badpasswd = "3;4;31"
+# e_key = "38;2;255;174;66"
+
+[chars]
+# hb = "─"
+# vb = "│"
+# ctl = "┌"
+# ctr = "┐"
+# cbl = "└"
+# cbr = "┘"
+
+[functions]
+# poweroff = F1
+# reboot = F2
+# refresh = F5
+
+[strings]
+# f_poweroff = "poweroff"
+# f_reboot = "reboot"
+# f_refresh = "refresh"
+# e_user = "user"
+# e_passwd = "password"
+# s_wayland = "wayland"
+# s_xorg = "xorg"
+# s_shell = "shell"
+# opts_pre = "< "
+# opts_post = " >"
+# ellipsis = "…"
+
+[behavior]
+# include_defshell = true
+timefmt = "%Y-%m-%d %H:%M:%S"
+# refresh_rate = 100
+source = "/etc/lidm.env"
+source = "/etc/locale.conf"
+user_source = ".lidm.env"