From c65fd63fd95eb954546d50855e1df8f63775e0af Mon Sep 17 00:00:00 2001 From: Cametendo Date: Mon, 4 May 2026 08:55:27 +0200 Subject: [PATCH] Inital commit --- .SRCINFO | 15 ++ .gitignore | 39 +++++ CONTRIBUTING.md | 19 +++ LICENSE | 21 +++ PKGBUILD | 34 +++++ README.md | 129 ++++++++++++++++ build.sh | 86 +++++++++++ cflash.sh | 84 +++++++++++ generate_javadoc.sh | 139 ++++++++++++++++++ install.sh | 16 ++ pom.xml | 55 +++++++ src/main/java/org/cametendo/BlockSize.java | 62 ++++++++ src/main/java/org/cametendo/Dd.java | 47 ++++++ src/main/java/org/cametendo/FilePathAdd.java | 108 ++++++++++++++ src/main/java/org/cametendo/Flasher.java | 42 ++++++ src/main/java/org/cametendo/GetHome.java | 1 + src/main/java/org/cametendo/Greeting.java | 27 ++++ src/main/java/org/cametendo/Main.java | 70 +++++++++ src/main/java/org/cametendo/OSDetector.java | 97 ++++++++++++ src/main/java/org/cametendo/OflagHandler.java | 60 ++++++++ .../org/cametendo/StorageDeviceLister.java | 134 +++++++++++++++++ src/main/java/org/cametendo/YesNo.java | 37 +++++ uninstall.sh | 12 ++ 23 files changed, 1334 insertions(+) create mode 100644 .SRCINFO create mode 100644 .gitignore create mode 100644 CONTRIBUTING.md create mode 100644 LICENSE create mode 100644 PKGBUILD create mode 100644 README.md create mode 100755 build.sh create mode 100755 cflash.sh create mode 100755 generate_javadoc.sh create mode 100755 install.sh create mode 100644 pom.xml create mode 100644 src/main/java/org/cametendo/BlockSize.java create mode 100644 src/main/java/org/cametendo/Dd.java create mode 100644 src/main/java/org/cametendo/FilePathAdd.java create mode 100644 src/main/java/org/cametendo/Flasher.java create mode 100644 src/main/java/org/cametendo/GetHome.java create mode 100644 src/main/java/org/cametendo/Greeting.java create mode 100644 src/main/java/org/cametendo/Main.java create mode 100644 src/main/java/org/cametendo/OSDetector.java create mode 100644 src/main/java/org/cametendo/OflagHandler.java create mode 100644 src/main/java/org/cametendo/StorageDeviceLister.java create mode 100644 src/main/java/org/cametendo/YesNo.java create mode 100755 uninstall.sh diff --git a/.SRCINFO b/.SRCINFO new file mode 100644 index 0000000..61a37d0 --- /dev/null +++ b/.SRCINFO @@ -0,0 +1,15 @@ +pkgbase = cflash + pkgdesc = A small and lightweight wrapper for dd that strips away the complexity of CLI flashing. + pkgver = 1.0.1 + pkgrel = 1 + url = https://github.com/cametendo/cflash-git + arch = any + license = MIT + makedepends = java-environment>=21 + makedepends = maven + makedepends = git + depends = java-runtime>=21 + source = cflash::git+https://github.com/cametendo/cflash-git.git + sha256sums = SKIP + +pkgname = cflash diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..85078d2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,39 @@ +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* +replay_pid* + +target/ +*.class +.mtj.tmp/ +*.jar +*.war +*.ear +hs_err_pid* + +# VS Code specific +.classpath +.project +.settings/ +.vscode/ +.claude/ diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..bef221f --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,19 @@ +## Contributing + +Contributions from the community are welcome! To contribute: + +1. Fork the repository. +2. Create a new branch for your feature or bug fix. +3. Make your changes with proper testing. +4. Submit a pull request detailing your modifications. + +### Developer Documentation + +Developer documentation is generated using JavaDoc. To generate and view the documentation: + +```bash +chmod +x generate_javadoc.sh +./generate_javadoc.sh +``` + +This will create a `docs/` folder with HTML documentation you can view in your browser. diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..c0186e5 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Cametendo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 0000000..8aadc5b --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,34 @@ +# Maintainer: Cametendo cameronmathis08@gmail.com +pkgname=cflash +pkgver=1.0.1 +pkgrel=1 +pkgdesc="A small and lightweight wrapper for dd that strips away the complexity of CLI flashing." +arch=('any') +url="https://github.com/cametendo/cflash-git" +license=('MIT') +depends=('java-runtime>=21') +makedepends=('java-environment>=21' 'maven' 'git') +source=("cflash::git+https://github.com/cametendo/cflash-git.git") +sha256sums=('SKIP') + +build() { + cd "$pkgname" + # using 'package' because pom.xml triggers the assembly plugin during this phase + mvn clean package +} + +package() { + cd "$srcdir/cflash" + + install -Dm644 "target/${pkgname}-${pkgver}-jar-with-dependencies.jar" \ + "$pkgdir/usr/share/java/${pkgname}/${pkgname}.jar" + + # Create the executable + install -d "$pkgdir/usr/bin" + cat < "$pkgdir/usr/bin/cflash" +#!/bin/sh +exec /usr/bin/java -jar /usr/share/java/cflash/cflash.jar "\$@" +EOF + # makes the program executable + chmod +x "$pkgdir/usr/bin/cflash" +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..890d00c --- /dev/null +++ b/README.md @@ -0,0 +1,129 @@ +# cflash +A small and lightweight wrapper for `dd` that strips away the complexity of CLI flashing. + +[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT) +[![Java Version](https://img.shields.io/badge/Java-21%2B-orange.svg)](https://www.java.com/en/) +[![Platform](https://img.shields.io/badge/Platform-Linux-brightgreen.svg)](https://www.linux.org/) +[![Version](https://img.shields.io/badge/version-1.0.0-blue)](https://github.com/Cametendo/cflash-git/releases/tag/cflash-1.0.0) + +# About +Small and lightweight wrapper written in Java for `dd` designed to simplify CLI flashing while protecting your hardware from accidental command-line errors. cflash replaces the syntax with a clear, safe interface, providing a reliable workflow for both newcomers and power users. + +# Requirements +- `Java`: 21 (Download [here](https://www.oracle.com/java/technologies/downloads/#java21)) +- `util-linux`: 2.41 +- `coreutils`: 9.10 +- `maven`: 3.9.15 +- Operating System: Linux +### Building and Running Locally + +1. Clone the repository: + + ```bash + git clone https://github.com/cametendo/cflash-git.git + cd cflash-git + ``` + +2. Compile the code: + + ```bash + mvn clean package + ``` + +3. Run cflash: + + ```bash + java -jar target/cflash-.jar (optionally add arguments here, like with dd) + ``` + +4. Update cflash: + + ```bash + git pull + mvn clean package + ``` + +### System-wide Installation + +To install cflash globally so that it can be run from any terminal: + +1. Clone the repository (if not done already): + + ```bash + git clone https://github.com/cametendo/cflash-git.git + cd cflash-git + ``` + +2. Make the build and install scripts executable: + + ```bash + chmod +x build.sh install.sh + ``` + +3. Build the project using the provided build script (requires root privileges): + + ```bash + sudo ./build.sh + ``` + +4. Install globally (requires root privileges): + + ```bash + sudo ./install.sh + ``` + +5. Run cflash from anywhere: + + ```bash + cflash + ``` + +6. Update cflash (reguires root privileges): + + ```bash + sudo cflash --update + ``` + +**Notes:** + +* The `build.sh` script compiles all Java source files and creates an executable `cflash.jar`. +* The `install.sh` script copies `cflash.jar` to `/usr/local/lib/cflash` and installs a wrapper script in `/usr/local/bin` for easy execution. +* If you use Arch Linux: + * You can directly install it with `yay` or `paru` via `yay -S cflash` / `paru -S cflash` or + * You can clone the repository from the [AUR](https://aur.archlinux.org/packages/cflash) and manually build it: + ```bash + git clone https://aur.archlinux.org/cflash.git + cd cflash + makepkg -si + ``` + * You can update cflash using `yay` / `paru` via `yay -S cflash` / `paru -S cflash` or by rebuilding the package: + ```bash + git clone https://aur.archlinux.org/cflash.git + cd cflash + makepkg -si + ``` + +# Usage +- Using the command `cflash` in the terminal, will start the flashing process. You will be asked several question before the flashing begins: + 1. You will see a list of every drive your system see's (excluding system drives) and the be asked to enter the device you want to flash the image onto. (F.e. **/dev/sda**) + 2. You will be prompted to enter the path of the iso / image you want to flash + 3. You will be prompted to choose a byte size (default: 4M) + 4. You will be prompted to enter your oflag (default: direct) + 5. You will be asked if you are absolutely sure that you want to continue (flashing will wipe all data) +- Alternative: using `cflash [device] [iso-path] [block-size] [oflag]` will skip the questions and instantly ask you, if you're absolutely sure you want to continue. +- Once confirmed, the flash will start and a small progress bar will appear showing the flashing progress. +- After completion, the program will detect the OS from the iso and wish you a great time with your new OS. (Example: "Done! Have fun with your new Linux installation!) +- **IMPORTANT**: Since dd needs sudo rights, ensure you have root priviliges. + +# Supported OS +- Linux + +# Installation +1. Clone the repository onto your device and cd into it. +2. Run the `build.sh` file to build the program. +3. Run the `ìnstall.sh`to install the program. +4. Open a terminal and use the program with `cflash`, optionally add all the arguments you need. + +# License and Credits +**Author**: [Cametendo](https://www.github.com/Cametendo) +**License**: MIT diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..cb741ed --- /dev/null +++ b/build.sh @@ -0,0 +1,86 @@ +#!/usr/bin/env bash +# --- Build script for cflash --- +# Compiles sources and bundles jline via Maven into a single fat JAR. +# If Maven is missing, prompts the user to install it using the detected package manager. + +set -e + +JAR_FILE="cflash.jar" + +# --- Detect package manager --- +detect_package_manager() { + if command -v pacman >/dev/null 2>&1; then + echo "pacman" + elif command -v apt >/dev/null 2>&1; then + echo "apt" + elif command -v dnf >/dev/null 2>&1; then + echo "dnf" + elif command -v yum >/dev/null 2>&1; then + echo "yum" + elif command -v zypper >/dev/null 2>&1; then + echo "zypper" + elif command -v brew >/dev/null 2>&1; then + echo "brew" + elif command -v apk >/dev/null 2>&1; then + echo "apk" + elif command -v emerge >/dev/null 2>&1; then + echo "emerge" + else + echo "" + fi +} + +# --- Generate Maven install command --- +maven_install_command() { + local pm="$1" + case "$pm" in + pacman) echo "pacman -Sy --noconfirm maven" ;; + apt) echo "apt update && apt install -y maven" ;; + dnf) echo "dnf install -y maven" ;; + yum) echo "yum install -y maven" ;; + zypper) echo "zypper install -y maven" ;; + brew) echo "brew install maven" ;; + apk) echo "apk add maven" ;; + emerge) echo "emerge dev-java/maven-bin" ;; + *) echo "" ;; + esac +} + +# --- Check for mvn --- +if ! command -v mvn >/dev/null 2>&1; then + echo "Maven (mvn) not found." + PM=$(detect_package_manager) + + if [[ -z "$PM" ]]; then + echo "Please install Maven manually and rerun this script." + exit 1 + fi + + CMD=$(maven_install_command "$PM") + if [[ $EUID -ne 0 && "$PM" != "brew" ]]; then + echo "Please run this script as root to install Maven, or install it manually." + exit 1 + fi + + read -rp "Do you want to run the following command to install Maven? [$CMD] (y/n): " ANSWER + case "$ANSWER" in + y|Y) + echo "Installing Maven..." + eval "$CMD" + echo "Maven installed successfully." + ;; + *) + echo "Maven installation cancelled. Please install manually and rerun." + exit 1 + ;; + esac +fi + +# --- Build process --- +echo "Building cflash with Maven..." +mvn package -q + +echo "Copying fat JAR to ${JAR_FILE}..." +cp target/cflash-*-jar-with-dependencies.jar "$JAR_FILE" + +echo "Build completed successfully: ${JAR_FILE}" diff --git a/cflash.sh b/cflash.sh new file mode 100755 index 0000000..8f00d19 --- /dev/null +++ b/cflash.sh @@ -0,0 +1,84 @@ +#!/usr/bin/env bash +# cflash launcher with self-update via git + rebuild (requires sudo for update) + +CFLASH_DIR="/usr/local/lib/cflash" +CFLASH_JAR="$CFLASH_DIR/cflash.jar" +GIT_REPO="https://gitea.cametendo.org/cametendo/cflash.git" + +update_cflash() { + # Check for sudo/root + if [[ $EUID -ne 0 ]]; then + echo "cflash --update requires root privileges. Please run with sudo." + exit 1 + fi + + echo "Updating cflash from repository..." + + TMP_DIR=$(mktemp -d) + echo "Cloning repository into $TMP_DIR..." + + if ! git clone --depth 1 "$GIT_REPO" "$TMP_DIR"; then + echo "Failed to clone repository." + rm -rf "$TMP_DIR" + exit 1 + fi + + pushd "$TMP_DIR" >/dev/null + + # Logic to handle if the repo contents are nested inside a 'cflash' folder + if [[ ! -f "./build.sh" && -d "cflash" ]]; then + echo "Detected nested directory, moving into cflash/..." + cd cflash + fi + + # Ensure build.sh is executable (git usually preserves this, but just in case) + if [[ -f "./build.sh" ]]; then + chmod +x ./build.sh + echo "Building cflash..." + if ! ./build.sh; then + echo "Build failed." + popd >/dev/null + rm -rf "$TMP_DIR" + exit 1 + fi + else + echo "Error: build.sh not found in the repository root or cflash/ directory." + popd >/dev/null + rm -rf "$TMP_DIR" + exit 1 + fi + + echo "Installing new version..." + if [[ -f "./install.sh" ]]; then + chmod +x ./install.sh + if ! ./install.sh; then + echo "Install failed." + popd >/dev/null + rm -rf "$TMP_DIR" + exit 1 + fi + else + echo "Error: install.sh not found." + popd >/dev/null + rm -rf "$TMP_DIR" + exit 1 + fi + + popd >/dev/null + rm -rf "$TMP_DIR" + echo "Update completed successfully!" + exit 0 +} + +# Handle --update argument +if [[ "$1" == "--update" ]]; then + update_cflash +fi + +# Run cflash normally +if [[ -f "$CFLASH_JAR" ]]; then + java --enable-native-access=ALL-UNNAMED -jar "$CFLASH_JAR" "$@" +else + echo "Error: $CFLASH_JAR not found. Please run 'sudo cflash --update' to install." + exit 1 +fi \ No newline at end of file diff --git a/generate_javadoc.sh b/generate_javadoc.sh new file mode 100755 index 0000000..955e55d --- /dev/null +++ b/generate_javadoc.sh @@ -0,0 +1,139 @@ +#!/usr/bin/env bash +# --- Generate JavaDoc for cflash --- +# This script generates developer documentation using javadoc. +# If JDK is missing, it prompts the user to install it using the detected package manager. + +set -e + +SRC_DIR="src/main/java" +DOC_DIR="docs" + +# --- Detect package manager --- +detect_package_manager() { + if command -v pacman >/dev/null 2>&1; then + echo "pacman" + elif command -v apt >/dev/null 2>&1; then + echo "apt" + elif command -v dnf >/dev/null 2>&1; then + echo "dnf" + elif command -v yum >/dev/null 2>&1; then + echo "yum" + elif command -v zypper >/dev/null 2>&1; then + echo "zypper" + elif command -v brew >/dev/null 2>&1; then + echo "brew" + elif command -v apk >/dev/null 2>&1; then + echo "apk" + elif command -v emerge >/dev/null 2>&1; then + echo "emerge" + else + echo "" + fi +} + +# --- Generate JDK install command --- +jdk_install_command() { + local pm="$1" + case "$pm" in + pacman) echo "pacman -Sy --noconfirm jdk-openjdk" ;; + apt) echo "apt update && apt install -y openjdk-21-jdk || apt install -y default-jdk" ;; + dnf) echo "dnf install -y java-21-openjdk-devel || dnf install -y java-latest-openjdk-devel" ;; + yum) echo "yum install -y java-21-openjdk-devel || yum install -y java-latest-openjdk-devel" ;; + zypper) echo "zypper install -y java-21-openjdk-devel || zypper install -y java-latest-openjdk-devel" ;; + brew) echo "brew install openjdk" ;; + apk) echo "apk add openjdk21" ;; + emerge) echo "emerge dev-java/openjdk-bin" ;; + *) echo "" ;; + esac +} + +# --- Check for javadoc --- +if ! command -v javadoc >/dev/null 2>&1; then + echo "Java Development Kit (JDK) with javadoc not found." + PM=$(detect_package_manager) + + if [[ -z "$PM" ]]; then + echo "Please install the latest JDK manually and rerun this script." + exit 1 + fi + + CMD=$(jdk_install_command "$PM") + if [[ $EUID -ne 0 && "$PM" != "brew" ]]; then + echo "Please rerun this script with sudo if you want automatic JDK installation." + exit 1 + fi + + # Prompt user + read -rp "Do you want to run the following command to install the JDK? [$CMD] (y/n): " ANSWER + case "$ANSWER" in + y|Y) + echo "Installing JDK..." + eval "$CMD" + echo "JDK installed successfully." + ;; + *) + echo "JDK installation cancelled. Please install manually and rerun." + exit 1 + ;; + esac +fi + +# --- Check if source directory exists --- +if [[ ! -d "$SRC_DIR" ]]; then + echo -e "\033[31mSource directory '$SRC_DIR' not found!" + echo "Please ensure you're running this script from the project root directory." + exit 1 +fi + +# --- Generate JavaDoc --- +echo "Generating JavaDoc for cflash..." +rm -rf "$DOC_DIR" +mkdir -p "$DOC_DIR" + +# Check if Maven is available +if command -v mvn >/dev/null 2>&1; then + echo "Using Maven to generate JavaDoc with dependencies..." + if mvn javadoc:javadoc -Dquiet=true > /dev/null 2>&1; then + # Copy generated docs from Maven location to our docs directory + if [[ -d "target/reports/apidocs" ]]; then + cp -r target/reports/apidocs/* "$DOC_DIR/" + echo -e "\033[32mJavaDoc generated successfully using Maven!" + echo -e "\033[0m→ Open file://$PWD/$DOC_DIR/index.html to view it." + else + echo -e "\033[31mMaven generated docs but couldn't find them in target/reports/apidocs" + exit 1 + fi + else + echo -e "\033[31mMaven JavaDoc generation failed." + exit 1 + fi +else + echo "Maven not found. Attempting to generate JavaDoc without dependencies..." + # Try to download JLine dependency manually + JLINE_JAR="$HOME/.m2/repository/org/jline/jline/3.25.1/jline-3.25.1.jar" + if [[ -f "$JLINE_JAR" ]]; then + echo "Found JLine dependency in Maven local repository..." + CLASSPATH="$SRC_DIR:$JLINE_JAR" + else + echo "JLine dependency not found. JavaDoc may have missing links." + CLASSPATH="$SRC_DIR" + fi + + if javadoc -quiet -d "$DOC_DIR" \ + -sourcepath "$SRC_DIR" \ + -classpath "$CLASSPATH" \ + -subpackages org.cametendo \ + -private \ + -author \ + -version \ + -doctitle "cflash - Disk Image Flashing Utility" \ + -windowtitle "cflash Documentation" \ + -bottom "Copyright © 2026 Cametendo. All rights reserved." > /dev/null 2>&1; then + echo -e "\033[32mJavaDoc generated successfully!" + echo -e "\033[0m→ Open file://$PWD/$DOC_DIR/index.html to view it." + else + echo -e "\033[31mJavaDoc generation failed. Install Maven for better dependency handling." + echo "Run: apt install maven (Ubuntu/Debian) or pacman -S maven (Arch)" + exit 1 + fi +fi diff --git a/install.sh b/install.sh new file mode 100755 index 0000000..9282cd6 --- /dev/null +++ b/install.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash +# Install script for system-wide usage + +# Ensure running as root +if [[ $EUID -ne 0 ]]; then + echo "Please run as root to install globally." + exit 1 +fi + +# Create installation directories +mkdir -p /usr/local/lib/cflash +cp cflash.jar /usr/local/lib/cflash/ +cp cflash.sh /usr/local/bin/cflash +chmod +x /usr/local/bin/cflash + +echo "cflash installed successfully! You can now run 'cflash' from anywhere." diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..b62efe4 --- /dev/null +++ b/pom.xml @@ -0,0 +1,55 @@ + + + 4.0.0 + + org.cametendo + cflash + 1.0.1 + + + 21 + 21 + UTF-8 + + + + + org.jline + jline + 3.25.1 + + + + + + + maven-assembly-plugin + 3.6.0 + + + + org.cametendo.Main + + + ALL-UNNAMED + + + + jar-with-dependencies + + + + + make-assembly + package + + single + + + + + + + \ No newline at end of file diff --git a/src/main/java/org/cametendo/BlockSize.java b/src/main/java/org/cametendo/BlockSize.java new file mode 100644 index 0000000..1dca793 --- /dev/null +++ b/src/main/java/org/cametendo/BlockSize.java @@ -0,0 +1,62 @@ +package org.cametendo; +import java.util.Scanner; + +/** + * Utility class for managing block size configuration for disk flashing operations. + * + *

