Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

18.0 KB
Raw Blame
#include "UserInputManager.h"

std::string UserInputManager::getLine(bool onlyNumber /* = false */) {
    std::string result;
    size_t cursorIndex = 0;

    while (true) {
        char c = terminalInput.handler();

        if (c == CARDPUTER_SPECIAL_ARROW_UP) {
            terminalView.print(std::string(1, CARDPUTER_SPECIAL_ARROW_UP));
            continue;
        }

        if (c == CARDPUTER_SPECIAL_ARROW_DOWN) {
            terminalView.print(std::string(1, CARDPUTER_SPECIAL_ARROW_DOWN));
            continue;
        }

        // Enter
        if (c == '\r' || c == '\n') break;

        // Backspace
        if ((c == '\b' || c == 127) && cursorIndex > 0) {
            cursorIndex--;
            result.erase(cursorIndex, 1);
            terminalView.print("\b \b");
            continue;
        }

        if (result.size() >= MAX_ALLOWED_INPUT_LENGTH) {
            continue;
        }

        // Only number
        if (onlyNumber && !std::isdigit(c)) {
            continue;
        }

        // Printable
        if (isprint(c)) {
            result.insert(cursorIndex, 1, c);
            cursorIndex++;
            terminalView.print(std::string(1, c));
        }
    }

    terminalView.println("");
    return result;
}

std::string UserInputManager::readSanitizedString(const std::string& label,
                                                  const std::string& def,
                                                  bool onlyLetter /* = false */)
{
    while (true) {
        terminalView.print(label + " [" + def + "]: ");
        std::string input = getLine(false);

        // ENTER ret default
        if (input.empty()) {
            return def;
        }

        std::string out;
        out.reserve(input.size());

        for (char c : input) {
            unsigned char uc = static_cast<unsigned char>(c);

            if (std::isalpha(uc)) {
                out.push_back(c);
            }
            else if (!onlyLetter && std::isdigit(uc)) {
                out.push_back(c);
            }
            else if (!onlyLetter && (c == '_' || c == '+' || c == '-')) {
                out.push_back(c);
            }
            // ignore others
        }

        // all filtered out ?
        if (out.empty()) {
            terminalView.println("Invalid input. Allowed: letters" +
                                 std::string(onlyLetter ? "" : ", digits, '_'"));
            continue;
        }

        return out;
    }
}

std::string UserInputManager::readString(const std::string& label,
                                         const std::string& def)
{
    // Print prompt
    terminalView.print(label);

    if (!def.empty()) {
        terminalView.print(" [" + def + "]");
    }
    terminalView.print(": ");

    // Raw input
    std::string input = getLine();

    // If empty, keep default
    if (input.empty()) {
        return def;
    }

    // Enforce max length
    if (input.size() > MAX_ALLOWED_INPUT_LENGTH) {
        input.resize(MAX_ALLOWED_INPUT_LENGTH);
    }

    return input;
}

uint8_t UserInputManager::readValidatedUint8(const std::string& label, uint8_t def, uint8_t min, uint8_t max) {
    while (true) {
        terminalView.print(label + " [" + std::to_string(def) + "]: ");
        std::string input = getLine();
        if (input.empty()) return def;

        if (argTransformer.isValidNumber(input)) {
            uint8_t val = argTransformer.toUint8(input);
            if (val >= min && val <= max) return val;
        }

        terminalView.println("Invalid input. Must be " + std::to_string(min) + "-" + std::to_string(max));
    }
}

uint8_t UserInputManager::readValidatedUint8(const std::string& label, uint8_t defaultVal) {
    return readValidatedUint8(label, defaultVal, 0, 255);
}

uint32_t UserInputManager::readValidatedUint32(const std::string& label, uint32_t def, bool hex) {
    while (true) {
        if (hex) {
            terminalView.print(label + " [0x" + argTransformer.toHex(def) + "]: ");
        } else {
            terminalView.print(label + " [" + std::to_string(def) + "]: ");
        }
        std::string input = getLine();
        if (input.empty()) return def;

        if (argTransformer.isValidNumber(input)) {
            return argTransformer.toUint32(input);
        }

        terminalView.println("Invalid number.");
    }
}

