.cargo/config → .cargo/config.toml

@@ -2,6 +2,17 @@
 linker = "aarch64-unknown-redox-gcc"
 rustflags = []
 
+[target.i686-unknown-redox]
+linker = "i686-unknown-redox-gcc"
+rustflags = []
+
 [target.x86_64-unknown-redox]
 linker = "x86_64-unknown-redox-gcc"
 rustflags = []
+
+[target.riscv64gc-unknown-redox]
+linker = "riscv64-unknown-redox-gcc"
+rustflags = []
+
+[env]
+CFLAGS_riscv64gc_unknown_redox="-march=rv64gc -mabi=lp64d"

.gitignore

-build
-repo
+/build
+/repo
 source
 source.tmp
 source-new
 source.tar
 source.tar.tmp
-stage
-stage.tmp
-stage.pkg
-stage.pkgar
-stage.sig
-stage.tar
-stage.tar.gz
-stage.toml
-sysroot
-sysroot.tmp
-xargo
-
-
-#Added by cargo
-
-/target
-**/*.rs.bk
+target

.gitmodules

@@ -6,7 +6,3 @@
 	path = pkgar
 	url = https://gitlab.redox-os.org/redox-os/pkgar.git
 	branch = master
-[submodule "pkgutils"]
-	path = pkgutils
-	url = https://gitlab.redox-os.org/redox-os/pkgutils.git
-	branch = master

Cargo.toml

@@ -20,13 +20,12 @@ name = "cookbook"
 path = "src/lib.rs"
 
 [dependencies]
-blake3 = "1"
+blake3 = "=1.5.3" # 1.5.4 is incompatible with blake3 0.3 dependency from pkgar
 pbr = "1.0.2"
 pkgar = "0.1.7"
 pkgar-keys = "0.1.0"
-redoxer = "0.2.25"
-serde = { version = "1.0.110", features = ["derive"] }
-sha2 = "0.10"
-termion = "1.5.5"
-toml = "0.5.6"
+redoxer = "0.2"
+serde = { version = "=1.0.197", features = ["derive"] }
+termion = "4"
+toml = "0.8"
 walkdir = "2.3.1"

README.md

-# cookbook
-A collection of package recipes for Redox.
+# Cookbook
 
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+Package system of Redox.
+
+This repository contains the system source code and packages inside the `recipes` folder.
+
+- A recipe can be a software port or system package (they use `pkgar` or `tar.gz` formats).
+
+**Read [this](https://doc.redox-os.org/book/porting-applications.html) page before porting programs to Redox**
 
 In order for this repository to be useful, it must be set up with an environment
-from the [Redox repository](https://gitlab.redox-os.org/redox-os/redox).
+from the [redox](https://gitlab.redox-os.org/redox-os/redox) repository.
+
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+- [Recipe Categories](#recipe-categories)
+- [Search Recipes](#search-recipes)
+- [Package Policy](#package-policy)
+    - [Cross-Compilation](#cross-compilation)
+    - [Library Linking](#library-linking)
+    - [ABI stability](#abi-stability)
+    - [Checksum](#checksum)
+    - [License](#license)
+- [Testing Area](#testing-area)
+    - [Suggestions for TODOs](#suggestions-for-todos)
+- [Repository Layout](#repository-layout)
+- [TODO](#todo)
+
+### Recipe Categories
+
+The categories inside the `recipes` folder.
+
+- `core` - System components
+- `demos` - Programs with demos and examples
+- `dev` - Programs used for development and programming languages, like compilers and dependency managers
+- `doc` - Programs used for documentation
+- `emulators` - Console emulators or compatibility layers
+- `fonts` - Fonts and programs for fonts
+- `games` - Any kind of game
+- `graphics` - Programs used for graphics processing or production
+- `gui` - Orbital
+- `icons` - Icon packs
+- `libs` - Software with functions for other softwares, like OpenSSL
+- `math` - Programs used for calculations
+- `net` - Networking tools
+- `other` - Software that can't fit on other categories
+- `shells` - Terminal interpreters and extensions
+- `sound` - Software used for sound processing or production
+- `tests` - Software used to test other softwares
+- `tools` - Text editors, terminal tools and any other kind of tools
+- `tui` - Programs with a [terminal user interface](https://en.wikipedia.org/wiki/Text-based_user_interface)
+- `video` - Programs used for video playback, processing and production
+- `web` - World Wide Web browsers and tools
+- `wip` - Software that needs porting or incomplete recipes
+
+### Search Recipes
+
+Click in the button named "Find file" on the top of this repository to search for recipe names.
+
+### Package Policy
+
+Before sending your recipe to upstream (to become a public package), you must follow these rules:
+
+#### Cross-Compilation
+
+- All recipes must use our cross-compilers, a Cookbook [template](https://doc.redox-os.org/book/porting-applications.html#templates) does this automatically but it's not always possible, study the build system of your program or library to find these options or patch the configuration files.
+- Don't hardcode the CPU architecture on the recipe script (this would break the multi-arch support).
+
+#### Tarballs
+
+- Don't use the auto-generated tarballs from GitHub, they aren't static and don't verify the archive integrity.
+
+#### Library Linking
+
+- Keep the static linking of libraries to reduce the launch time and improve security.
+- If your package is bigger than 50MB, dynamic link big libraries until your package is equal or less than 50MB (to reduce the RAM usage).
+
+#### ABI stability
+
+- Respect the ABI separation of the libraries, for example, if `openssl1` is available and some program need `openssl3`, you will create a recipe for `openssl3` and not rename the `openssl1`, as it will break the dependent packages.
+
+#### Checksum
+
+- If your recipe download a tarball, you will need to create a BLAKE3 hash for it. You can learn how to do it [here](https://doc.redox-os.org/book/porting-applications.html#create-a-blake3-hash-for-your-recipe).
+
+#### License
+
+- Don't package programs or libraries lacking a license.
+- Verify if the program has some license violation, in case of doubt ask us on the [chat](https://doc.redox-os.org/book/chat.html).
+- Non-free programs and assets should go to a subcategory of the `nonfree` category and be approved per license.
+
+### Testing Area
+
+Work-in-progress software ports goes to the `wip` category, be aware of these items during your packaging process:
+
+- A recipe is considered ready if it's mostly working inside of Redox.
+- All WIP recipes must have a `#TODO` on the beginning of the `recipe.toml` and explain what is missing.
+- BLAKE3 hashes for tarballs are optional (quick testing workflow)
+- Try to keep the recipe with the latest stable version of the program (the porting process can take months).
+- Once the recipe is ready, add the BLAKE3 hash if needed and move the folder to the appropriate category.
+
+#### Suggestions for TODOs
+
+These TODOs improve the packagers cooperation and understanding.
+
+- `not compiled or tested` - It means that your recipe is fully configured and don't lack necessary dependencies.
+- `missing script for x, see insert-the-link-for-build-instructions-here` - It means that your recipe is lacking the cross-compilation script for some build system, where `x` is the build system name. After `see` you will insert the link for the build instructions of the program or library, it will help other packagers to insert the script for you.
+- `missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that the `dependencies = []` section is incomplete.
+- `probably wrong script, see insert-the-link-for-build-instructions-here` - It means that you don't know if your script will work.
+- `probably wrong template, see insert-the-link-for-build-instructions-here` - It means that you don't know if the Cookbook template will work.
+- `probably missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that you don't know if the required dependencies are satisfied.
+- `promote` - It means that the recipe is working and should be moved to the equivalent category at `cookbook/recipes`
+
+Other TODOs are specific and won't be covered on this list.
+
+### Repository Layout
+
+- `.cargo` - Cargo configuration.
+- `bin` - LLVM and pkg-config CPU targets.
+- `recipes` - Package configuration files.
+- `src` - Package system source code.
+
+### TODO
+
+- Convert old recipes to TOML, see [this](https://gitlab.redox-os.org/redox-os/cookbook/-/issues/174) tracking issue.
+- Remove the scripts after full TOML conversion.

Xargo.toml

-[target.aarch64-unknown-redox.dependencies.std]
-features = ["panic_unwind"]
-
-[target.x86_64-unknown-redox.dependencies.std]
-features = ["panic_unwind"]
-#features = ["panic_unwind", "backtrace"]
-
-#[dependencies.test]
-#stage = 1
-

bin/aarch64-unknown-redox-pkg-config

 #!/usr/bin/env bash
 
-export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_RECIPE}/sysroot"
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
 export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
 export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
 

bin/i686-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

bin/riscv64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+exec pkg-config --static "$@"

bin/x86_64-unknown-redox-pkg-config

 #!/usr/bin/env bash
 
-export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_RECIPE}/sysroot"
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
 export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
 export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
 

clean.sh

@@ -5,14 +5,12 @@ source config.sh
 
 if [ $# = 0 ]
 then
-    recipes="$(ls -1 recipes)"
+    recipes="$(target/release/list_recipes)"
 else
     recipes="$@"
 fi
 
-for recipe in $recipes
+for recipe_path in $recipes
 do
-    ./cook.sh "$recipe" distclean
+    ./cook.sh "$recipe_path" distclean
 done
-
-rm -rf xargo

config.sh

@@ -8,12 +8,14 @@ then
 fi
 ARCH="${TARGET%%-*}"
 HOST="$TARGET"
+if [ x"${HOST}" == x"riscv64gc-unknown-redox" ] ; then
+	HOST="riscv64-unknown-redox"
+fi
 
 # Automatic variables
 ROOT="$(cd `dirname "$0"` && pwd)"
 REPO="$ROOT/repo/$TARGET"
 export PATH="${ROOT}/bin:$PATH"
-export XARGO_HOME="${ROOT}/xargo"
 
 export AR="${HOST}-gcc-ar"
 export AS="${HOST}-as"
@@ -52,3 +54,17 @@ else
     FIND="find"
     STAT="stat";
 fi
+
+export FIND
+export STAT
+
+if [ ! "$(uname -s)" = "Redox" ]
+then
+function docgen {
+    "$ROOT/docgen/target/release/docgen" "$@"
+}
+
+function pkgar {
+    "$ROOT/pkgar/target/release/pkgar" "$@"
+}
+fi

cook.sh

@@ -20,49 +20,20 @@ else
     SHASUM="shasum -a 256"
 fi
 
-if [ ! "$(uname -s)" = "Redox" ]
-then
-function docgen {
-    CC=cc cargo run --release --manifest-path "$ROOT/docgen/Cargo.toml" --bin docgen -- "$@"
-}
-
-function pkg {
-    CC=cc cargo run --release --manifest-path "$ROOT/pkgutils/Cargo.toml" --bin pkg -- "$@"
-}
-
-function pkgar {
-    CC=cc cargo run --release --manifest-path "$ROOT/pkgar/Cargo.toml" --bin pkgar -- "$@"
-}
-fi
-
 function usage {
     echo "cook.sh $1 <op>" >&2
     echo "  dist" >&2
     echo "  distclean" >&2
     echo "  build" >&2
     echo "  clean" >&2
-    echo "  diff" >&2
-    echo "  diff_origin" >&2
-    echo "  diff_upstream" >&2
-    echo "  difftool" >&2
-    echo "  difftool_origin" >&2
-    echo "  difftool_upstream" >&2
     echo "  fetch" >&2
     echo "  unfetch" >&2
     echo "  pkg" >&2
     echo "  unpkg" >&2
     echo "  prepare" >&2
     echo "  unprepare" >&2
-    echo "  publish" >&2
-    echo "  unpublish" >&2
     echo "  stage" >&2
     echo "  unstage" >&2
-    echo "  status" >&2
-    echo "  status_origin" >&2
-    echo "  status_upstream" >&2
-    echo "  tar" >&2
-    echo "  untar" >&2
-    echo "  update" >&2
     echo "  version" >&2
 }
 
@@ -77,12 +48,10 @@ function op {
             op $1 prepare
             op $1 build
             op $1 stage
-            op $1 tar
             op $1 pkg
             ;;
         distclean)
             op $1 unpkg
-            op $1 untar
             op $1 unstage
             op $1 unprepare
             ;;
@@ -98,7 +67,8 @@ function op {
                 then
                     if [ ! -f source.tar ]
                     then
-                        wget "$TAR" -O source.tar
+                        wget "$TAR" --continue -O source.tar.tmp
+                        mv source.tar.tmp source.tar
                     fi
 
                     if [ -n "$TAR_SHA256" ]
@@ -150,113 +120,7 @@ function op {
             fi
             ;;
         unfetch)
-            rm -rfv source
-            if [ -n "$TAR" ]
-            then
-                rm -f source.tar
-            fi
-            ;;
-        status)
-            if [ -n "$TAR" ]
-            then
-                tar --compare --file="source.tar" -C "source" --strip-components=1 2>&1 |
-                grep -v "tar: :" | grep -v '\(Mod time\|Mode\|Gid\|Uid\) differs' ||
-                true
-            elif [ -n "$GIT" ]
-            then
-                git -C source diff --stat --color
-            fi
-            ;;
-        status_origin)
-            if [ -n "$GIT" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff --stat --color "origin/$BRANCH"
-                else
-                    git -C source diff --stat --color "origin/master"
-                fi
-            fi
-            ;;
-        status_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff --stat --color "upstream/$BRANCH"
-                else
-                    git -C source diff --stat --color "upstream/master"
-                fi
-            fi
-            ;;
-        diff)
-            if [ -n "$GIT" ]
-            then
-                git -C source diff
-            fi
-            ;;
-        diff_origin)
-            if [ -n "$GIT" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff "origin/$BRANCH"
-                else
-                    git -C source diff "origin/master"
-                fi
-            fi
-            ;;
-        diff_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff "upstream/$BRANCH"
-                else
-                    git -C source diff "upstream/master"
-                fi
-            fi
-            ;;
-        difftool)
-            if [ -n "$GIT" ]
-            then
-                git -C source difftool -d
-            fi
-            ;;
-        difftool_origin)
-            if [ -n "$GIT" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source difftool -d "origin/$BRANCH"
-                else
-                    git -C source difftool -d "origin/master"
-                fi
-            fi
-            ;;
-        difftool_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source difftool -d "upstream/$BRANCH"
-                else
-                    git -C source difftool -d "upstream/master"
-                fi
-            fi
-            ;;
-        update)
-            pushd source > /dev/null
-            skip=0
-            if [ "$(type -t recipe_update)" = "function" ]
-            then
-                recipe_update
-            fi
-            if [ "$skip" -eq "0" ]
-            then
-                "${CARGO[@]}" update
-            fi
-            popd > /dev/null
+            rm -rfv source source.tar
             ;;
         prepare)
             skip=0
@@ -266,8 +130,16 @@ function op {
             fi
             if [ "$skip" -eq "0" ]
             then
-                rm -rf sysroot
-                mkdir sysroot
+                rm -rf "${COOKBOOK_SYSROOT}"
+                mkdir "${COOKBOOK_SYSROOT}"
+
+                # usrmerge
+                mkdir "${COOKBOOK_SYSROOT}/usr"
+                for folder in bin include lib share
+                do
+                    mkdir "${COOKBOOK_SYSROOT}/usr/${folder}"
+                    ln -s "usr/${folder}" "${COOKBOOK_SYSROOT}/${folder}"
+                done
 
                 if [ ${#BUILD_DEPENDS} -gt 0 ]
                 then
@@ -279,32 +151,32 @@ function op {
                     do
                         pkgar \
                             extract \
-                            sysroot \
+                            "${COOKBOOK_SYSROOT}" \
                             --archive "$REPO/$i.pkgar" \
                             --pkey "${ROOT}/build/id_ed25519.pub.toml"
                     done
                 fi
 
-                rm -rf build
+                rm -rf "${COOKBOOK_BUILD}"
                 if [ "$PREPARE_COPY" -eq "0" ]
                 then
-                    mkdir build
+                    mkdir "${COOKBOOK_BUILD}"
                 else
-                    cp -rp source build
+                    cp -Rp source "${COOKBOOK_BUILD}"
                 fi
 
                 for patch in *.patch
                 do
-                    patch -p1 -d build < "$patch"
+                    patch -p1 -d "${COOKBOOK_BUILD}" < "$patch"
                 done
             fi
             ;;
         unprepare)
-            rm -rf build
-            rm -rf sysroot
+            rm -rf "${COOKBOOK_BUILD}"
+            rm -rf "${COOKBOOK_SYSROOT}"
             ;;
         version)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_version)" = "function" ]
             then
@@ -312,20 +184,21 @@ function op {
             fi
             if [ "$skip" -eq "0" ]
             then
-                cargo config package.version | tr -d '"'
+                # there's an unstable built-in cargo config command, so hack around it
+                cargo-config config package.version | tr -d '"'
             fi
             popd > /dev/null
             ;;
         gitversion)
-            if [ -d build/.git ]
+            if [ -d "${COOKBOOK_BUILD}"/.git ]
             then
-                echo "$(op $1 version)-$(git -C build rev-parse --short HEAD)"
+                echo "$(op $1 version)-$(git -C "${COOKBOOK_BUILD}" rev-parse --short HEAD)"
             else
                 op $1 version
             fi
             ;;
         build)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_build)" = "function" ]
             then
@@ -346,34 +219,12 @@ function op {
 
             if [ "$skip" -eq "0" ]
             then
-                cp -p "$ROOT/Xargo.toml" "Xargo.toml"
                 "${CARGO[@]}" "$CARGOBUILD" --target "$TARGET" $release_flag $package_flag $CARGOFLAGS
             fi
             popd > /dev/null
             ;;
-        test)
-            pushd build > /dev/null
-            skip=0
-            if [ "$(type -t recipe_test)" = "function" ]
-            then
-                recipe_test
-            fi
-
-            release_flag="--release"
-            if [ "$DEBUG" == 1 ]
-            then
-                release_flag=
-            fi
-
-            if [ "$skip" -eq "0" ]
-            then
-                cp -p "$ROOT/Xargo.toml" "Xargo.toml"
-                "${CARGO[@]}" test --no-run --target "$TARGET" $release_flag $CARGOFLAGS
-            fi
-            popd > /dev/null
-            ;;
         clean)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_clean)" = "function" ]
             then
@@ -387,10 +238,10 @@ function op {
             ;;
         stage)
             op $1 unstage
-            mkdir -p stage
-            stage="$(realpath stage)"
+            mkdir -p "${COOKBOOK_STAGE}"
+            stage="$(realpath "${COOKBOOK_STAGE}")"
             source="$(realpath source)"
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_stage)" = "function" ]
             then
@@ -438,22 +289,19 @@ function op {
             popd > /dev/null
             ;;
         unstage)
-            rm -rfv stage
+            rm -rfv "${COOKBOOK_STAGE}"
             ;;
         pkg)
             pkgar \
                 create \
-                --archive stage.pkgar \
+                --archive "${COOKBOOK_STAGE}.pkgar" \
                 --skey "${ROOT}/build/id_ed25519.toml" \
-                stage
-            ;;
-        unpkg)
-            rm -fv stage.pkgar
-            ;;
-        tar)
-            echo "name = \"$1\"" > "stage.toml"
-            echo "version = \"$(op $1 version)\"" >> "stage.toml"
-            echo "target = \"$TARGET\"" >> "stage.toml"
+                "${COOKBOOK_STAGE}"
+
+            # Generate stage.toml
+            echo "name = \"$1\"" > "${COOKBOOK_STAGE}.toml"
+            echo "version = \"$(op $1 version)\"" >> "${COOKBOOK_STAGE}.toml"
+            echo "target = \"$TARGET\"" >> "${COOKBOOK_STAGE}.toml"
 
             # Add runtime dependencies to package if they exist
             if [ -n "$DEPENDS" ]
@@ -461,35 +309,13 @@ function op {
                 # Remove leading and trailing whitespace, replace whitespace between
                 # package names with commas, and surround package names with quotes
                 dependencies=$(echo -e "$DEPENDS" | sed -E 's/^[[:space:]]*//;s/[[:space:]]*$//;s/[[:space:]]+/,/g;s/[^, ][^, ]*/"&"/g')
