.vscode/settings.json

@@ -63,7 +63,6 @@
         "typeinfo": "cpp",
         "variant": "cpp",
         "format": "cpp",
-        "__nullptr": "cpp",
+        "__nullptr": "cpp"
-        "codecvt": "cpp"
     }
 }

README.md

@@ -2,18 +2,10 @@
 
 # Installation
 
-Automated system-wide installation:
 ```
-curl -fsSL https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh | bash
+curl -fsSL -o bb64_install.sh https://gitea.jde.nz/public/bb64/raw/branch/main/install.sh && sudo bash ./bb64_install.sh && rm bb64_install.sh
 ```
 
-## To download just the bb64 executable:
-
-```
-curl -fsSL -o bb64 https://gitea.jde.nz/public/bb64/releases/download/latest/bb64.amd64 && chmod a+x bb64
-```
-
-
 # Use
 
 Bash Base64, written in C++.
@@ -21,11 +13,12 @@ Bash Base64, written in C++.
 Uses a custom Base64 character set for bash compatibility, not compatible with other utilities.
 
 ```
-Usage:
+Useage:
-    bb64 BASE64COMMAND          Decodes and runs the command
+    bb64 BASE64COMMAND      Decodes the base64 encoded command, and runs it
-    bb64 -[i|d] BASE64COMMAND   Displays the decoded command
+    bb64 -i BASE64COMMAND   Decodes the base64 encoded command, and prints to the screen
-    bb64 -e COMMAND             Encodes the command and prints the result
+                            If it contains a bb64 command within the decoded command, it 
-    bb64 -u                     Updates bb64 to the latest version (uses docker)
+                            also decodes that and prints it to the screen.
+    bb64 -e COMMAND(S)      encodes the commands in base64.
 ```
 
 # Implementation Notes
@@ -34,9 +27,11 @@ bb64 runs the command by replacing the current process, so it ensures that tty,
 variables etc are all identical for the run command. It works with interactive commands, like
 nano or ssh.
 
-bb64 supports bash scripts, as the command is run as:
+The command is run as:
-    `bash -c 'COMMAND'`
+    `bash -c COMMAND`
 Where COMMAND is passed to bash as a single argument.
 
 If the command is run, the return value is the return value of the command.
 If it isn't run, bb64 returns -1.
+
+`./build.sh` will build bb64 for x86_64 (amd64) and arm64 architectures.

bb64.cpp

@@ -36,41 +36,6 @@ constexpr unsigned int hash(const char *s, int off = 0)
     return !s[off] ? 5381 : (hash(s, off + 1) * 33) ^ s[off];
 }
 
