platformWindows.cpp

Go to the documentation of this file.

 
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <winsock2.h>
#include <windows.h>
#include <iphlpapi.h>
 
#include <algorithm>
#include <filesystem>
#include <limits>
#include <string>
#include <stdexcept>
#include <string_view>
#include <vector>
 
#include "profinet/util.h"
#include "profinet/exceptions.h"
 
namespace profinet
{
namespace
{
constexpr std::string_view kNpcapDevicePrefix = R"(\Device\NPF_)";
 
std::wstring Utf8ToWide(const std::string& value)
{
  if (value.empty())
  {
    return {};
  }
 
  if (value.size() > static_cast<std::size_t>(std::numeric_limits<int>::max()))
  {
    return {};
  }
 
  const int sourceLength = static_cast<int>(value.size());
  const int requiredLength = MultiByteToWideChar(
      CP_UTF8,
      MB_ERR_INVALID_CHARS,
      value.data(),
      sourceLength,
      nullptr,
      0);
 
  if (requiredLength <= 0)
  {
    return {};
  }
 
  std::wstring result(static_cast<std::size_t>(requiredLength), L'\0');
 
  const int convertedLength = MultiByteToWideChar(
      CP_UTF8,
      MB_ERR_INVALID_CHARS,
      value.data(),
      sourceLength,
      result.data(),
      requiredLength);
 
  if (convertedLength != requiredLength)
  {
    return {};
  }
 
  return result;
}
 
std::string NormalizeWindowsInterfaceName(const std::string& interface)
{
  if (interface.starts_with(kNpcapDevicePrefix))
  {
    return interface.substr(kNpcapDevicePrefix.size());
  }
 
  return interface;
}
} // namespace
 
MacAddress GetInterfaceMac(const std::string& interface)
{
  if (interface.empty())
  {
    throw SocketError("Interface name cannot be empty");
  }
 
  const std::string normalizedInterface = NormalizeWindowsInterfaceName(interface);
  const std::wstring wideInterface = Utf8ToWide(normalizedInterface);
 
  ULONG bufferSize = 15U * 1024U;
  std::vector<std::uint8_t> buffer(bufferSize);
 
  PIP_ADAPTER_ADDRESSES adapters = nullptr;
  ULONG result = ERROR_BUFFER_OVERFLOW;
 
  while (result == ERROR_BUFFER_OVERFLOW)
  {
    buffer.resize(bufferSize);
    adapters = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(buffer.data());
 
    result = GetAdaptersAddresses(
        AF_UNSPEC,
        0,
        nullptr,
        adapters,
        &bufferSize);
  }
 
  if (result != NO_ERROR)
  {
    throw SocketError("Failed to enumerate Windows network interfaces: error " +
                      std::to_string(result));
  }
 
  for (const IP_ADAPTER_ADDRESSES* adapter = adapters;
       adapter != nullptr;
       adapter = adapter->Next)
  {
    const bool adapterNameMatches =
        adapter->AdapterName != nullptr && normalizedInterface == adapter->AdapterName;
 
    const bool friendlyNameMatches =
        adapter->FriendlyName != nullptr &&
        !wideInterface.empty() &&
        wideInterface == adapter->FriendlyName;
 
    const bool descriptionMatches =
        adapter->Description != nullptr &&
        !wideInterface.empty() &&
        wideInterface == adapter->Description;
 
    if (!adapterNameMatches && !friendlyNameMatches && !descriptionMatches)
    {
      continue;
    }
 
    if (adapter->PhysicalAddressLength != macAddressLength)
    {
      throw SocketError("Interface '" + interface +
                        "' does not expose a six-byte MAC address");
    }
 
    MacAddress mac{};
    std::ranges::copy_n(
        adapter->PhysicalAddress,
        macAddressLength,
        mac.begin());
 
    return mac;
  }
 
  throw SocketError("Network interface not found: '" + interface + "'");
}
 
std::filesystem::path GetExecutableDirectory()
{
  std::vector<wchar_t> buffer(512U);
 
  for (;;)
  {
    const DWORD length = GetModuleFileNameW(
        nullptr,
        buffer.data(),
        static_cast<DWORD>(buffer.size()));
 
    if (length == 0U)
    {
      const DWORD error = GetLastError();
      throw std::runtime_error(
          "Failed to get executable path: " + std::to_string(error));
    }
 
    if (length < buffer.size())
    {
      return std::filesystem::path(
                 std::wstring(buffer.data(), buffer.data() + length))
          .parent_path();
    }
 
    buffer.resize(buffer.size() * 2U);
 
    if (buffer.size() > static_cast<std::size_t>(std::numeric_limits<DWORD>::max()))
    {
      throw std::runtime_error("Executable path exceeds the supported Windows path length");
    }
  }
}
 
} // namespace profinet