uint32_t UserInputManager::readValidatedHex(
    const std::string& label,
    int def,
    int min,
    int max)
{
    while (true) {

        terminalView.print(
            label + " [0x" + argTransformer.toHex(def) + "]: "
        );

        std::string input = getLine();

        // ENTER → default
        if (input.empty())
            return def;

        // Check valid number (hex or dec)
        if (!argTransformer.isValidNumber(input)) {
            terminalView.println("❌ Invalid number.");
            continue;
        }

        // Parse hex or dec
        uint32_t val = argTransformer.parseHexOrDec32(input);

        if (val < (uint32_t)min || val > (uint32_t)max) {
            terminalView.println(
                "❌ Out of range (0x" +
                argTransformer.toHex(min) + " - 0x" +
                argTransformer.toHex(max) + ")"
            );
            continue;
        }

        return val;
    }
}

uint8_t UserInputManager::readValidatedByte(const std::string& label,
                                            uint8_t def,
                                            bool showHex)
{
    while (true) {
        if (showHex) {
            terminalView.print(label + " [0x" + argTransformer.toHex(def) + "]: ");
        } else {
            terminalView.print(label + " [" + std::to_string(def) + "]: ");
        }

        std::string input = getLine();
        if (input.empty()) {
            return def;
        }

        if (!argTransformer.isValidNumber(input)) {
            terminalView.println("❌ Invalid number. Use dec (55) or hex (0x37).");
            continue;
        }

        uint32_t value = argTransformer.parseHexOrDec32(input);

        if (value > 0xFF) {
            terminalView.println("❌ Value out of range (0..255).");
            continue;
        }

        return static_cast<uint8_t>(value);
    }
}

char UserInputManager::readCharChoice(const std::string& label, char def, const std::vector<char>& allowed) {
    while (true) {
        terminalView.print(label + " [" + def + "]: ");
        std::string input = getLine();
        if (input.empty()) return def;

        char c = toupper(input[0]);
        if (std::find(allowed.begin(), allowed.end(), c) != allowed.end()) return c;

        terminalView.println("Invalid choice.");
    }
}

bool UserInputManager::readYesNo(const std::string& label, bool def) {
    while (true) {
        terminalView.print(label + " [" + (def ? "y" : "n") + "]: ");
        std::string input = getLine();
        if (input.empty()) return def;

        char c = tolower(input[0]);
        if (c == 'y') return true;
        if (c == 'n') return false;

        terminalView.println("Please answer y or n.");
    }
}

uint8_t UserInputManager::readModeNumber() {
    std::string inputDigit;
    size_t cursorIndex = 0;

    while (true) {
        char c = terminalInput.handler();

        if (c == CARDPUTER_SPECIAL_ARROW_UP) {
            terminalView.print(std::string(1, CARDPUTER_SPECIAL_ARROW_UP));
            continue;
        }

        if (c == CARDPUTER_SPECIAL_ARROW_DOWN) {
            terminalView.print(std::string(1, CARDPUTER_SPECIAL_ARROW_DOWN));
            continue;
        }

        // Enter
        if (c == '\r' || c == '\n') {
            terminalView.println("");
            break;
        }

        // Backspace
        if ((c == '\b' || c == 127) && cursorIndex > 0) {
            cursorIndex--;
            inputDigit.erase(cursorIndex, 1);
            terminalView.print("\b \b");
            continue;
        }

        // Only number
        if (std::isdigit(c)) {
            inputDigit.insert(cursorIndex, 1, c);
            cursorIndex++;
            terminalView.print(std::string(1, c));
        }
    }

    if (inputDigit.empty()) {
        return -1;
    }

    return std::stoi(inputDigit);
}

uint8_t UserInputManager::readValidatedPinNumber(const std::string& label, uint8_t def, uint8_t min, uint8_t max, const std::vector<uint8_t>& forbiddenPins) {
    while (true) {
        int val = readValidatedUint8(label, def, min, max);
        if (std::find(forbiddenPins.begin(), forbiddenPins.end(), val) != forbiddenPins.end()) {
            terminalView.println("This pin is reserved/protected and cannot be used.");
            continue;
        }
        return val;
    }
}

uint8_t UserInputManager::readValidatedPinNumber(const std::string& label, uint8_t def, const std::vector<uint8_t>& forbiddenPins) {
    return readValidatedPinNumber(label, def, 0, 48, forbiddenPins);
}