-                echo "depends = [$dependencies]" >> "stage.toml"
-			else
-				echo "depends = []" >> "stage.toml"
+                echo "depends = [$dependencies]" >> "${COOKBOOK_STAGE}.toml"
+            else
+                echo "depends = []" >> "${COOKBOOK_STAGE}.toml"
             fi
-
-            rm -rf stage/pkg
-            mkdir -p stage/pkg
-
-            pushd stage > /dev/null
-            find -L . -type f | cut -d / -f 2- | sort | while read file
-            do
-                $SHASUM "$file" >> "pkg/$1.sha256sums"
-            done
-            popd > /dev/null
-
-            cp -v stage.toml "stage/pkg/$1.toml"
-            pkg --target=$TARGET create stage
-            ;;
-        untar)
-            rm -rfv stage.tar.gz stage.sig stage.toml
             ;;
-        publish)
-            mkdir -p "$REPO"
-            cp -v stage.tar.gz "$REPO/$1.tar.gz"
-            cp -v stage.sig "$REPO/$1.sig"
-            cp -v stage.toml "$REPO/$1.toml"
-            ;;
-        unpublish)
-            rm -rfv "$REPO/$1.tar.gz" "$REPO/$1.sig" "$REPO/$1.toml"
+        unpkg)
+            rm -fv "${COOKBOOK_STAGE}.pkgar" "${COOKBOOK_STAGE}.toml"
             ;;
         *)
             usage $1
