http_client.cpp

#include "pch.h"

#include "http_client.h"

#include <algorithm>
#include <atomic>
#include <fstream>
#include <vector>
#include <winhttp.h>

#pragma comment(lib, "winhttp.lib")

namespace mapupdater::net {
namespace {

constexpr wchar_t kUserAgent[] = L"MapUpdater/1.0";
constexpr int kHttpTimeoutMs = 15000;

struct WinHttpHandle {
  explicit WinHttpHandle(HINTERNET value = nullptr) : handle(value) {}
  ~WinHttpHandle() {
    if (handle != nullptr) {
      WinHttpCloseHandle(handle);
    }
  }

  WinHttpHandle(const WinHttpHandle &) = delete;
  WinHttpHandle &operator=(const WinHttpHandle &) = delete;

  HINTERNET get() const { return handle; }
  explicit operator bool() const { return handle != nullptr; }

 private:
  HINTERNET handle;
};

} // namespace

std::optional<HttpResponse> HttpGet(const std::wstring &url) {
  URL_COMPONENTS url_comp = {};
  wchar_t host_name[256] = {};
  wchar_t url_path[1024] = {};
  wchar_t extra_info[1024] = {};

  url_comp.dwStructSize = sizeof(url_comp);
  url_comp.lpszHostName = host_name;
  url_comp.dwHostNameLength = _countof(host_name);
  url_comp.lpszUrlPath = url_path;
  url_comp.dwUrlPathLength = _countof(url_path);
  url_comp.lpszExtraInfo = extra_info;
  url_comp.dwExtraInfoLength = _countof(extra_info);

  if (!WinHttpCrackUrl(url.c_str(), 0, 0, &url_comp)) {
    return std::nullopt;
  }

  const std::wstring host(url_comp.lpszHostName, url_comp.dwHostNameLength);

  std::wstring path;
  if (url_comp.dwUrlPathLength > 0) {
    path.assign(url_comp.lpszUrlPath, url_comp.dwUrlPathLength);
  } else {
    path = L"/";
  }
  if (url_comp.dwExtraInfoLength > 0) {
    path.append(url_comp.lpszExtraInfo, url_comp.dwExtraInfoLength);
  }

  WinHttpHandle session(WinHttpOpen(kUserAgent, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                    WINHTTP_NO_PROXY_NAME,
                                    WINHTTP_NO_PROXY_BYPASS, 0));
  if (!session) {
    return std::nullopt;
  }

  WinHttpSetTimeouts(session.get(), kHttpTimeoutMs, kHttpTimeoutMs,
                     kHttpTimeoutMs, kHttpTimeoutMs);

  WinHttpHandle connect(WinHttpConnect(session.get(), host.c_str(), url_comp.nPort, 0));
  if (!connect) {
    return std::nullopt;
  }

  const DWORD flags =
      (url_comp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
  WinHttpHandle request(WinHttpOpenRequest(
      connect.get(), L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER,
      WINHTTP_DEFAULT_ACCEPT_TYPES, flags));
  if (!request) {
    return std::nullopt;
  }

  const BOOL send_ok = WinHttpSendRequest(request.get(),
                                          WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                          WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
  if (!send_ok || !WinHttpReceiveResponse(request.get(), nullptr)) {
    return std::nullopt;
  }

  DWORD status_code = 0;
  DWORD status_code_size = sizeof(status_code);
  if (!WinHttpQueryHeaders(request.get(),
                           WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
                           WINHTTP_HEADER_NAME_BY_INDEX, &status_code,
                           &status_code_size, WINHTTP_NO_HEADER_INDEX)) {
    return std::nullopt;
  }

  if (status_code < 200 || status_code >= 300) {
    return HttpResponse{status_code, {}};
  }

  HttpResponse response;
  response.status_code = status_code;

  std::vector<char> buffer(16 * 1024);
  while (true) {
    DWORD available = 0;
    if (!WinHttpQueryDataAvailable(request.get(), &available)) {
      return std::nullopt;
    }
    if (available == 0) {
      break;
    }

    const DWORD to_read = (std::min)(available, static_cast<DWORD>(buffer.size()));
    DWORD downloaded = 0;
    if (!WinHttpReadData(request.get(), buffer.data(), to_read, &downloaded)) {
      return std::nullopt;
    }
    if (downloaded == 0) {
      break;
    }

    response.body.append(buffer.data(), downloaded);
  }

  return response;
}

DownloadFileResult HttpDownloadToFile(const std::wstring &url,
                                      const std::filesystem::path &target_path,
                                      DownloadProgressCallback on_progress,
                                      const std::atomic_bool *cancel_flag) {
  DownloadFileResult result;

  URL_COMPONENTS url_comp = {};
  wchar_t host_name[256] = {};
  wchar_t url_path[1024] = {};
  wchar_t extra_info[1024] = {};

  url_comp.dwStructSize = sizeof(url_comp);
  url_comp.lpszHostName = host_name;
  url_comp.dwHostNameLength = _countof(host_name);
  url_comp.lpszUrlPath = url_path;
  url_comp.dwUrlPathLength = _countof(url_path);
  url_comp.lpszExtraInfo = extra_info;
  url_comp.dwExtraInfoLength = _countof(extra_info);

  if (!WinHttpCrackUrl(url.c_str(), 0, 0, &url_comp)) {
    result.error_code = GetLastError();
    return result;
  }

  const std::wstring host(url_comp.lpszHostName, url_comp.dwHostNameLength);
  std::wstring path;
  if (url_comp.dwUrlPathLength > 0) {
    path.assign(url_comp.lpszUrlPath, url_comp.dwUrlPathLength);
  } else {
    path = L"/";
  }
  if (url_comp.dwExtraInfoLength > 0) {
    path.append(url_comp.lpszExtraInfo, url_comp.dwExtraInfoLength);
  }

  WinHttpHandle session(WinHttpOpen(kUserAgent, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                    WINHTTP_NO_PROXY_NAME,
                                    WINHTTP_NO_PROXY_BYPASS, 0));
  if (!session) {
    result.error_code = GetLastError();
    return result;
  }
  WinHttpSetTimeouts(session.get(), kHttpTimeoutMs, kHttpTimeoutMs,
                     kHttpTimeoutMs, kHttpTimeoutMs);

  WinHttpHandle connect(WinHttpConnect(session.get(), host.c_str(), url_comp.nPort, 0));
  if (!connect) {
    result.error_code = GetLastError();
    return result;
  }

  const DWORD flags =
      (url_comp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
  WinHttpHandle request(WinHttpOpenRequest(
      connect.get(), L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER,
      WINHTTP_DEFAULT_ACCEPT_TYPES, flags));
  if (!request) {
    result.error_code = GetLastError();
    return result;
  }

  const BOOL send_ok = WinHttpSendRequest(request.get(),
                                          WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                          WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
  if (!send_ok || !WinHttpReceiveResponse(request.get(), nullptr)) {
    result.error_code = GetLastError();
    return result;
  }

  DWORD status_code = 0;
  DWORD status_code_size = sizeof(status_code);
  if (!WinHttpQueryHeaders(request.get(),
                           WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
                           WINHTTP_HEADER_NAME_BY_INDEX, &status_code,
                           &status_code_size, WINHTTP_NO_HEADER_INDEX)) {
    result.error_code = GetLastError();
    return result;
  }
  result.status_code = status_code;

  if (status_code < 200 || status_code >= 300) {
    return result;
  }

  wchar_t content_length_buf[64] = {};
  DWORD content_length_size = sizeof(content_length_buf);
  if (WinHttpQueryHeaders(request.get(), WINHTTP_QUERY_CONTENT_LENGTH,
                          WINHTTP_HEADER_NAME_BY_INDEX, content_length_buf,
                          &content_length_size, WINHTTP_NO_HEADER_INDEX)) {
    wchar_t *end_ptr = nullptr;
    const unsigned long long content_length =
        wcstoull(content_length_buf, &end_ptr, 10);
    if (end_ptr != content_length_buf) {
      result.total_bytes = static_cast<uint64_t>(content_length);
    }
  }

  std::error_code fs_error;
  if (target_path.has_parent_path()) {
    std::filesystem::create_directories(target_path.parent_path(), fs_error);
    if (fs_error) {
      result.error_code = static_cast<uint32_t>(fs_error.value());
      return result;
    }
  }

  std::filesystem::path temp_path = target_path;
  temp_path += L".part";

  std::ofstream out(temp_path, std::ios::binary | std::ios::trunc);
  if (!out.is_open()) {
    result.error_code = GetLastError();
    return result;
  }

  std::vector<char> buffer(32 * 1024);
  if (on_progress) {
    if (!on_progress(0, result.total_bytes)) {
      result.canceled = true;
      result.error_code = ERROR_CANCELLED;
      out.close();
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }
  }

  while (true) {
    if (cancel_flag != nullptr && cancel_flag->load()) {
      result.canceled = true;
      result.error_code = ERROR_CANCELLED;
      out.close();
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }

    DWORD available = 0;
    if (!WinHttpQueryDataAvailable(request.get(), &available)) {
      result.error_code = GetLastError();
      out.close();
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }
    if (available == 0) {
      break;
    }

    const DWORD to_read = (std::min)(available, static_cast<DWORD>(buffer.size()));
    DWORD downloaded = 0;
    if (!WinHttpReadData(request.get(), buffer.data(), to_read, &downloaded)) {
      result.error_code = GetLastError();
      out.close();
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }
    if (downloaded == 0) {
      break;
    }

    out.write(buffer.data(), static_cast<std::streamsize>(downloaded));
    if (!out.good()) {
      result.error_code = ERROR_WRITE_FAULT;
      out.close();
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }

    result.downloaded_bytes += downloaded;

    if (on_progress) {
      if (!on_progress(result.downloaded_bytes, result.total_bytes)) {
        result.canceled = true;
        result.error_code = ERROR_CANCELLED;
        out.close();
        std::filesystem::remove(temp_path, fs_error);
        return result;
      }
    }
  }

  out.close();
  if (!out.good()) {
    result.error_code = ERROR_WRITE_FAULT;
    std::filesystem::remove(temp_path, fs_error);
    return result;
  }

  std::filesystem::rename(temp_path, target_path, fs_error);
  if (fs_error) {
    std::filesystem::remove(target_path, fs_error);
    fs_error.clear();
    std::filesystem::rename(temp_path, target_path, fs_error);
    if (fs_error) {
      result.error_code = static_cast<uint32_t>(fs_error.value());
      std::filesystem::remove(temp_path, fs_error);
      return result;
    }
  }

  result.success = true;
  return result;
}

std::optional<uint32_t> HttpPostNoBody(const std::wstring &url) {
  URL_COMPONENTS url_comp = {};
  wchar_t host_name[256] = {};
  wchar_t url_path[1024] = {};
  wchar_t extra_info[1024] = {};

  url_comp.dwStructSize = sizeof(url_comp);
  url_comp.lpszHostName = host_name;
  url_comp.dwHostNameLength = _countof(host_name);
  url_comp.lpszUrlPath = url_path;
  url_comp.dwUrlPathLength = _countof(url_path);
  url_comp.lpszExtraInfo = extra_info;
  url_comp.dwExtraInfoLength = _countof(extra_info);

  if (!WinHttpCrackUrl(url.c_str(), 0, 0, &url_comp)) {
    return std::nullopt;
  }

  const std::wstring host(url_comp.lpszHostName, url_comp.dwHostNameLength);

  std::wstring path;
  if (url_comp.dwUrlPathLength > 0) {
    path.assign(url_comp.lpszUrlPath, url_comp.dwUrlPathLength);
  } else {
    path = L"/";
  }
  if (url_comp.dwExtraInfoLength > 0) {
    path.append(url_comp.lpszExtraInfo, url_comp.dwExtraInfoLength);
  }

  WinHttpHandle session(WinHttpOpen(kUserAgent, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                    WINHTTP_NO_PROXY_NAME,
                                    WINHTTP_NO_PROXY_BYPASS, 0));
  if (!session) {
    return std::nullopt;
  }

  WinHttpSetTimeouts(session.get(), kHttpTimeoutMs, kHttpTimeoutMs,
                     kHttpTimeoutMs, kHttpTimeoutMs);

  WinHttpHandle connect(WinHttpConnect(session.get(), host.c_str(), url_comp.nPort, 0));
  if (!connect) {
    return std::nullopt;
  }

  const DWORD flags =
      (url_comp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0;
  WinHttpHandle request(WinHttpOpenRequest(
      connect.get(), L"POST", path.c_str(), nullptr, WINHTTP_NO_REFERER,
      WINHTTP_DEFAULT_ACCEPT_TYPES, flags));
  if (!request) {
    return std::nullopt;
  }

  const BOOL send_ok = WinHttpSendRequest(request.get(),
                                          WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                          WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
  if (!send_ok || !WinHttpReceiveResponse(request.get(), nullptr)) {
    return std::nullopt;
  }

  DWORD status_code = 0;
  DWORD status_code_size = sizeof(status_code);
  if (!WinHttpQueryHeaders(request.get(),
                           WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
                           WINHTTP_HEADER_NAME_BY_INDEX, &status_code,
                           &status_code_size, WINHTTP_NO_HEADER_INDEX)) {
    return std::nullopt;
  }

  return status_code;
}

} // namespace mapupdater::net