157 lines
4.3 KiB
C++
157 lines
4.3 KiB
C++
#include <iostream>
|
|
#include <unordered_map>
|
|
|
|
#include <argparse/argparse.hpp>
|
|
|
|
#include <basen.hpp>
|
|
#include <config.hpp>
|
|
|
|
#ifdef _WIN32
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
namespace basen
|
|
{
|
|
typedef std::string (*encoder_t)(std::span<const uint8_t>);
|
|
typedef std::vector<uint8_t> (*decoder_t)(std::string_view);
|
|
|
|
const std::unordered_map<std::string, encoder_t> encoders = {
|
|
{"base58", base58::encode},
|
|
{"base58check", base58::encodeCheck},
|
|
{"base64", base64::encode},
|
|
{"hex", hex::encode},
|
|
};
|
|
const std::unordered_map<std::string, decoder_t> decoders = {
|
|
{"base58", base58::decode},
|
|
{"base58check", base58::decodeCheck},
|
|
{"base64", base64::decode},
|
|
{"hex", hex::decode},
|
|
};
|
|
|
|
std::string getPipe()
|
|
{
|
|
std::string str;
|
|
str.reserve(1024 * 1024);
|
|
#ifdef _WIN32
|
|
if (_isatty(_fileno(stdin)))
|
|
#else
|
|
if (isatty(fileno(stdin)))
|
|
#endif
|
|
{
|
|
throw std::logic_error("should use pipe syntax ( | or < )");
|
|
}
|
|
else
|
|
{
|
|
char temp[4096];
|
|
while (std::cin.read(temp, sizeof(temp)))
|
|
{
|
|
str.insert(str.end(), temp, temp + std::cin.gcount());
|
|
}
|
|
str.insert(str.end(), temp, temp + std::cin.gcount());
|
|
}
|
|
if (!str.empty() && str.back() == '\n')
|
|
{
|
|
str.erase(str.size() - 1);
|
|
}
|
|
return str;
|
|
}
|
|
uint8_t error(const std::string &str, argparse::ArgumentParser &program) noexcept
|
|
{
|
|
std::cerr << "\033[31merror:\t\033[0m"
|
|
<< str << "\n\n"
|
|
<< program << '\n';
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
argparse::ArgumentParser program("basen", "1.1.0");
|
|
program.add_argument("-t", "--type")
|
|
.help("encoding type")
|
|
.metavar("STRING")
|
|
.choices("base58", "base58check", "base64", "hex");
|
|
program.add_argument("-a", "--alphabet")
|
|
.help("specify alphabet")
|
|
.metavar("STRING");
|
|
program.add_argument("-d", "--decode")
|
|
.help("decode flag")
|
|
.flag();
|
|
program.add_argument("-v", "--version")
|
|
.flag();
|
|
try
|
|
{
|
|
program.parse_args(argc, argv);
|
|
}
|
|
catch (const std::exception &err)
|
|
{
|
|
return basen::error(err.what(), program);
|
|
}
|
|
if (program.is_used("-v")) {
|
|
std::cout << BASEN_VER_STR << std::endl;
|
|
return 0;
|
|
}
|
|
if (!program.is_used("-t") && !program.is_used("-a"))
|
|
{
|
|
return basen::error("either -t or -a should be provided", program);
|
|
}
|
|
if (program.is_used("-t") && program.is_used("-a"))
|
|
{
|
|
return basen::error("-t and -a cannot be used together", program);
|
|
}
|
|
std::string str;
|
|
try
|
|
{
|
|
str = basen::getPipe();
|
|
}
|
|
catch (const std::exception &e)
|
|
{
|
|
return basen::error(e.what(), program);
|
|
}
|
|
try
|
|
{
|
|
if (program.is_used("-t"))
|
|
{
|
|
auto type = program.get<std::string>("-t");
|
|
if (program.is_used("-d"))
|
|
{
|
|
auto data = (*basen::decoders.at(type))(str);
|
|
std::for_each(data.begin(), data.end(), [](uint8_t item)
|
|
{ std::cout << (char)item; });
|
|
std::cout << '\n';
|
|
}
|
|
else
|
|
{
|
|
std::span<uint8_t> dv((uint8_t *)str.data(), str.size());
|
|
std::cout << (*basen::encoders.at(type))(dv) << '\n';
|
|
}
|
|
}
|
|
if (program.is_used("-a"))
|
|
{
|
|
auto alphabet = program.get<std::string>("-a");
|
|
uint8_t map[256];
|
|
baseN::digitsMap(alphabet.data(), alphabet.size(), map);
|
|
if (program.is_used("-d"))
|
|
{
|
|
auto data = baseN::decode(str, alphabet.size(), alphabet.data(), map);
|
|
std::for_each(data.begin(), data.end(), [](uint8_t item)
|
|
{ std::cout << (char)item; });
|
|
std::cout << '\n';
|
|
}
|
|
else
|
|
{
|
|
std::span<uint8_t> dv((uint8_t *)str.data(), str.size());
|
|
std::cout << baseN::encode(dv, alphabet.size(), alphabet.data()) << '\n';
|
|
}
|
|
}
|
|
}
|
|
catch (const basen::Exception &e)
|
|
{
|
|
return basen::error(e.message(), program);
|
|
}
|
|
return 0;
|
|
}
|