@@ -499,15 +325,30 @@ function op {
 
 if [ -n "$1" ]
 then
-    if [ -d "$ROOT/recipes/$1" ]
+    if (echo "$1" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$1")
+        recipe_path="recipes/$1"
+    else
+        recipe_name="$1"
+        recipe_path=`target/release/find_recipe $recipe_name`
+    fi
+
+    if [ -d "$ROOT/$recipe_path" ]
     then
-        export COOKBOOK_RECIPE="${ROOT}/recipes/$1"
+        export COOKBOOK_RECIPE="${ROOT}/$recipe_path"
+
+        TARGET_DIR="${COOKBOOK_RECIPE}/target/${TARGET}"
+        mkdir -p "${TARGET_DIR}"
 
+        export COOKBOOK_BUILD="${TARGET_DIR}/build"
+        export COOKBOOK_STAGE="${TARGET_DIR}/stage"
+        export COOKBOOK_SOURCE="${COOKBOOK_RECIPE}/source"
+        export COOKBOOK_SYSROOT="${TARGET_DIR}/sysroot"
 
         export PKG_CONFIG_ALLOW_CROSS=1
         export PKG_CONFIG_PATH=
-        export PKG_CONFIG_LIBDIR="${COOKBOOK_RECIPE}/sysroot/lib/pkgconfig"
-        export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_RECIPE}/sysroot"
+        export PKG_CONFIG_LIBDIR="${COOKBOOK_SYSROOT}/lib/pkgconfig"
+        export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
 
         cd "${COOKBOOK_RECIPE}"
 
@@ -528,10 +369,10 @@ then
 
         for i in "${ops[@]}"
         do
-            op "$1" "$i"
+            op "$recipe_name" "$i"
         done
     else
-        echo "cook.sh: recipe '$1' not found" >&2
+        echo "cook.sh: recipe '$recipe_name' at not found" >&2
         exit 1
     fi
 else

fetch.sh

@@ -5,18 +5,25 @@ source config.sh
 
 if [ $# = 0 ]
 then
-    recipes="$(ls -1 recipes)"
+    recipes="$(target/release/list_recipes)"
 else
     recipes="$@"
 fi
 
-for recipe in $recipes
+for recipe_path in $recipes
 do
-    if [ -e "recipes/$recipe/recipe.toml" ]
-    then
-        target/release/cook --fetch-only "$recipe"
-        continue
+    if (echo "$recipe_path" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$recipe_path")
+        recipe_path="recipes/$recipe_path"
+    else
+        recipe_name="$recipe_path"
+        recipe_path=`target/release/find_recipe $recipe_name`
     fi
 
-    ./cook.sh "$recipe" fetch
+    if [ -e "$recipe_path/recipe.toml" ]
+    then
+        target/release/cook --fetch-only "$recipe_name"
+    else
+        ./cook.sh "$recipe_name" fetch
+    fi
 done

pkgar @ ccfa2bd3

-Subproject commit 2bf580756f63dccefc8fbe115b77e8b18025bb65
+Subproject commit ccfa2bd3adc41f192d12cb1778a85da232fa2456

pkgutils @ 410b9b07

-Subproject commit 410b9b0761d9c933490e9ee2c0668eea9d9af181

recipes/archives/lz4/recipe.toml

+[source]
+tar = "https://github.com/lz4/lz4/releases/download/v1.10.0/lz4-1.10.0.tar.gz"
+blake3 = "3e69fd475e7852e17594985528b5232afeba7d3d56cfebe2e89071768b2ab36a"
+patches = ["redox.patch"]
+
+[build]
+template = "custom"
+script = """
+rsync -av --delete "${COOKBOOK_SOURCE}/" ./
+
+# No configure provided
+COOKBOOK_CONFIGURE="true"
+COOKBOOK_CONFIGURE_FLAGS=""
+
+export CPPFLAGS="${CPPFLAGS} -D_REDOX"
+
+cookbook_configure 
+"""

recipes/archives/lz4/redox.patch

+diff '--color=auto' -ruwN source/programs/util.h source-new/programs/util.h
+--- source/programs/util.h	2024-07-21 13:29:49.000000000 -0400
++++ source-new/programs/util.h	2024-12-13 02:21:03.032769559 -0500
+@@ -52,6 +52,9 @@
+ #include <time.h>         /* time */
+ #include <limits.h>       /* INT_MAX */
+ #include <errno.h>
++#if defined(_REDOX)
++#  include <sys/time.h>  /* utimes */
++#endif
+ 
+ 
+ 
+@@ -239,12 +242,20 @@
+         timebuf.modtime = statbuf->st_mtime;
+         res += utime(filename, &timebuf);  /* set access and modification times */
+ #else
++        #if defined(_REDOX)
++            struct timeval timebuf[2];
++            memset(timebuf, 0, sizeof(timebuf));
++            timebuf[0].tv_usec = UTIME_NOW;
++            timebuf[1].tv_sec = statbuf->st_mtime;
++            res += utimes(filename, timebuf);
++        #else
+         struct timespec timebuf[2];
+         memset(timebuf, 0, sizeof(timebuf));
+         timebuf[0].tv_nsec = UTIME_NOW;
+         timebuf[1].tv_sec = statbuf->st_mtime;
+         res += utimensat(AT_FDCWD, filename, timebuf, 0);  /* set access and modification times */
+ #endif
++#endif
+     }
+ 
+ #if !defined(_WIN32)