std::vector<uint8_t> UserInputManager::readValidatedPinGroup(
    const std::string& label,
    const std::vector<uint8_t>& defaultPins,
    const std::vector<uint8_t>& protectedPins
) {
    while (true) {
        // Default pins
        std::string defaultStr;
        for (size_t i = 0; i < defaultPins.size(); ++i) {
            if (i > 0) defaultStr += " ";
            defaultStr += std::to_string(defaultPins[i]);
        }
        
        // Display default list [1 2 3 ...]
        terminalView.print(label + " [" + defaultStr + "]: ");

        // Get user input
        std::string input = getLine();

        // Empty, we keep default pins
        if (input.empty()) {
            return defaultPins;
        }

        std::stringstream ss(input);
        std::vector<uint8_t> pins;
        int val;
        
        // Validate
        bool valid = true;
        while (ss >> val) {
            // Invalid
            if (val < 0 || val > 48) {
                terminalView.println("Invalid pin: " + std::to_string(val));
                valid = false;
                break;
            }
            // Protected
            if (std::find(protectedPins.begin(), protectedPins.end(), val) != protectedPins.end()) {
                terminalView.println("Pin " + std::to_string(val) + " is protected/reserved.");
                valid = false;
                break;
            }
            pins.push_back(static_cast<uint8_t>(val));
        }

        // Valid new pins
        if (valid && !pins.empty()) {
            return pins;
        }

        terminalView.println("Please enter valid, non-protected GPIOs separated by spaces.");
    }
}

std::string UserInputManager::readValidatedHexString(
    const std::string& label,
    size_t numItems,
    bool ignoreLen,
    size_t digitsPerItem /* = 2 */)
{
    while (true) {
        terminalView.print(label + "(hex): ");
        std::string input = getLine();

        // Remove space
        input.erase(std::remove_if(input.begin(), input.end(),
                    [](unsigned char c){ return std::isspace(c); }), input.end());

        // Empty ?
        if (input.empty()) {
            if (ignoreLen) {
                // Default value (one item at 0)
                return (digitsPerItem == 2) ? "00" : "0000";
            }
            terminalView.println("❌ Input cannot be empty.");
            continue;
        }

        // Verify hex
        bool valid = std::all_of(input.begin(), input.end(),
                        [](unsigned char c){ return std::isxdigit(c); });
        if (!valid) {
            terminalView.println("❌ Invalid characters. Only hexadecimal digits (0-9, A-F) are allowed.");
            continue;
        }

        // Verify length
        if (ignoreLen) {
            if (input.length() % digitsPerItem != 0) {
                terminalView.println("❌ Length must be a multiple of " + std::to_string(digitsPerItem) + " hex digits.");
                continue;
            }
        } else {
            const size_t expected = numItems * digitsPerItem;
            if (input.length() != expected) {
                terminalView.println("❌ Invalid length. Expected " + std::to_string(expected) + " hex digits.");
                continue;
            }
        }

        // Inject spaces between items (every digitsPerItem characters)
        std::string spaced;
        for (size_t i = 0; i < input.length(); i += digitsPerItem) {
            if (i > 0) spaced += ' ';
            spaced += input.substr(i, digitsPerItem);
        }

        return spaced;
    }
}

uint16_t UserInputManager::readValidatedCanId(const std::string& label, uint16_t defaultValue) {
    while (true) {
        terminalView.print(label + " (hex, max 3 digits) [default: " + argTransformer.toHex(defaultValue, 3) + "]: ");
        std::string input = getLine();

        if (input.empty()) return defaultValue;

        // Remove spaces
        input.erase(std::remove_if(input.begin(), input.end(), ::isspace), input.end());

        // Allow "0x" prefix
        if (input.rfind("0x", 0) == 0 || input.rfind("0X", 0) == 0) {
            input = input.substr(2);  // supprime le "0x"
        }

        // Check if input is valid hex
        bool valid = std::all_of(input.begin(), input.end(), [](char c) {
            return std::isxdigit(static_cast<unsigned char>(c));
        });

        if (!valid) {
            terminalView.println("❌ Invalid characters. Use hex digits only (0-9, A-F).");
            continue;
        }

        // Check length
        if (input.length() > 3) {
            terminalView.println("❌ Too long. Standard CAN ID must be ≤ 0x7FF (3 hex digits).");
            continue;
        }

        // Convert
        uint16_t id = std::stoul(input, nullptr, 16);

        // Check max value
        if (id > 0x7FF) {
            terminalView.println("❌ Value exceeds standard 11-bit CAN ID (max 0x7FF).");
            continue;
        }

        return id;
    }
}

