parser.cpp

#include <iostream>
#include <vector>
#include <string>
#include <cctype>
#include <stdexcept>
#include <map>
#include <fstream>

// sha -1
#include <openssl/sha.h>
#include <sstream>
#include <iomanip>

using namespace std;

size_t g_info_start = 0;
size_t g_info_end = 0;
bool g_info_found = false;

struct BencodeValue
{
    enum class Type
    {
        Int,
        String,
        List,
        Dict
    };
    Type type;
    int64_t integer;
    string str;
    vector<BencodeValue> list;
    map<string, BencodeValue> dict;
};

BencodeValue parseInt(const vector<uint8_t> &data, size_t &pos)
{

    // skip i
    pos++;

    bool negative = false;

    if (data[pos] == '-')
    {
        negative = true;
        pos++;
    }

    int64_t val = 0;

    while (data[pos] != 'e')
    {

        if (!isdigit(data[pos]))
        {
            throw runtime_error("invalid integer in bencode");
        }

        val = val * 10 + (data[pos] - '0');
        pos++;
    }
    // skip e
    pos++;

    if (negative)
        val = -val;

    BencodeValue v;
    v.type = BencodeValue::Type::Int;
    v.integer = val;

    return v;
}

BencodeValue parseString(const vector<uint8_t> &data, size_t &pos)
{

    size_t length = 0;

    while (data[pos] != ':')
    {
        if ((!isdigit(data[pos])))
            throw runtime_error("Invalid character in Bencode string");

        length = length * 10 + (data[pos] - '0');
        pos++;
    }

    // skip :
    pos++;

    if (pos + length > data.size())
        throw runtime_error("Invalid Bencode String");

    string s;

    s.reserve(length);

    for (size_t i = 0; i < length; i++)
    {
        s.push_back(static_cast<char>(data[pos]));
        pos++;
    }

    BencodeValue v;
    v.type = BencodeValue::Type::String;
    v.str = s;

    return v;
}

BencodeValue parse(const vector<uint8_t> &data, size_t &pos);

BencodeValue parseList(const vector<uint8_t> &data, size_t &pos)
{
    // skip l;
    pos++;

    BencodeValue v;
    v.type = BencodeValue::Type::List;

    while (data[pos] != 'e')
    {
        v.list.push_back(parse(data, pos));
    }

    // skip e;
    pos++;

    return v;
}

BencodeValue parseDict(const vector<uint8_t> &data, size_t &pos)
{

    // skip d;
    pos++;

    BencodeValue v;
    v.type = BencodeValue::Type::Dict;

    while (data[pos] != 'e')
    {
        BencodeValue key = parseString(data, pos);

        if (key.str == "info" && !g_info_found)
        {
            g_info_found = true;
            g_info_start = pos;
            BencodeValue value = parse(data, pos);
            g_info_end = pos;
            v.dict[key.str] = value;
        }
        else
        {
            BencodeValue value = parse(data, pos);
            v.dict[key.str] = value;
        }
    }

    pos++;

    return v;
}

BencodeValue parse(const vector<uint8_t> &data, size_t &pos)
{

    if (pos > data.size())
        throw runtime_error("Unexpected end of data");

    if (data[pos] == 'i')
    {
        return parseInt(data, pos);
    }

    if (isdigit(data[pos]))
    {
        return parseString(data, pos);
    }

    if (data[pos] == 'l')
    {
        return parseList(data, pos);
    }

    if (data[pos] == 'd')
    {
        return parseDict(data, pos);
    }

    throw runtime_error("Unsupported bencode type (yet)");
}

vector<uint8_t> readFile(const string &path)
{
    ifstream file(path, ios::binary);

    if (!file)
        throw runtime_error("failed to open file");

    return vector<uint8_t>((istreambuf_iterator<char>(file)), istreambuf_iterator<char>());
}

void printJson(const BencodeValue &v, int indent = 0)
{

    const auto pad = [&]()
    {
        for (size_t i = 0; i < indent; i++)
            cout << " ";
    };

    switch (v.type)
    {

    case BencodeValue::Type::Int:
        std::cout << v.integer;
        break;

    case BencodeValue::Type::String:
        std::cout << "\"" << v.str << "\"";
        break;

    case BencodeValue::Type::List:
        cout << "[\n";
        for (size_t i = 0; i < v.list.size(); i++)
        {
            pad();
            cout << " ";
            printJson(v.list[i], indent + 1);
            // 4. The Comma Check
            if (i + 1 < v.list.size())
                std::cout << ",";
            std::cout << "\n";
        }
        pad();
        cout << "\n]";
        break;

    case BencodeValue::Type::Dict:
        std::cout << "{\n";
        size_t count = 0;
        for (const auto &[k, val] : v.dict)
        {
            pad();
            std::cout << "  \"" << k << "\": ";
            printJson(val, indent + 1);
            if (++count < v.dict.size())
                std::cout << ",";
            std::cout << "\n";
        }
        pad();
        std::cout << "}";
        break;
    }
}

std::string sha1Hex(const std::vector<uint8_t> &data,
                    size_t start,
                    size_t end)
{
    unsigned char hash[SHA_DIGEST_LENGTH];

    SHA1(&data[start], end - start, hash);

    std::ostringstream oss;
    for (int i = 0; i < SHA_DIGEST_LENGTH; i++)
    {
        oss << std::hex << std::setw(2)
            << std::setfill('0')
            << static_cast<int>(hash[i]);
    }
    return oss.str();
}

vector<string> extractTrackers(const BencodeValue &root)
{

    if (root.type != BencodeValue::Type::Dict)
    {
        throw runtime_error("torrent type is not dict");
    }

    vector<string> trackers;

    auto it = root.dict.find("announce-list");
    if (it != root.dict.end())
    {
        if (it->second.type != BencodeValue::Type::List)
        {
            throw runtime_error("announce List is not list");
        }

        for (const auto &tier : it->second.list)
        {
            if (tier.type != BencodeValue::Type::List)
            {
                throw runtime_error("announce-list tier is not a list");
            }

            for (const auto &tracker : tier.list)
            {
                if (tracker.type != BencodeValue::Type::String)
                {
                    throw std::runtime_error("tracker URL is not a string");
                }

                if (tracker.str.rfind("http://") || tracker.str.rfind("https://"))
                {
                    trackers.push_back(tracker.str);
                }
            }
        }

        if (trackers.empty())
        {
            auto it2 = root.dict.find("announce");
            if (it2 == root.dict.end())
            {
                throw runtime_error("no announce or announce-list found");
            }

            if (it2->second.type == BencodeValue::Type::String)
            {
                throw runtime_error("anounce is not a string");
            }

            trackers.push_back(it2->second.str);
        }


    }

            return trackers;
}

int main()
{
    try
    {
        auto data = readFile("sample.torrent");
        size_t pos = 0;

        BencodeValue root = parse(data, pos);

        // printJson(root);

        if (!g_info_found)
        {
            throw std::runtime_error("info dictionary not found");
        }

        std::string infoHash = sha1Hex(data, g_info_start, g_info_end);
        std::cout << "Info-hash: " << infoHash << "\n";

        auto trackers = extractTrackers(root);

        std::cout << "Trackers:\n";
        for (const auto &t : trackers)
        {
            std::cout << "  " << t << "\n";
        }

        // std::cout << "Torrent parsed successfully\n";
    }
    catch (const std::exception &ex)
    {
        std::cerr << "Error: " << ex.what() << "\n";
    }
}