Merge branch 'master' into patch-3

Author: HarryVasanth

sh/debian/configure.sh

@@ -388,13 +388,17 @@ elif [[ "--run" = "$1" ]]; then
 elif [[ "--deploy" = "$1" ]]; then
     deployCore
     deployPlatform
-    echo -e "$(tput setaf 6)\nRepositories cloned  and platform has been deployed successfully! $(tput sgr0)"
+    echo -e "$(tput setaf 6)\nRepositories cloned and platform has been deployed successfully! $(tput sgr0)"
     exit 0
 elif [[ "--ssh-keys" = "$1" ]]; then
     sshKeyGen
     echo -e "$(tput setaf 5)\nSSH keys have been generated successfully! $(tput sgr0)"
     checkKeys
     exit 0
+elif [[ "--deploy-core" = "$1" ]]; then
+    deployCore
+    echo -e "$(tput setaf 5)\nRepositories cloned and core has been deployed successfully! $(tput sgr0)"
+    exit 0
 elif [[ "--platform" = "$1" ]]; then
     clonePlatform
     echo -e "$(tput setaf 5)\nPlatform has been cloned successfully! $(tput sgr0)"

subjects/0-shell/README.md

@@ -1,88 +1,104 @@
-## 0-shell
+## 0-Shell
 
-### Objective
+### Overview
 