int UserInputManager::readValidatedChoiceIndex(const std::string& label, const std::vector<std::string>& choices, int defaultIndex) {
    // Display choices
    terminalView.println(label + ":");
    for (size_t i = 0; i < choices.size(); ++i) {
        std::string prefix = (i == defaultIndex) ? "*" : " ";
        terminalView.println("  [" + std::to_string(i + 1) + "] " + prefix + choices[i]);
    }

    // Ask for index
    terminalView.print("Enter index (default " + std::to_string(defaultIndex + 1) + "): ");
    std::string input = getLine(true); // only numbers
    input = argTransformer.toLower(argTransformer.filterPrintable(input));

    // Default
    if (input.empty()) return defaultIndex;

    // Validate index
    int index;
    if (!argTransformer.parseInt(input, index) || index < 1 || index > (int)choices.size()) {
        terminalView.println("❌ Invalid choice. Using default.");
        return defaultIndex;
    }

    return index - 1; // Convert to 0 based index
}

int UserInputManager::readValidatedInt(const std::string& label, int def, int min /* = -127 */, int max /* = 127 */) {
    while (true) {
        terminalView.print(label + " [" + std::to_string(def) + "]: ");
        std::string input = getLine();
        if (input.empty()) return def;

        int val = 0;
        if (argTransformer.parseInt(input, val) && val >= min && val <= max) {
            return val;
        }
        terminalView.println("Invalid input. Must be " + std::to_string(min) + "-" + std::to_string(max));
    }
}

int UserInputManager::readValidatedChoiceIndex(const std::string& label, const std::vector<int>& choices, int defaultIndex) {
    std::vector<std::string> strChoices;
    strChoices.reserve(choices.size());
    for (int val : choices) {
        strChoices.push_back(std::to_string(val));
    }
    return readValidatedChoiceIndex(label, strChoices, defaultIndex);
}

int UserInputManager::readValidatedChoiceIndex(const std::string& label,
                                               const std::vector<float>& choices,
                                               int defaultIndex) {
    std::vector<std::string> strChoices;
    strChoices.reserve(choices.size());

    for (float f : choices) {
        std::ostringstream oss;
        oss.setf(std::ios::fixed);
        oss << std::setprecision(2) << f; 
        strChoices.push_back(oss.str());
    }
    return readValidatedChoiceIndex(label, strChoices, defaultIndex);
}

int UserInputManager::readValidatedChoiceIndex(const std::string& label,
                                               const char* const* choices,
                                               size_t count,
                                               int defaultIndex)
{
    if (!choices || count == 0) {
        terminalView.println("❌ No choices available.");
        return -1;
    }

    if (defaultIndex < 0 || defaultIndex >= (int)count) {
        defaultIndex = 0;
    }

    terminalView.println(label + ":");
    for (size_t i = 0; i < count; ++i) {
        const char* s = choices[i] ? choices[i] : "";
        const bool isDef = ((int)i == defaultIndex);

        terminalView.println(
            "  [" + std::to_string(i + 1) + "] " +
            std::string(isDef ? "* " : "  ") +
            s
        );
    }

    terminalView.print("Enter index (default " + std::to_string(defaultIndex + 1) + "): ");
    std::string input = getLine(true); // only numbers

    if (input.empty()) return defaultIndex;

    int idx = 0;
    if (!argTransformer.parseInt(input, idx) || idx < 1 || idx > (int)count) {
        terminalView.println("❌ Invalid choice. Using default.");
        return defaultIndex;
    }

    return idx - 1;
}

float UserInputManager::readValidatedFloat(const std::string& label,
                                           float def,
                                           float min,
                                           float max) {
    while (true) {
        terminalView.print(label + " [" + std::to_string(def) + "]: ");
        std::string input = getLine();
        if (input.empty()) return def;

        // Remove spaces
        input.erase(std::remove_if(input.begin(), input.end(), ::isspace), input.end());

        try {
            float v = std::stof(input);
            if (v >= min && v <= max) return v;
        } catch (...) {
            // fallthrough
        }
        terminalView.println("Invalid input. Must be " + std::to_string(min) + " .. " + std::to_string(max));
    }
}