;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2024 Noé Lopez <noelopez@free.fr>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages appimage)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (gnu packages)
  #:use-module (gnu packages base)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages file-systems)
  #:use-module (gnu packages linux)
  #:use-module (guix build-system gnu)
  #:use-module (guix download)
  #:use-module (guix gexp)
  #:use-module (guix git-download)
  #:use-module (guix packages))

(define fuse-for-appimage
  (package
    (inherit fuse)
    (name "fuse")
    (version "3.15.0")
    (source
     (origin
       (method url-fetch)
       (uri (string-append "https://github.com/libfuse/libfuse/releases/"
                           "download/fuse-"
                           version
                           "/fuse-"
                           version
                           ".tar.xz"))
       (sha256
        (base32 "181cx8g40ki8m85j0pjw50kv4h733g08c769db6przqwbvyrqn3h"))))
    (arguments
     `(#:configure-flags ,#~(list (string-append "-Dudevrulesdir="
                                                 #$output "/udev/rules.d")
                                  "-Duseroot=false" "--default-library=static")
       #:tests? #f
       #:phases ,#~(modify-phases %standard-phases
                     (add-after 'unpack 'set-file-names
                       (lambda* (#:key inputs #:allow-other-keys)
                         ;; libfuse calls out to mount(8) and umount(8).  Make sure
                         ;; it refers to the right ones.
                         (substitute* '("lib/mount_util.c")
                           (("/bin/(u?)mount" _ maybe-u)
                            (search-input-file inputs
                                               (string-append "bin/" maybe-u
                                                              "mount"))))
                         (substitute* '("util/mount.fuse.c")
                           (("/bin/sh")
                            (search-input-file inputs "/bin/sh")))

                         ;; This hack leads libfuse to search for 'fusermount' in
                         ;; $PATH, where it may find a setuid-root binary, instead of
                         ;; trying solely $out/sbin/fusermount and failing because
                         ;; it's not setuid.
                         (substitute* "lib/meson.build"
                           (("-DFUSERMOUNT_DIR=[[:graph:]]+")
                            "-DFUSERMOUNT_DIR=\"/var/empty\"'"))))
                     (add-after 'unpack 'fix-install
                       (lambda* (#:key inputs #:allow-other-keys)
                         (substitute* '("util/meson.build")
                           (("install_helper.sh")
                            "true"))
                         (substitute* '("util/meson.build")
                           (("fuseconf_path = .*")
                            "fuseconf_path = '/etc/fuse.conf'"))))
                     (add-before 'configure 'set-paths
                       (lambda* (#:key inputs outputs #:allow-other-keys)
                         (let ((dummy-init.d (string-append (getcwd)
                                                            "/etc/init.d")))
                           (setenv "MOUNT_FUSE_PATH"
                                   (string-append #$output "/sbin"))
                           (setenv "UDEV_RULES_PATH"
                                   (string-append #$output "/lib/udev/rules.d"))))))))))

(define squashfuse-for-appimage
  (let ((revision "0")
        (commit "e51978cd6bb5c4d16fae9eee43d0b258f570bb0f"))
    (package
      (inherit squashfuse)
      (name "squashfuse")
      (version (git-version "0.1.104" revision commit))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/vasi/squashfuse")
               (commit commit)))
         (file-name (git-file-name name version))
         (sha256
          (base32 "02421zsgcvbip5ff999ci4c748zxsc34yycjfp7rq8afrlnlvl29"))))
      (arguments
       (list
        #:configure-flags #~'("CFLAGS=-ffunction-sections -fdata-sections -Os -no-pie"
                              "LDFLAGS=-static")
        #:phases #~(modify-phases %standard-phases
                     (add-after 'install 'install-private-headers
                       (lambda _
                         (install-file "fuseprivate.h"
                                       (string-append #$output
                                                      "/include/squashfuse/")))))))
      (inputs (list fuse-for-appimage
                    `(,zstd "lib")
                    `(,zstd "static")
                    `(,zlib "out")
                    `(,zlib "static"))))))

(define-public appimage-type2-runtime
  (let ((revision "0")
        (commit "47b665594856b4e8928f8932adcf6d13061d8c30"))
    (package
      (name "appimage-type2-runtime")
      (version (git-version "continuous" revision commit))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "https://github.com/AppImage/type2-runtime")
               (commit commit)))
         (file-name (git-file-name name version))
         (sha256
          (base32 "0954crhlbapxis96g1s0vfpf78ybr64zvjalak387ksxj560g44x"))))
      (arguments
       (list
        #:make-flags #~(list "-Csrc/runtime" "runtime-fuse3"
                             (string-append "CFLAGS="
                                            "-I"
                                            #$fuse-2
                                            "/include/fuse/"
                                            " -DGIT_COMMIT='\""
                                            "guix-"
                                            #$version
                                            "\"'"
                                            " -D_FILE_OFFSET_BITS=64"
                                            " -static"))
        #:phases #~(modify-phases %standard-phases
                     (delete 'configure)
                     (delete 'check)
                     (replace 'install
                       (lambda _
                         (install-file "src/runtime/runtime-fuse3"
                                       (string-append #$output "/bin"))))
                     ;; must be after all elf reliant phases
                     (add-after 'make-dynamic-linker-cache 'set-magic-bytes
                       (lambda _
                         (use-modules (ice-9 binary-ports))
                         (let ((port (open (string-append #$output
                                            "/bin/runtime-fuse3")
                                           (logior O_WRONLY))))
                           (seek port 8 SEEK_SET)
                           (put-bytevector port #vu8(#x41 #x49 #x02))
                           (close-port port)))))
        #:disallowed-references (list squashfuse-for-appimage
                                      fuse-for-appimage zstd zlib)))
      ;; only needed at build time
      (inputs (list squashfuse-for-appimage fuse-for-appimage
                    `(,zstd "static")
                    `(,zlib "static")))
      (build-system gnu-build-system)
      (home-page "https://github.com/AppImage/type2-runtime")
      (synopsis "Runtime for AppImages")
      (description "The runtime is the executable part of every AppImage.  It
mounts the payload via FUSE and executes the entrypoint.")
      (license license:expat))))