-The objective of this project is for you to create a simple [shell](https://en.wikipedia.org/wiki/Unix_shell).
+In this project, you'll build **0-shell**, a minimalist Unix-like shell implemented in **Rust**, designed to run core Unix commands using system calls—without relying on external binaries or built-in shells like `bash` or `sh`.
 
-Through the `0-shell` you will get to the core of the `Unix` system and explore an important part of this system’s API which is the process creation and synchronization.
-Executing a command inside a shell implies creating a new process, which execution and final state will be monitored by its parents processes. This set of functions will be the key to success for your project.
+Inspired by tools like [BusyBox](https://en.wikipedia.org/wiki/BusyBox), this project introduces you to key concepts in **Unix system programming**, including **process creation**, **command execution**, and **file system interaction**, all while leveraging Rust's safety and abstraction features to avoid manual memory management.
 
-For this project you will only have to create a simple `Unix shell` where you can run some of the most known commands. For this part of the project, no advanced functions, pipes or redirection will be asked, but you can add them if you like.
+### Role Play
 
-### Instructions
+You are a **system-level developer** assigned to build a lightweight, standalone Unix shell for an embedded Linux environment. Your task is to create a shell that handles basic navigation, file manipulation, and process control—faithfully mimicking essential shell behaviors without relying on existing shell utilities.
 
-- You must program a mini `Unix shell`, try to focus on something simple like [BusyBox](https://en.wikipedia.org/wiki/BusyBox).
-- This interpreter must display at least a simple `$` and wait until you type a command line which will be validated by pressing enter.
-- The `$` will be shown again only once the command has been completely executed.
-- The command lines are simple, you will not have pipes, redirection or any other advanced functions.
-- You must manage the errors, by displaying a message adapted to the error output.
-- You must implement the following commands:
-  - `echo`
-  - `cd`
-  - `ls`, including the flags `-l`, `-a` and `-F`
-  - `pwd`
-  - `cat`
-  - `cp`
-  - `rm`, including the flag `-r`
-  - `mv`
-  - `mkdir`
-  - `exit`
+### Learning Objectives
 
-> The commands need to be implemented from scratch, without calling any external binaries.
+- Work with **file and directory operations**
+- Manage **user input and output** within a shell loop
+- Implement **robust error handling**
+- Gain experience in **Unix process and system call APIs**
 
-- You must manage the program interruption `Ctrl + D`.
-- The project has to be written in a compiled language (like C, Rust, Go or other), **interpreted languages (like Perl and others) are not allowed**.
-- The code must respect the [good practices](https://public.01-edu.org/subjects/good-practices/)
+### Core Requirements
 
-This project will help you learn about:
+Your minimalist shell must:
 
-- Shell
-- Operating systems services
-- Command-line interfaces
-- Unix system
-- Process creation and synchronization
-- Commands syntax
-- Scripting language
+- Display a prompt (`$ `) and wait for user input
+- Parse and execute user commands
+- Return to the prompt only after command execution completes
+- Handle `Ctrl+D` (EOF) gracefully to exit the shell
 
-### Bonus
+You must implement the following commands **from scratch**, using system-level Rust abstractions:
 
-You can also do more bonus features like:
+- `echo`
+- `cd`
+- `ls` (supporting `-l`, `-a`, `-F`)
+- `pwd`
+- `cat`
+- `cp`
+- `rm` (supporting `-r`)
+- `mv`
+- `mkdir`
+- `exit`
 
-- Implement the commands exclusively using `low-level system calls` avoiding built-in functions or libraries that abstract file operations.
+Additional constraints:
 
-  - Avoid High-Level Abstractions: Instead of using functions like the Go `os.Open, os.Remove, and io.Copy`, you would use system calls directly through the `syscall` package using `syscall.Open, syscall.Close, syscall.Read, syscall.Write, syscall.Unlink`.
+- Do **not** use any external binaries or system calls that spawn them
+- If a command is unrecognized, print:  
+  `Command '<name>' not found`
 
-- Manage the interruption `Ctrl + C`
-- Auto complete when you are writing
-- Add piping
-- Add redirection
-- Have your path behind the `$` like (~/Desktop/0-shell $)
-- Add colors for the directories or errors
-- Other advanced commands you may like.
+### Constraints
 
-### Usage
+- Only basic command syntax is required  
+  (No piping `|`, no redirection `>`, no globbing `*`, etc.)
+- Shell behavior should align with Unix conventions
+- Code must follow [good coding practices](https://public.01-edu.org/subjects/good-practices/)
 
-```
+### Bonus Features
+
+Implementing any of the following will be considered bonus:
+
+- Handle `Ctrl+C` (SIGINT) without crashing the shell
+- Shell usability enhancements:
+  - **Auto-completion**
+  - **Command history**
+  - **Prompt with current directory** (e.g., `~/projects/0-shell $`)
+  - **Colorized output** for commands, directories, and errors
+  - **Command chaining** with `;`
+  - **Pipes** (`|`)
+  - **I/O redirection** (`>`, `<`)
+- Support for environment variables (e.g. `$HOME`, `$PATH`)
+- A custom `help` command documenting built-in functionality
+
+### Example Usage
+
+```shell
 student$ ./0-shell
 $ cd dev
 $ pwd
-dev
+/dev
 $ ls -l
 total 0
-crw-------  1 root   root     10,    58 fev  5 09:21 acpi_thermal_rel
-crw-r--r--  1 root   root     10,   235 fev  5 09:21 autofs
-drwxr-xr-x  2 root   root           540 fev  5 09:21 block
-crw-------  1 root   root     10,   234 fev  5 09:21 btrfs-control
-drwxr-xr-x  3 root   root            60 fev  5 09:20 bus
-drwxr-xr-x  2 root   root          4400 fev  5 09:21 char
-crw-------  1 root   root      5,     1 fev  5 09:21 console
-lrwxrwxrwx  1 root   root            11 fev  5 09:20 core -> /proc/kcore
-drwxr-xr-x  2 root   root            60 fev  5 09:20 cpu
-crw-------  1 root   root     10,    59 fev  5 09:21 cpu_dma_latency
+crw-------  1 root   root     10,    58 Feb  5 09:21 acpi_thermal_rel
+crw-r--r--  1 root   root     10,   235 Feb  5 09:21 autofs
+drwxr-xr-x  2 root   root           540 Feb  5 09:21 block
+...
 $ something
 Command 'something' not found
 $ echo "Hello There"
 Hello There
 $ exit
 student$
 ```
+
+### Evaluation Criteria
+
+This project will be reviewed and graded based on the following:
+
+- **Functionality**: Commands perform correctly and emulate standard Unix behavior
+- **Stability**: Shell handles user errors, invalid input, and edge cases without crashing
+
+### Resources
+
+- [man pages](https://man7.org/linux/man-pages/) (e.g., `man 2 open`, `man 2 execve`)
+- [Unix Shell - Wikipedia](https://en.wikipedia.org/wiki/Unix_shell)
+- [BusyBox](https://busybox.net/)
+- [Rust std::fs and std::process Docs](https://doc.rust-lang.org/std/)

subjects/0-shell/audit/README.md

@@ -1,10 +1,10 @@
 #### General
 
-###### Was the project written in a compiled programming language?
+###### Was the project written in Rust?
 
 ###### Are the commands mentioned in the subject implemented from scratch, without calling any external binaries?
 
-The use of execution commands (such as exec, system, os/exec, or similar functions) to call **external binaries** or utilities is strictly forbidden, as the project requires implementing all functionality from scratch without relying on external programs.
+The use of external binaries or system calls that spawn them is strictly forbidden, as the project requires implementing all functionality from scratch without relying on external programs.
 
 #### Functional
 
@@ -20,76 +20,74 @@ The use of execution commands (such as exec, system, os/exec, or similar functio
 
 ###### Can you confirm that the interpreter only validates the command if you press enter?
 
-##### Try to run the command `"exit"`.
+##### Try to run the command `exit`.
 
 ###### Can you confirm that the interpreter terminates properly and gives back the parent's shell?
 
-##### Try to run the command `"echo "something!""`. Do the same in your computer terminal.
+##### Try to run the command `echo "something!"`. Do the same in your computer terminal.
 
 ###### Can you confirm that the displayed message of the project is exactly the same as the computer terminal?
 
-##### Try to run the command `"echo something else"` (without double quotes). Do the same in your computer terminal.
+##### Try to run the command `echo something else` (without double quotes). Do the same in your computer terminal.
 
 ###### Can you confirm that the displayed message of the project is exactly the same as the computer terminal?
 
-##### Try to run the command `"pwd"`.
+##### Try to run the command `pwd`.
 
 ###### Can you confirm that the interpreter displayed the current path?
 
-##### Try to open the project and create a parent folder with two children folders using the command "mkdir". Then enter the parent folder and do "pwd".
+##### Try to open the project and create a parent folder with two children folders using the command `mkdir`. Then enter the parent folder and do `pwd`.
 
 ###### Can you confirm that the interpreter displayed the current path?
 
-##### Try to enter a directory of your choice by using the command `"cd dir/of/your/choice"`.
+##### Try to enter a directory of your choice by using the command `cd dir/of/your/choice`.
 
-###### Can you confirm that the interpreter took you to the correct path? Use `"pwd"` to confirm.
+###### Can you confirm that the interpreter took you to the correct path? Use `pwd` to confirm.
 
-##### Try to run only the command `"cd"`.
+##### Try to run only the command `cd`.
 
-###### Can you confirm that the interpreter took you to the users home folder? Use `"pwd"` to confirm.
+###### Can you confirm that the interpreter took you to the users home folder? Use `pwd` to confirm.
 
-##### Try to run the command `"ls"` in a directory at your choice. Do the same in your computer terminal.
+##### Try to run the command `ls` in a directory at your choice. Do the same in your computer terminal.
 
-###### Can you confirm that the output is the same in the project and in your computer terminal?
+###### Can you confirm that the output is similar in the project and in your computer terminal?
 
-##### Try to run the command `"ls -l -a -F"` in a directory at your choice. Do the same in your computer terminal.
+##### Try to run the command `ls -l -a -F` in a directory at your choice. Do the same in your computer terminal.
 
-###### Can you confirm that the output is the same in the project and in your computer terminal?
+###### Can you confirm that the output is similar in the project and in your computer terminal?
 
-##### Try to run the commands `"mkdir new_folder1"` and `"mkdir new_folder2"` in a directory of your choice.
+##### Try to run the commands `mkdir new_folder1` and `mkdir new_folder2` in a directory of your choice.
 
-###### Can you confirm that the directory `new_folder1` and `new_folder2` were created?
+###### Can you confirm that the directories `new_folder1` and `new_folder2` were created?
 
-##### Create a document inside the `new_folder1` called `new_doc.txt` with some random text inside. Try to run the command `"cp new_doc.txt ../folder2"` to copy the document to the folder `new_folder2`.
+##### Create a document inside the `new_folder1` called `new_doc.txt` with some random text inside. Try to run the command `cp new_doc.txt ../folder2` to copy the document to the folder `new_folder2`.
 
 ###### Can you confirm that the document `new_doc.txt` is inside the `new_folder2`?
 
-##### Try to run the command `"cat new_folder1/new_doc"`. Do the same in your computer terminal.
+##### Try to run the command `cat new_folder1/new_doc`. Do the same in your computer terminal.
 
 ###### Can you confirm that the output is the same in the project and in your computer terminal?
 
-##### Try to run the commands `"mv new_folder2 new_folder1"` to move the directory `new_folder2` inside of the directory `new_folder1`.
+##### Try to run the commands `mv new_folder2 new_folder1` to move the directory `new_folder2` inside of the directory `new_folder1`.
 
 ###### Can you confirm that the directory `new_folder2` is inside of the directory `new_folder1`?
 
-##### Try to run the command `"rm -r new_folder1"` to remove what was created above.
+##### Try to run the command `rm -r new_folder1` to remove what was created above.
 
 ###### Can you confirm that the directory `new_folder1` was removed?
 
 #### Bonus
 
-###### + Did the student implemented the commands exclusively using `low-level system calls` avoiding built-in functions or libraries that abstract file operations?
-
-###### +Did the student added auto complete when you are writing the commands?
+###### +Did the student handle `Ctrl + C` gracefully?
 
-###### +Did the student added piping?
+###### +Did the student add auto-completion when writing a command?
 
-###### +Did the student managed the `Ctrl + C`?
+###### +Did the student implement piping?
 
-###### +Did the student added colors to the errors or directories?
+###### +Did the student add colors to the errors or directories?
 
-###### +Did the student added redirection?
+###### +Did the student implement redirection?
 
-###### +Did the student added the current path behind the `$`?
+###### +Did the student display the current directory in the prompt?
 
-###### +Did the student added any other features or commands to the project?
+###### +Did the student add any other features or commands to the project?

subjects/card_deck/README.md

@@ -66,9 +66,9 @@ fn main() {
         suit: Suit::random(),
     };
 
-    println!("Your card is {:?}", your_card);
+    println!("Your card is {:?}", &your_card);
 
-    if card_deck::winner_card(your_card) {
+    if card_deck::winner_card(&your_card) {
         println!("You are the winner!");
     }
 }