udpcap
v2.0.1
Udpcap é uma emulação de soquete UDP somente para recebimento baseada em Npcap. Ele utiliza o driver de captura de pacotes Npcap para capturar o tráfego Ethernet, analisar todos os cabeçalhos necessários e retornar a carga UDP. Com o Udpcap você pode abrir um Socket UDP e receber dados sem realmente abrir um Socket!
O projeto é apenas para Windows, já que o Npcap também tem como alvo o Windows.
Udpcap pode :
Udpcap não pode :
Todas as dependências são convenientemente buscadas pelo CMake. No entanto, para realmente usar o Udpcap, o driver Npcap precisa ser instalado. Tenha em mente que a licença Npcap é proprietária.
Usar um driver de captura de pacotes para emular um soquete UDP parece uma péssima idéia, quando você poderia simplesmente usar um soquete UDP adequado? Bem, provavelmente é. Mas espere, há um problema muito específico do Windows que este projeto pode solucionar.
Comparado ao Windows 7, o Windows 10 possui um Windows Defender mais agressivo (o serviço MpsSvc). Ao receber muitos pacotes multicast UDP com um soquete regular no Windows 10, o Windows Defender causa uma carga massiva de CPU, tornando todo o sistema lento. O problema parece ser pior quando a máquina Windows está conectada a um domínio Windows, como normalmente é feito em redes de grandes corporações. Ao investigar o Sistema com Process Hacker, pode-se ver que o processo System (o Kernel do Windows) ocupa tanto quanto um núcleo inteiro da CPU. É sempre um thread dentro do kernel que utiliza todos os ciclos da CPU e possui tcpip.sys em sua pilha de chamadas:
O Defender Firewall não pode mais ser desativado no Windows 10. O serviço MpsSvc continuará funcionando mesmo quando desativado temporariamente, pois oferece outros recursos de segurança além do Defender Firewall.
No Windows, todo acesso à rede (iniciado no espaço do usuário) usa a API Winsocks/2. Essa API usa o driver do sistema de arquivos no modo Kernel Afd.sys , que então usa o driver do protocolo de transporte tcpip.sys . O driver tcpip.sys é onde toda a mágica do protocolo acontece no Windows. Este também é o ponto onde o Firewall do Windows Defender analisa o tráfego. A Microsoft criou uma API inteira apenas para esse propósito: a Windows Filtering Platform (WFP). Essa API está disponível no Windows Vista e versões posteriores. Abaixo de tcpip.sys vem apenas o NDIS.sys (Especificação de interface de driver de rede) e os drivers NIC Ethernet reais. Portanto, para solucionar o problema de carga da CPU do Defender Firewall, precisamos ignorar todo o driver tcpip.sys e tudo acima dele. Consulte a imagem abaixo (linhas pretas) para obter uma visão geral. Ao usar o Npcap, o Windows Defender não vê nenhum soquete aberto e não analisa o tráfego. No entanto, isso significa que a pilha de protocolos UDP deve ser reimplementada no espaço do usuário (é aí que o Udpcap é útil!) .
Udpcap possui uma API muito simples com fortes semelhanças com outras APIs de soquete conhecidas:
# include < iostream >
# include < udpcap/udpcap_socket.h >
int main ()
{
// Create a Udpcap socket and bind it to a port. For this example we want to
// receive data from any local or remote source and therefore not bind to an
// IP address.
Udpcap::UdpcapSocket socket;
socket. bind ( Udpcap::HostAddress::Any (), 14000 );
for (;;)
{
// Allocate a buffer for the received datagram. The size of the buffer
// should be large enough to hold the largest possible datagram.
std::vector< char > datagram ( 65535 );
// Create an error code object to hold the error code if an error occurs.
Udpcap::Error error = Udpcap::Error::OK;
// Receive a datagram from the Socket. This is a blocking
// operation. The operation will return once a datagram has been received,
// the socket was closed by another thread or an error occured.
size_t num_bytes = socket. receiveDatagram (datagram. data (), datagram. size (), error);
// Resize the buffer to the actual size of the received datagram.
datagram. resize (num_bytes);
std::cout << " Received " << datagram. size () << " bytes: "
<< std::string (datagram. data (), datagram. size ())
<< std::endl;
}
return 0 ;
}
Você precisará do git-for-windows, do Visual Studio 2015 ou mais recente e do CMake 3.13 ou mais recente para compilar o Udpcap.
Clonar este repositório
(Como alternativa, você pode baixar este repositório como arquivo. Não há submódulos.)
git clone https://github.com/eclipse-ecal/udpcap.git
cd udpcap Chame CMakeWindows.bat
Isso também baixará as seguintes dependências:
.lib ).lib ) Abra _build/udpcap.sln com Visual Studio e compile udpcap e os exemplos
Para ver alguma saída das amostras, você obviamente terá que sempre executar a amostra sender e udpcap_reciever.
Você pode definir as seguintes opções do CMake para controlar como o Udpcap deve ser compilado:
| Opção | Tipo | Padrão | Explicação |
|---|---|---|---|
UDPCAP_BUILD_SAMPLES | BOOL | ON | Construa as amostras Udpcap (e asio) para enviar e receber dados fictícios |
UDPCAP_BUILD_TESTS | BOOL | OFF | Construa os testes udpcap. Requer que GTest::GTest esteja disponível. |
UDPCAP_THIRDPARTY_ENABLED | BOOL | ON | Ativar/desativar o uso de dependências integradas. |
UDPCAP_THIRDPARTY_USE_BUILTIN_NPCAP | BOOL | ON | Busque e construa em uma versão integrada do SDK npcap. Disponível apenas se UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_PCAPPLUSPLUS | BOOL | ON | Busque e construa em uma versão integrada do Pcap++. Disponível apenas se UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_ASIO | BOOL | ON | Busque e construa em uma versão integrada do asio. Disponível apenas se UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_GTEST | BOOL | ON | Busque e construa testes em uma versão predefinida do GTest. Se desativado, os alvos deverão ser fornecidos externamente. Disponível apenas se UDPCAP_THIRDPARTY_ENABLED=ON e UDPCAP_BUILD_TESTS=ON |
UDPCAP_LIBRARY_TYPE | STRING | Controla o tipo de biblioteca Udpcap injetando a string na chamada add_library . Pode ser definido como ESTÁTICO/COMPARTILHADO/OBJETO. Se definido, isso substituirá a opção BUILD_SHARED_LIBS CMake normal. Se não for definido, o CMake usará a configuração padrão, que é controlada por BUILD_SHARED_LIBS . |
Integrar como binários :
Baixe uma versão udpcap ou construa-a conforme descrito anteriormente. Se você mesmo compilar, certifique-se de compilar e instalar uma versão de depuração e uma versão de lançamento.
Se você escolheu a biblioteca udpcap compartilhada (-> .dll ), ela será independente e você só precisará copiar udpcap.dll / udpcapd.dll para o diretório do seu aplicativo.
Se você escolheu a biblioteca estática udpcap (-> .lib ), também precisará disponibilizar os seguintes destinos para o CMake:
pcapplusplus::pcapplusplusnpcap::npcapConfira o exemplo de integração Udpcap para obter uma sugestão sobre como fazer isso. Você pode encontrar os scripts e módulos para buscar e encontrar Npcap e Pcap++ aqui:
Adicione o diretório udpcap ao seu CMAKE_PREFIX_PATH :
cmake your_command_line -DCMAKE_PREFIX_PATH=path/to/udpcap/install/dirIntegrar como fonte
Disponibilize a fonte udpcap de qualquer maneira. Você pode, por exemplo, baixá-lo manualmente, usar um submódulo git ou usar CMake FetchContent.
Adicione o seguinte ao seu CMakeLists.txt :
# You will probably not need the samples, so turn them off.
set (UDPCAP_BUILD_SAMPLES OFF )
# Add the top-level directory as cmake subdirectory
add_subdirectory ( "path_to_udpcap" )
# Add the dummy Findudpcap.cmake do the module path to make
# find_package(udpcap) succeed.
list ( APPEND CMAKE_MODULE_PATH "path_to_udpcap/thirdparty/udpcap/Modules" ) Agora você pode vincular-se ao udpcap::udpcap