-std::string tidy(const std::string &str)
-{
-    std::string result;
-    bool in_whitespace = false;
-    for (char c : str)
-    {
-        // Remove non-printable characters except for whitespace (space, tab, newline, carriage return)
-        if ((static_cast<unsigned char>(c) < 32 && c != ' ' && c != '\t' && c != '\n' && c != '\r') || static_cast<unsigned char>(c) == 127)
-        {
-            continue;
-        }
-        if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
-        {
-            if (!in_whitespace)
-            {
-                result += ' ';
-                in_whitespace = true;
-            }
-        }
-        else
-        {
-            result += c;
-            in_whitespace = false;
-        }
-    }
-    // Remove leading whitespace
-    size_t start = result.find_first_not_of(' ');
-    if (start == std::string::npos)
-        return "";
-    // Remove trailing whitespace
-    size_t end = result.find_last_not_of(' ');
-    return result.substr(start, end - start + 1);
-}
-    
-
 std::string get_arch()
 {
     // determine the architecture of the system
@@ -87,7 +52,6 @@ int update_bb64()
 {
     // determine path to this executable
     std::filesystem::path bb64_path = std::filesystem::canonical("/proc/self/exe");
-    std::filesystem::path parent_path = bb64_path.parent_path();
 
     // determine the architecture of the system
     std::string arch = get_arch();
@@ -96,7 +60,7 @@ int update_bb64()
 
     // download new version, preserve permissions and ownership
     std::string bash_script;
-    bash_script += "docker run --rm -v "+parent_path.string()+":/target";
+    bash_script += "docker run --rm -v /usr/local/bin:/target";
     bash_script += " gitea.jde.nz/public/debian-curl:latest";
     bash_script += " sh -c \"";
     bash_script += " curl -fsSL " + url + " -o /target/bb64_temp &&";
@@ -143,13 +107,8 @@ int main(int argc, char *argv[])
 Usage:
     bb64 BASE64COMMAND          Decodes and runs the command
     bb64 -[i|d] BASE64COMMAND   Displays the decoded command
-    
+    bb64 -e COMMAND             Encodes the command and prints the result
-    bb64 -e COMMAND             Encodes the command and prints the base64 encoded result
+    bb64 -u                     Updates bb64 to the latest version (may require sudo)
-    bb64 -e                     Encodes the command provided on stdin and prints the result
-
-    bb64 -u                     Updates bb64 to the latest version (uses docker)
-
-    bb64 -v                     Prints the version number
 
 )" << std::endl;
         return -1;
@@ -161,30 +120,11 @@ Usage:
     {
         if (mode == "-u")
             return update_bb64();
-        else if (mode == "-v")
-        {
-            std::cout << VERSION << std::endl;
-            return 0;
-        }
-        else if (mode == "-e")
-        {
-            std::ostringstream oss;
-            while (std::cin)
-            {
-                std::string line;
-                std::getline(std::cin, line);
-                oss << line << std::endl;
-            }
-            std::string tidier = tidy(oss.str());
-            std::cout << base64_encode(tidier) << std::endl;
-            return 0;
-        }
         else
             return decode_and_run(mode);
     }
 
     std::ostringstream oss;
-    std::string tidier;
 
     switch (hash(mode.c_str()))
     {
@@ -197,8 +137,7 @@ Usage:
     case hash("-e"):
         for (int i = 2; i < argc; ++i)
             oss << (i > 2 ? " " : "") << argv[i];
-        tidier = tidy(oss.str());
+        std::cout << base64_encode(oss.str()) << std::endl;
-        std::cout << base64_encode(tidier) << std::endl;
         break;
     default:
         std::cerr << "Invalid mode: " << mode << std::endl;

build.sh

@@ -8,7 +8,12 @@ mkdir -p "$OUTPUT_DIR"
 # Build for x86_64 with musl static linking
 if [[ $(uname -m) == "x86_64" ]]; then
     echo "Building for x86_64 (musl static)..."
-    x86_64-linux-musl-g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp
+    if command -v x86_64-linux-musl-g++ &>/dev/null; then
+        x86_64-linux-musl-g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp
+    else
+        g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp -static-libgcc -static-libstdc++
+        echo "Warning: musl-g++ not found, built with g++ static flags."
+    fi
     echo "Built bb64.amd64 (x86_64, static)"
 fi
 

install.sh

@@ -8,24 +8,6 @@ set -e
 # 4. moves the bb64 binary to /usr/local/bin
 # 5. prints a message to the user
 
-# 0. see if we were passed a folder to install to
-# -----------------------------------------------------------------------------
-INSTALL_DIR="$1"
-if [[ -z "$INSTALL_DIR" ]]; then
-    INSTALL_DIR="/usr/local/bin"
-else
-    echo "Installing bb64 to $INSTALL_DIR"
-    if [[ ! -d "$INSTALL_DIR" ]]; then
-        mkdir -p "$INSTALL_DIR"
-    fi
-fi
-
-# 0. see if we were passed a user to chown to
-# -----------------------------------------------------------------------------
-CHOWN_USER="$2"
-if [[ -z "$CHOWN_USER" ]]; then
-    CHOWN_USER=$(id -u)
-fi
 
 # 1. Determine architecture
 # ----------------------------------------------------------------------------- 
@@ -55,15 +37,15 @@ chmod +x "$TMPDIR/bb64"
 
 # 5. Move to /usr/local/bin
 # -----------------------------------------------------------------------------
-docker run --rm -v "$TMPDIR:/tmp" -v "$INSTALL_DIR:/target" alpine sh -c "cp /tmp/bb64 /target/bb64; chown $CHOWN_USER /target/bb64"
+docker run --rm -v "$TMPDIR:/tmp" -v /usr/local/bin:/target alpine sh -c "cp /tmp/bb64 /target/bb64"
 rm "$TMPDIR/bb64"
 
 # 6. Print success message
 # -----------------------------------------------------------------------------
-echo "bb64 installed successfully to $INSTALL_DIR/bb64 (arch $ARCH)"
+echo "bb64 installed successfully to /usr/local/bin/bb64 (version $TAG, arch $ARCH)"
-# echo " "
+echo " "
-# echo "Update bb64 with:"
+echo "Update bb64 with:"
-# echo "    bb64 -u"
+echo "    bb64 -u"
-# echo " "
+echo " "
-# echo "try it out with:"
+echo "try it out with:"
-# echo "    bb64 ZWNobyAiSGVsbG8td29ybGQhIGJiNjQgaXMgd29ya2luZy4i"
+echo "    bb64 ZWNobyAiSGVsbG8td29ybGQhIGJiNjQgaXMgd29ya2luZy4i"

install_prerequisites.sh

@@ -39,15 +39,15 @@ if [ ! -d "$INSTALL_DIR/aarch64-linux-musl-cross" ]; then
 fi
 
 # Print instructions for adding to PATH
-# cat <<EOF
+cat <<EOF
 
-# To use the musl cross compilers, add the following to your shell:
+To use the musl cross compilers, add the following to your shell:
-# export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
+export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
 
-# Or run:
+Or run:
-#     export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
+    export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
 
-# EOF
+EOF
 
 # Clean up
 rm -rf "$TMPDIR"

publish.sh

@@ -17,9 +17,8 @@ if [ ! -f version.h ]; then
     exit 1
 else
     v=$(cat version.h | grep -o 'static const char \*VERSION = "[0-9.]*";' | cut -d'"' -f2)
-    oldv=$v
+    v=$((v+1))
-    v=$((v+1))  
+    echo "Incrementing version from $v to $v" >&2
-    echo "Incrementing version from $oldv to $v" >&2
     echo "static const char *VERSION = \"$v\";" > version.h
 fi
 TAG="v$v"

version.h

@@ -1 +1 @@
-static const char *VERSION = "39";
+static const char *VERSION = "26";