This class provides methods to both interactively prompt users for block size selection + * and to map command-line inputs to valid block size values. The default block size is 4M.

+ * + * @author Cametendo + * @version 1.0 + */ +public class BlockSize { + + /** + * Default block size string value. + * Set to "4M" as the default block size for flashing operations. + */ + public static String blockSizeString = "4M"; + + /** + * Maps user input to a valid block size value. + * + *

Supports both numeric inputs (1-6) and string inputs (512K,1M,2M,4M,8M,16M). + * If the input is not recognized, returns the default block size.

+ * + * @param input User input string, either numeric (1-6) or block size string + * @return Valid block size string (512K, 1M, 2M, 4M, 8M, 16M, or default) + */ + public static String mapBlockSize(String input) { + return switch (input) { + case "1", "512K" -> "512K"; + case "2", "1M" -> "1M"; + case "3", "2M" -> "2M"; + case "4", "4M" -> "4M"; + case "5", "8M" -> "8M"; + case "6", "16M" -> "16M"; + default -> blockSizeString; + }; + } + + /** + * Interactively prompts the user to select a block size. + * + *

Displays a menu of available block sizes and maps the user's input + * to a valid block size value using {@link #mapBlockSize(String)}.

+ * + * @param UserInput Scanner object for reading user input + * @return The selected block size string + */ + static String blockSize(Scanner UserInput) { + System.out.println("Choose a block size (Default: 4M)"); + System.out.println("512KB (1), 1M (2), 2M (3), 4M (4), 8M (5), 16M (6)"); + + String input = UserInput.nextLine(); + + blockSizeString = mapBlockSize(input); + + System.out.println("Using blocksize of: " + blockSizeString); + return blockSizeString; + } +} \ No newline at end of file diff --git a/src/main/java/org/cametendo/Dd.java b/src/main/java/org/cametendo/Dd.java new file mode 100644 index 0000000..a631b93 --- /dev/null +++ b/src/main/java/org/cametendo/Dd.java @@ -0,0 +1,47 @@ +package org.cametendo; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/** + * Executes the dd command for disk flashing operations. + * + *

This class handles the actual execution of the dd command with the configured + * parameters (input file, output device, block size, and output flags). It provides + * real-time output streaming and calls the OSDetector for completion messages.

+ * + * @author Cametendo + * @version 1.0 + */ +public class Dd { + + /** + * Executes the dd command with the configured parameters. + * + *

Runs the dd command using sudo with the specified image file, target device, + * block size, and output flags. Streams the command output in real-time to show + * progress. Upon completion, calls {@link OSDetector#wishWell(String)} to display + * a completion message based on the image file name.

+ */ + public static void dd() { + try { + ProcessBuilder pb = new ProcessBuilder("sudo", "dd", "if=" + FilePathAdd.ImagePath, "of=" + StorageDeviceLister.fullPath, "bs=" + BlockSize.blockSizeString, "status=progress", "oflag=" + OflagHandler.oflagHandleString); + pb.redirectErrorStream(true); + Process process = pb.start(); + + BufferedReader reader = new BufferedReader( + new InputStreamReader(process.getInputStream()) + ); + + int character; + while ((character = reader.read()) != -1) { + char c = (char) character; + System.out.print(c); + System.out.flush(); + } + OSDetector.wishWell(FilePathAdd.ImagePath); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/org/cametendo/FilePathAdd.java b/src/main/java/org/cametendo/FilePathAdd.java new file mode 100644 index 0000000..ad7a5b8 --- /dev/null +++ b/src/main/java/org/cametendo/FilePathAdd.java @@ -0,0 +1,108 @@ +package org.cametendo; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; + +import org.jline.reader.LineReader; +import org.jline.reader.LineReaderBuilder; +import org.jline.reader.impl.completer.FileNameCompleter; +import org.jline.terminal.Terminal; +import org.jline.terminal.TerminalBuilder; + +/** + * Handles file path input and validation for disk image files. + * *

This class provides functionality to interactively prompt users for image file paths + * with tab completion support via JLine. It handles Unix-style tilde (~) expansion + * to the user's home directory and validates that paths point to existing regular files.

+ * * @author Cametendo + * @version 1.1 + */ +public class FilePathAdd { + + /** + * Stores the validated absolute path to the selected image file. + */ + public static String ImagePath = ""; + + /** + * Constant representing the current user's home directory path. + */ + public static final String Home = System.getProperty("user.home"); + + /** + * Interactively prompts the user to select an image file path. + * *

Uses JLine for enhanced terminal interaction with {@link FileNameCompleter}. + * The method expands the tilde (~) character if present at the start of the string + * and validates that the resulting path is a regular file before returning.

+ * * @return The validated absolute path to the selected image file + * @throws IOException If there are I/O errors during terminal setup or file resolution + */ + protected static String filePath() throws IOException { + fileQuestion(); + + Terminal terminal = TerminalBuilder.terminal(); + LineReader reader = LineReaderBuilder.builder().terminal(terminal).completer(new FileNameCompleter()).build(); + + while (true) { + String input = reader.readLine("Path: ").trim(); + + if (input.isBlank()) { + System.out.println("Oops... You didn't specify a file!"); + continue; + } + + // Expand tilde to the full home directory path + if (input.startsWith("~")) { + input = Home + input.substring(1); + } + + Path path = Path.of(input); + + if (!Files.exists(path) || !Files.isRegularFile(path)) { + System.out.println("Invalid file! Please ensure the path points to an ISO / image file."); + continue; + } + + // Convert to a real, absolute path and return + ImagePath = path.toRealPath().toString(); + System.out.println("Using File: " + ImagePath); + return ImagePath; + } + } + + /** + * Validates and returns the full path to an image file from a provided string. + * *

This is primarily used for validating command-line arguments. It supports + * tilde expansion and verifies file existence and type.

+ * * @param inputPath Raw path string to validate + * @return Full validated absolute path, or {@code null} if the path is invalid or inaccessible + */ + public static String validateAndGetFile(String inputPath) { + if (inputPath == null) return null; + + try { + if (inputPath.startsWith("~")) { + inputPath = Home + inputPath.substring(1); + } + + Path path = Path.of(inputPath); + if (Files.exists(path) && Files.isRegularFile(path)) { + return path.toRealPath().toString(); + } else { + System.out.println("Invalid file! Please ensure the path points to an ISO / image file."); + return null; + } + } catch (IOException e) { + System.out.println("File not found! Invalid Path or no access."); + return null; + } + } + + /** + * Displays the prompt for file path input to the standard output. + */ + protected static void fileQuestion() { + System.out.println("Please enter the FULL Path of your ISO / Image. (Tab-completion supported)"); + } +} \ No newline at end of file diff --git a/src/main/java/org/cametendo/Flasher.java b/src/main/java/org/cametendo/Flasher.java new file mode 100644 index 0000000..f6027ce --- /dev/null +++ b/src/main/java/org/cametendo/Flasher.java @@ -0,0 +1,42 @@ +package org.cametendo; +import java.util.Scanner; + +/** + * Handles the final confirmation and execution of the disk flashing process. + * + *

This class displays the current configuration to the user for confirmation + * before proceeding with the actual flashing operation using the dd command.

+ * + * @author Cametendo + * @version 1.0 + */ +public class Flasher { + + /** + * Displays the current flashing configuration and prompts for user confirmation. + * + *

Shows the device path, image file path, block size, and output flag that will be used + * for the flashing operation. If the user confirms, proceeds with the flashing process + * by calling {@link Dd#dd()}. If the user cancels, exits the application.

+ * + * @param UserInput Scanner object for reading user confirmation + */ + public static void flasher(Scanner UserInput) { + + String input = ""; + + System.out.println("The program will use the following configuration, do you want to flash with this? (Y/n)"); + System.out.println(" - To be flashed device: " + StorageDeviceLister.fullPath); + System.out.println(" - To be used path: " + FilePathAdd.ImagePath); + System.out.println(" - To be used blocksize: " + BlockSize.blockSizeString); + System.out.println(" - To be used oflag: " + OflagHandler.oflagHandleString); + input = UserInput.nextLine(); + if (YesNo.check(input)) { + System.out.println("Starting to flash..."); + } else { + System.out.println("Canceling..."); + System.exit(0); + } + Dd.dd(); + } +} \ No newline at end of file diff --git a/src/main/java/org/cametendo/GetHome.java b/src/main/java/org/cametendo/GetHome.java new file mode 100644 index 0000000..09c0ba9 --- /dev/null +++ b/src/main/java/org/cametendo/GetHome.java @@ -0,0 +1 @@ + diff --git a/src/main/java/org/cametendo/Greeting.java b/src/main/java/org/cametendo/Greeting.java new file mode 100644 index 0000000..24f17d8 --- /dev/null +++ b/src/main/java/org/cametendo/Greeting.java @@ -0,0 +1,27 @@ +package org.cametendo; + +import java.util.Scanner; + +/** + * Handles the initial greeting and user confirmation for the cflash application. + * + *

This class provides a welcome message and prompts the user to confirm + * whether they want to proceed with flashing an image to a storage device.

+ * + * @author Cametendo + * @version 1.0 + */ +public class Greeting { + + /** + * Displays a welcome message and prompts for user confirmation. + * + *

Shows the cflash welcome message and asks the user if they want to + * flash an image. If the user declines, exits the application.

+ * + * @param UserInput Scanner object for reading user confirmation + */ + public static void greeting(Scanner UserInput) { + System.out.println("Welcome to cflash!"); + } +} diff --git a/src/main/java/org/cametendo/Main.java b/src/main/java/org/cametendo/Main.java new file mode 100644 index 0000000..b9c27eb --- /dev/null +++ b/src/main/java/org/cametendo/Main.java @@ -0,0 +1,70 @@ +package org.cametendo; +import java.io.IOException; +import java.util.Scanner; + +/** + * Main entry point for the cflash application. + * + *

cflash is a command-line utility for flashing disk images to storage devices. + * It supports both interactive mode and command-line argument mode for automation.

+ * + *

In interactive mode, the user is guided through device selection, file path input, + * block size configuration, and output flag selection. In command-line mode, all parameters + * can be specified as arguments for automated flashing.

+ * + * @author Cametendo + * @version 1.0 + */ +public class Main { + + /** + * Main method that serves as the entry point for the cflash application. + * + *

The application can operate in two modes:

+ *
    + *
  • Interactive mode: No arguments provided, user is guided through the process
    • + *
  • Command-line mode: Four arguments provided for automated execution
    • + *
+ * + *

Command-line arguments format:

+ *
    + *
  1. Device name (e.g., "sda" without /dev/ prefix)
    2. + *
  2. Image file path (absolute or relative path to ISO/image file)
    3. + *
  3. Block size (1-6 or 512K,1M,2M,4M,8M,16M)
    4. + *
  4. Output flag (1-4 or direct,dsync,sync,nocache)
    5. + *
+ * + * @param args Command-line arguments. If 4 arguments are provided, runs in automated mode. + * If no arguments, runs in interactive mode. + * @throws InterruptedException If the flashing process is interrupted + * @throws IOException If there are I/O errors during device/file validation + */ + public static void main(String[] args) throws InterruptedException, IOException { + Scanner UserInput = new Scanner(System.in); + if (args.length == 4) { + String validatedDevice = StorageDeviceLister.validateAndGetPath(args[0]); + if (validatedDevice == null) { + return; + } + + String validatedFile = FilePathAdd.validateAndGetFile(args[1]); + if (validatedFile == null) { + return; + } + + StorageDeviceLister.fullPath = validatedDevice; + FilePathAdd.ImagePath = validatedFile; + BlockSize.blockSizeString = BlockSize.mapBlockSize(args[2]); + OflagHandler.oflagHandleString = OflagHandler.mapOflagHandle(args[3]); + + } else { + Greeting.greeting(UserInput); + + StorageDeviceLister.deviceCheck(UserInput); + FilePathAdd.filePath(); + BlockSize.blockSize(UserInput); + OflagHandler.Oflag(UserInput); + } + Flasher.flasher(UserInput); + } +} diff --git a/src/main/java/org/cametendo/OSDetector.java b/src/main/java/org/cametendo/OSDetector.java new file mode 100644 index 0000000..9e9a845 --- /dev/null +++ b/src/main/java/org/cametendo/OSDetector.java @@ -0,0 +1,97 @@ +package org.cametendo; +import java.nio.file.Path; + +/** + * Detects operating system types from image file names and displays completion messages. + * + *

This class analyzes the filename of disk images to identify the operating system + * and displays a personalized completion message with some fun descriptions for various + * Linux distributions, BSD variants, and other operating systems.

+ * + * @author Cametendo + * @version 1.0 + */ +public class OSDetector { + + /** + * Analyzes an image file path and displays a personalized completion message. + * + *

Extracts the filename from the provided path and attempts to identify the + * operating system based on filename patterns. Displays a fun, personalized message + * wishing the user well with their new OS installation.

+ * + * @param imagePath Path to the image file that was flashed + */ + public static void wishWell(String imagePath) { + String fileName = Path.of(imagePath).getFileName().toString().toLowerCase(); + + String osName; + + // Specialized & Advanced Distros + if (fileName.contains("nyarch")) { + osName = "Nyarch Linux (Nyaa~!)"; + } else if (fileName.contains("artix")) { + osName = "Artix Linux (Systemd-free Arch!)"; + } else if (fileName.contains("gentoo")) { + osName = "Gentoo (Enjoy the compiling...)"; + } else if (fileName.contains("nixos")) { + osName = "NixOS (Immutable & Reproducible!)"; + } else if (fileName.contains("void")) { + osName = "Void Linux"; + } else if (fileName.contains("arch")) { + osName = "Arch Linux (btw)"; + } else if (fileName.contains("alpine")) { + osName = "Alpine Linux (Minimalism at its peak)"; + } else if (fileName.contains("winux")) { + osName = "Winux (Windows without Windows)"; + } + // Mainstream Linux + else if (fileName.contains("fedora")) { + osName = "Fedora (Freehat Linux)"; + } else if (fileName.contains("debian")) { + osName = "Debian (Universal OS)"; + } else if (fileName.contains("ubuntu")) { + osName = "Ubuntu (Debian but fancy)"; + } else if (fileName.contains("mint")) { + osName = "Linux Mint"; + } else if (fileName.contains("pop-os") || fileName.contains("pop_os")) { + osName = "Pop!_OS"; + } + // The BSD Family + else if (fileName.contains("freebsd")) { + osName = "FreeBSD"; + } else if (fileName.contains("openbsd")) { + osName = "OpenBSD (Secure by default)"; + } else if (fileName.contains("netbsd")) { + osName = "NetBSD (It runs on everything!)"; + } + // Security & Privacy + else if (fileName.contains("kali")) { + osName = "Kali Linux (Happy Hacking)"; + } else if (fileName.contains("tails")) { + osName = "Tails (Incognito mode: ON)"; + } else if (fileName.contains("qubes")) { + osName = "Qubes OS (Security by Compartmentalization)"; + } + // Others & Legacy + else if (fileName.contains("win") && (fileName.contains("10") || fileName.contains("11"))) { + osName = "Windows (Spies... Spies everywhere)"; + } else if (fileName.contains("haiku")) { + osName = "Haiku OS"; + } else if (fileName.contains("reactos")) { + osName = "ReactOS"; + } else if (fileName.contains("jgh")) { + osName = "JGH OS (Sauerkraut juice)"; + } + // Generic Fallbacks + else if (fileName.contains("linux")) { + osName = "Linux"; + } else if (fileName.contains("bsd")) { + osName = "BSD"; + } else { + osName = "new OS"; + } + + System.out.println("\nFlash complete! Have fun with your " + osName + " installation!"); + } +} \ No newline at end of file diff --git a/src/main/java/org/cametendo/OflagHandler.java b/src/main/java/org/cametendo/OflagHandler.java new file mode 100644 index 0000000..39e6457 --- /dev/null +++ b/src/main/java/org/cametendo/OflagHandler.java @@ -0,0 +1,60 @@ +package org.cametendo; +import java.util.Scanner; + +/** + * Handles output flag (oflag) configuration for the dd command. + * + *

This class provides functionality to both interactively prompt users for output flag selection + * and to map command-line inputs to valid oflag values. The default output flag is "direct".

+ * + * @author Cametendo + * @version 1.0 + */ +public class OflagHandler { + + /** + * Default output flag string value. + * Set to "direct" as the default output flag for dd operations. + */ + public static String oflagHandleString = "direct"; + + /** + * Maps user input to a valid output flag value. + * + *

Supports both numeric inputs (1-4) and string inputs (direct,dsync,sync,nocache). + * If the input is not recognized, returns the default output flag.

+ * + * @param input User input string, either numeric (1-4) or output flag string + * @return Valid output flag string (direct, dsync, sync, nocache, or default) + */ + public static String mapOflagHandle(String input) { + return switch (input) { + case "1", "direct" -> "direct"; + case "2", "dsync" -> "dsync"; + case "3", "sync" -> "sync"; + case "4", "nocache" -> "nocache"; + default -> oflagHandleString; + }; + } + + /** + * Interactively prompts the user to select an output flag. + * + *

Displays a menu of available output flags and maps the user's input + * to a valid output flag value using {@link #mapOflagHandle(String)}.

+ * + * @param UserInput Scanner object for reading user input + * @return The selected output flag string + */ + static String Oflag(Scanner UserInput) { + System.out.println("Choose an Oflag (Default: direct)"); + System.out.println("direct (1), dsync (2), sync (3), nocache (4)"); + + String input = UserInput.nextLine(); + + oflagHandleString = mapOflagHandle(input); + + System.out.println("Using Oflag: " + oflagHandleString); + return oflagHandleString; + } +} diff --git a/src/main/java/org/cametendo/StorageDeviceLister.java b/src/main/java/org/cametendo/StorageDeviceLister.java new file mode 100644 index 0000000..b3b94d7 --- /dev/null +++ b/src/main/java/org/cametendo/StorageDeviceLister.java @@ -0,0 +1,134 @@ +package org.cametendo; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.file.Path; +import java.util.Scanner; + +/** + * Handles storage device detection, listing, and validation for the flashing process. + * *

Includes safety checks to ensure we don't nuke a partition that's currently in use. + * Keeps the user in the loop with a more personal touch.

+ * * @author Cametendo + * @version 1.1 + */ +public class StorageDeviceLister { + + public static String device = ""; + public static String fullPath = ""; + + /** + * Guides the user through selecting a safe, unmounted storage device. + */ + protected static String deviceCheck(Scanner UserInput) { + deviceList(); + + while (true) { + System.out.print("Target device: "); + device = UserInput.nextLine().trim(); + + if (device.isBlank()) { + System.out.println("Oops... Device name is empty. Did you missclick?"); + continue; + } + + // Standardize path - allows entering 'sda' or '/dev/sda' + String checkPath = device.startsWith("/dev/") ? device : "/dev/" + device; + Path path = Path.of(checkPath); + + try { + fullPath = path.toRealPath().toString(); + + // Check if the user is about to break their system + if (isMounted(fullPath)) { + System.out.println("Wait a second! " + fullPath + " is currently mounted."); + System.out.println("I can't flash to a device that's in use. Unmount it and try again!"); + continue; + } + + System.out.println("Solid choice. Using device: " + fullPath); + return fullPath; + + } catch (IOException e) { + System.out.println("Hmm... I can't seem to find or access that device. Are you sure you have access to it?"); + } + } + } + + /** + * Asks lsblk if the device or its children have an active mount point. + */ + private static boolean isMounted(String devicePath) { + try { + ProcessBuilder pb = new ProcessBuilder("lsblk", "-no", "MOUNTPOINT", devicePath); + Process process = pb.start(); + + try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) { + String line; + while ((line = reader.readLine()) != null) { + if (!line.trim().isEmpty()) { + return true; + } + } + } + process.waitFor(); + } catch (IOException | InterruptedException e) { + System.out.println("Warning: Mountstatus couldn't be verified"); + return true; + } + return false; + } + + /** + * Lists devices with enough info for the user to make a smart decision. + */ + private static void deviceList() { + try { + System.out.println("Scanning for block devices..."); + ProcessBuilder pb = new ProcessBuilder("lsblk", "-o", "NAME,SIZE,TYPE,RM,MOUNTPOINT"); + Process process = pb.start(); + + BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); + String line; + while ((line = reader.readLine()) != null) { + System.out.println(line); + } + process.waitFor(); + + System.out.println("Enter the name of your device (e.g., sdb or nvme1n1):"); + + } catch (IOException | InterruptedException e) { + System.out.println("Failed to run lsblk. Do you have it installed."); + } + } + + /** + * Validates a device path (e.g., from a CLI argument). + * *

Checks if the device exists, resolves the real path, and ensures + * it isn't currently mounted before giving the green light.

+ * * @param deviceName Device name (e.g., "sda" or "/dev/sda") + * @return Full validated path, or null if it's a bad idea to use it + */ + public static String validateAndGetPath(String deviceName) { + if (deviceName == null || deviceName.isBlank()) return null; + + try { + // Support both "sda" and "/dev/sda" + String checkPath = deviceName.startsWith("/dev/") ? deviceName : "/dev/" + deviceName; + Path path = Path.of(checkPath); + String resolvedPath = path.toRealPath().toString(); + + // Safety check for CLI arguments too! + if (isMounted(resolvedPath)) { + System.out.println("Hold up! " + resolvedPath + " is mounted. I won't let you flash it like that."); + return null; + } + + return resolvedPath; + } catch (IOException e) { + System.out.println("Hmm... I couldn't find a device at '" + deviceName + "'. Is it plugged in?"); + return null; + } + } +} \ No newline at end of file diff --git a/src/main/java/org/cametendo/YesNo.java b/src/main/java/org/cametendo/YesNo.java new file mode 100644 index 0000000..31de3ab --- /dev/null +++ b/src/main/java/org/cametendo/YesNo.java @@ -0,0 +1,37 @@ +package org.cametendo; + +/** + * Utility class for parsing yes/no user responses. + * + *

This class provides a simple method to interpret user input as a boolean + * value, accepting various forms of "yes" and treating everything else as "no".

+ * + * @author Cametendo + * @version 1.0 + */ +public class YesNo { + + /** + * Parses user input to determine if it represents a "yes" response. + * + *

Accepts "Y", "y", and empty string (default) as yes responses. + * All other inputs are treated as no responses.

+ * + * @param input User input string to parse + * @return true if the input represents a yes response, false otherwise + */ + public static boolean check(String input) { + switch (input) { + case "Y": + return true; + case "y": + return true; + case "": + return true; + case "n": + return false; + default: + return false; + } + } +} diff --git a/uninstall.sh b/uninstall.sh new file mode 100755 index 0000000..dbc13fc --- /dev/null +++ b/uninstall.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +# Uninstall script for cflash + +if [[ $EUID -ne 0 ]]; then + echo "Please run as root to uninstall globally." + exit 1 +fi + +rm -f /usr/local/bin/cflash +rm -rf /usr/local/lib/cflash + +echo "cflash uninstalled successfully."