Initial commit

1 files changed, 245 insertions, 0 deletions

diff --git a/toolsrc/src/main.cpp b/toolsrc/src/main.cpp
new file mode 100644
index 000000000..bba1f3c63
--- /dev/null
+++ b/toolsrc/src/main.cpp
@@ -0,0 +1,245 @@
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include <cassert>
+#include "vcpkg.h"
+#include "vcpkg_Commands.h"
+#include "metrics.h"
+#include <Shlobj.h>
+#include "vcpkg_Files.h"
+#include "vcpkg_System.h"
+
+using namespace vcpkg;
+
+bool g_debugging = false;
+
+void invalid_command(const std::string& cmd)
+{
+    System::println(System::color::error, "invalid command: %s", cmd);
+    print_usage();
+    exit(EXIT_FAILURE);
+}
+
+static void inner(const vcpkg_cmd_arguments& args)
+{
+    TrackProperty("command", args.command);
+    if (args.command.empty())
+    {
+        print_usage();
+        exit(EXIT_FAILURE);
+    }
+
+    if (auto command_function = find_command(args.command, get_available_commands_type_c()))
+    {
+        return command_function(args);
+    }
+
+    fs::path vcpkg_root_dir;
+    if (args.vcpkg_root_dir != nullptr)
+    {
+        vcpkg_root_dir = fs::absolute(Strings::utf8_to_utf16(*args.vcpkg_root_dir));
+    }
+    else
+    {
+        auto vcpkg_root_dir_env = System::wdupenv_str(L"VCPKG_ROOT");
+
+        if (!vcpkg_root_dir_env.empty())
+            vcpkg_root_dir = fs::absolute(vcpkg_root_dir_env);
+        else
+            vcpkg_root_dir = fs::absolute(System::get_exe_path_of_current_process()).parent_path();
+    }
+
+    const expected<vcpkg_paths> expected_paths = vcpkg_paths::create(vcpkg_root_dir);
+    Checks::check_exit(!expected_paths.error_code(), "Error: Invalid vcpkg root directory %s: %s", vcpkg_root_dir.string(), expected_paths.error_code().message());
+    const vcpkg_paths paths = expected_paths.get_or_throw();
+    int exit_code = _wchdir(paths.root.c_str());
+    Checks::check_exit(exit_code == 0, "Changing the working dir failed");
+
+    if (auto command_function = find_command(args.command, get_available_commands_type_b()))
+    {
+        return command_function(args, paths);
+    }
+
+    triplet default_target_triplet = triplet::X86_WINDOWS;
+
+    if (args.target_triplet != nullptr)
+    {
+        const std::string& target_triplet = *args.target_triplet;
+
+        auto it = fs::directory_iterator(paths.triplets);
+        for (; it != fs::directory_iterator(); ++it)
+        {
+            std::string triplet_file_name = it->path().stem().generic_u8string();
+            if (target_triplet == triplet_file_name) // TODO: fuzzy compare
+            {
+                default_target_triplet = {triplet_file_name};
+                break;
+            }
+        }
+
+        if (it == fs::directory_iterator())
+        {
+            System::println(System::color::error, "Error: invalid triplet: %s", target_triplet);
+            TrackProperty("error", "invalid triplet: " + target_triplet);
+            help_topic_valid_triplet(paths);
+            exit(EXIT_FAILURE);
+        }
+    }
+
+    if (auto command_function = find_command(args.command, get_available_commands_type_a()))
+    {
+        return command_function(args, paths, default_target_triplet);
+    }
+
+    return invalid_command(args.command);
+}
+
+static void loadConfig()
+{
+    fs::path localappdata;
+    {
+        // Config path in AppDataLocal
+        wchar_t* localappdatapath = nullptr;
+        if (S_OK != SHGetKnownFolderPath(FOLDERID_LocalAppData, 0, nullptr, &localappdatapath))
+            __fastfail(1);
+        localappdata = localappdatapath;
+        CoTaskMemFree(localappdatapath);
+    }
+
+    try
+    {
+        std::string config_contents = Files::get_contents(localappdata / "vcpkg" / "config").get_or_throw();
+
+        std::unordered_map<std::string, std::string> keys;
+        auto pghs = parse_paragraphs(config_contents);
+        if (pghs.size() > 0)
+            keys = pghs[0];
+
+        for (size_t x = 1; x < pghs.size(); ++x)
+        {
+            for (auto&& p : pghs[x])
+                keys.insert(p);
+        }
+
+        auto user_id = keys["User-Id"];
+        auto user_time = keys["User-Since"];
+        Checks::check_throw(!user_id.empty() && !user_time.empty(), ""); // Use as goto to the catch statement
+
+        SetUserInformation(user_id, user_time);
+        return;
+    }
+    catch (...)
+    {
+    }
+
+    // config file not found, could not be read, or invalid
+    std::string user_id, user_time;
+    InitUserInformation(user_id, user_time);
+    SetUserInformation(user_id, user_time);
+    try
+    {
+        std::error_code ec;
+        fs::create_directory(localappdata / "vcpkg", ec);
+        std::ofstream(localappdata / "vcpkg" / "config", std::ios_base::out | std::ios_base::trunc)
+            << "User-Id: " << user_id << "\n"
+            << "User-Since: " << user_time << "\n";
+    }
+    catch (...)
+    {
+    }
+}
+
+static System::Stopwatch g_timer;
+
+static std::string trim_path_from_command_line(const std::string& full_command_line)
+{
+    Checks::check_exit(full_command_line.size() > 0, "Internal failure - cannot have empty command line");
+
+    if (full_command_line[0] == '"')
+    {
+        auto it = std::find(full_command_line.cbegin() + 1, full_command_line.cend(), '"');
+        if (it != full_command_line.cend()) // Skip over the quote
+            ++it;
+        while (it != full_command_line.cend() && *it == ' ') // Skip over a space
+            ++it;
+        return std::string(it, full_command_line.cend());
+    }
+
+    auto it = std::find(full_command_line.cbegin(), full_command_line.cend(), ' ');
+    while (it != full_command_line.cend() && *it == ' ')
+        ++it;
+    return std::string(it, full_command_line.cend());
+}
+
+int wmain(const int argc, const wchar_t* const* const argv)
+{
+    if (argc == 0)
+        std::abort();
+
+    std::cout.sync_with_stdio(false);
+    std::cout.imbue(std::locale::classic());
+
+    g_timer.start();
+    atexit([]()
+        {
+            g_timer.stop();
+            TrackMetric("elapsed_us", g_timer.microseconds());
+            Flush();
+        });
+
+    TrackProperty("version", version());
+
+    const std::string trimmed_command_line = trim_path_from_command_line(Strings::utf16_to_utf8(GetCommandLineW()));
+    TrackProperty("cmdline", trimmed_command_line);
+    loadConfig();
+
+    const vcpkg_cmd_arguments args = vcpkg_cmd_arguments::create_from_command_line(argc, argv);
+
+    if (args.printmetrics != opt_bool::unspecified)
+        SetPrintMetrics(args.printmetrics == opt_bool::enabled);
+    if (args.sendmetrics != opt_bool::unspecified)
+        SetSendMetrics(args.sendmetrics == opt_bool::enabled);
+
+    if (args.debug != opt_bool::unspecified)
+    {
+        g_debugging = (args.debug == opt_bool::enabled);
+    }
+
+    if (g_debugging)
+    {
+        inner(args);
+        exit(EXIT_FAILURE);
+    }
+
+    std::string exc_msg;
+    try
+    {
+        inner(args);
+        exit(EXIT_FAILURE);
+    }
+    catch (std::exception& e)
+    {
+        exc_msg = e.what();
+    }
+    catch (...)
+    {
+        exc_msg = "unknown error(...)";
+    }
+    TrackProperty("error", exc_msg);
+    std::cerr
+        << "vcpkg.exe has crashed.\n"
+        << "Please send an email to:\n"
+        << "    vcpkg@microsoft.com\n"
+        << "containing a brief summary of what you were trying to do and the following data blob:\n"
+        << "\n"
+        << "Version=" << version() << "\n"
+        << "EXCEPTION='" << exc_msg << "'\n"
+        << "CMD=\n";
+    for (int x = 0; x < argc; ++x)
+        std::cerr << argv[x] << "|\n";
+    std::cerr
+        << "\n";
+}