udpcap
v2.0.1
Udpcap es una emulación de UDP-Socket de solo recepción basada en Npcap. Utiliza el controlador de captura de paquetes Npcap para capturar el tráfico de Ethernet, analizar todos los encabezados necesarios y devolver la carga útil UDP. ¡Con Udpcap puedes abrir un socket UDP y recibir datos sin tener que abrir un socket!
El proyecto es solo para Windows, ya que Npcap también está dirigido a Windows.
Udpcap puede :
Udpcap no puede :
CMake recupera cómodamente todas las dependencias. Sin embargo, para utilizar Udpcap, es necesario instalar el controlador Npcap. Tenga en cuenta que la licencia Npcap es propietaria.
Usar un controlador de captura de paquetes para emular un socket UDP parece una idea terrible, ¿cuando podrías usar un socket UDP adecuado? Bueno, probablemente lo sea. Pero espera, hay un problema de Windows muy específico que este proyecto puede solucionar.
En comparación con Windows 7, Windows 10 tiene un Windows Defender más agresivo (el servicio MpsSvc). Al recibir muchos paquetes de multidifusión UDP con un socket normal en Windows 10, Windows Defender provoca una carga masiva de CPU que hace que todo el sistema se retrase. El problema parece empeorar cuando la máquina con Windows está conectada a un dominio de Windows, como suele hacerse en las redes de grandes corporaciones. Al investigar el sistema con Process Hacker, se puede ver que el proceso System (el kernel de Windows) ocupa tanto como un núcleo de CPU completo. Siempre hay un subproceso dentro del kernel que utiliza todos los ciclos de la CPU y tiene tcpip.sys en su pila de llamadas:
El Defender Firewall ya no se puede desactivar en Windows 10. El servicio MpsSvc seguirá ejecutándose incluso cuando se desactive temporalmente, ya que ofrece más funciones de seguridad además del Defender Firewall.
En Windows, cada acceso a la red (iniciado por el espacio del usuario) utiliza la API Winsocks/2. Esa API utiliza el controlador del sistema de archivos en modo kernel Afd.sys , que luego utiliza el controlador de protocolo de transporte tcpip.sys . El controlador tcpip.sys es donde ocurre toda la magia del protocolo en Windows. Este es también el punto donde el Firewall de Windows Defender analiza el tráfico. Microsoft ha creado una API completa sólo para ese propósito: la plataforma de filtrado de Windows (WFP). Esta API está disponible en Windows Vista y versiones posteriores. Debajo de tcpip.sys solo se encuentran NDIS.sys (Especificación de interfaz de controlador de red) y los controladores NIC Ethernet reales. Entonces, para solucionar el problema de carga de la CPU del Defender Firewall, debemos omitir todo el controlador tcpip.sys y todo lo que está encima de él. Consulte la imagen a continuación (líneas negras) para obtener una descripción general. Cuando se utiliza Npcap, Windows Defender no ve ningún socket abierto y no analiza el tráfico. Sin embargo, esto significa que la pila de protocolos UDP debe volver a implementarse en el espacio del usuario (¡ahí es donde Udpcap resulta útil!) .
Udpcap tiene una API muy simple con grandes similitudes con otras API de socket conocidas:
# 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 ;
}
Necesitará git-for-windows, Visual Studio 2015 o posterior y CMake 3.13 o posterior para compilar Udpcap.
Clonar este repositorio
(Como alternativa, puede descargar este repositorio como archivo. No hay submódulos).
git clone https://github.com/eclipse-ecal/udpcap.git
cd udpcap Llame CMakeWindows.bat
Esto también descargará las siguientes dependencias:
.lib ).lib ) Abra _build/udpcap.sln con Visual Studio y compile udpcap y los ejemplos
Para ver algunos resultados de las muestras, obviamente siempre tendrá que ejecutar tanto la muestra del remitente como la de udpcap_reciever.
Puede configurar las siguientes opciones de CMake para controlar cómo se supone que debe compilarse Udpcap:
| Opción | Tipo | Por defecto | Explicación |
|---|---|---|---|
UDPCAP_BUILD_SAMPLES | BOOL | ON | Cree muestras de Udpcap (y asio) para enviar y recibir datos ficticios |
UDPCAP_BUILD_TESTS | BOOL | OFF | Construya los GTests de udpcap. Requiere que GTest::GTest esté disponible. |
UDPCAP_THIRDPARTY_ENABLED | BOOL | ON | Activar / Desactivar el uso de dependencias integradas. |
UDPCAP_THIRDPARTY_USE_BUILTIN_NPCAP | BOOL | ON | Busque y cree en una versión integrada del SDK de npcap. Sólo disponible si UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_PCAPPLUSPLUS | BOOL | ON | Busque y construya con una versión integrada de Pcap++. Sólo disponible si UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_ASIO | BOOL | ON | Busque y construya con una versión integrada de asio. Sólo disponible si UDPCAP_THIRDPARTY_ENABLED=ON |
UDPCAP_THIRDPARTY_USE_BUILTIN_GTEST | BOOL | ON | Obtenga y cree pruebas con una versión predefinida de GTest. Si está deshabilitado, los objetivos deben proporcionarse externamente. Sólo disponible si UDPCAP_THIRDPARTY_ENABLED=ON y UDPCAP_BUILD_TESTS=ON |
UDPCAP_LIBRARY_TYPE | STRING | Controla el tipo de biblioteca de Udpcap inyectando la cadena en la llamada add_library . Se puede configurar en ESTÁTICO / COMPARTIDO / OBJETO. Si se establece, esto anulará la opción BUILD_SHARED_LIBS CMake normal. Si no se establece, CMake utilizará la configuración predeterminada, que está controlada por BUILD_SHARED_LIBS . |
Integrar como binarios :
Descargue una versión de udpcap o compílela como se describió anteriormente. Si lo compila usted mismo, asegúrese de compilar e instalar tanto una versión de depuración como una versión de lanzamiento.
Si elige la biblioteca udpcap compartida (-> .dll ), será autónoma y solo necesitará copiar udpcap.dll / udpcapd.dll al directorio de su aplicación.
Si elige la biblioteca estática udpcap (-> .lib ), también debe hacer que los siguientes destinos estén disponibles para CMake:
pcapplusplus::pcapplusplusnpcap::npcapConsulte el ejemplo de integración de Udpcap para obtener sugerencias sobre cómo hacerlo. Puede encontrar los scripts y módulos para buscar y buscar Npcap y Pcap++ aquí:
Agregue el directorio udpcap a su CMAKE_PREFIX_PATH :
cmake your_command_line -DCMAKE_PREFIX_PATH=path/to/udpcap/install/dirIntegrar como fuente
Haga que la fuente udpcap esté disponible de cualquier manera. Puede, por ejemplo, descargarlo manualmente, usar un submódulo git o usar CMake FetchContent.
Agregue lo siguiente a su 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" ) Ahora puedes vincular contra udpcap::udpcap
