Minimal Socket
1.0.0
MinimalSocket bietet Ihnen eine moderne C++- Bibliothek zum Einrichten und Erstellen von TCP- und UDP- Socket-Verbindungen auf völlig plattformunabhängige Weise. Die unterstützten Systeme sind: Windows , jede Linux- Distribution und MacOS .
Im Abschnitt „Funktionen“ werden die verschiedenen Funktionen von MinimalSocket detailliert beschrieben. Lesen Sie „Nutzung und Beispiele“, um zu sehen, wie einfach die Verwendung von MinimalSocket ist.
Dies ist ein CMake -Projekt. Überprüfen Sie die CMake-Unterstützung, um zu sehen, wie diese Bibliothek integriert werden kann.
Denken Sie daran, einen Stern zu hinterlassen, falls Sie diese Bibliothek nützlich fanden.
Du hast noch keinen Stern hinterlassen? Mach es jetzt ;)!
Mit MinimalSocket können Sie TCP- und UDP -Verbindungen aufbauen und einrichten. Nachrichten können sowohl als Byte- als auch als String-Puffer gesendet und empfangen werden. Tatsächlich ist dies tatsächlich die einzige Fähigkeit, die Sie für einen Socket benötigen, da komplexere Nachrichten unter anderem mithilfe von Ansätzen wie Google Protocol Buffers oder NanoPb in einen Bytepuffer serialisiert oder aus diesem internalisiert werden können.
Dies sind die bemerkenswertesten Merkmale von MinimalSocket :
Diese Tabelle fasst die Unterschiede zwischen dem blockierenden und dem nicht blockierenden Verhalten des Sockets zusammen, der mit MinimalSocket erstellt werden kann:
| Blockierungsverhalten: Der Anrufer wird blockiert, bis der Vorgang abgeschlossen ist oder eine Zeitüberschreitung erreicht ist (falls angegeben wurde). | Nicht blockierendes Verhalten, Funktionen kehren sofort zurück | |
|---|---|---|
| Akzeptieren eines neuen Clients (nur TCP) | Der Aufrufer-Thread wird absorbiert, bis ein neuer Client tatsächlich eine Verbindung anfordert oder eine Zeitüberschreitung erreicht ist (falls angegeben wurde). | Wenn eine Verbindungsanforderung von einem Client bereits vor dem Aufruf der Accept-Funktion in der Warteschlange stand, wird ein neuer Verbindungshandler zurückgegeben, andernfalls wird ein Nullopt zurückgegeben. |
| eine neue Nachricht erhalten (TCP und UDP) | Der Aufrufer-Thread wird absorbiert, bis eine neue Nachricht an den Socket gesendet wird oder eine Zeitüberschreitung erreicht wird (falls angegeben wurde). | Wenn eine Nachricht gesendet wurde und sich vor dem Aufruf der Empfangsfunktion bereits im Socket-Puffer befand, wird diese Nachricht zurückgegeben, andernfalls wird eine leere Nachricht zurückgegeben. |
| eine neue Nachricht senden (TCP und UDP) | Falls der Puffer des Sockets nicht voll ist und die zu sendende Nachricht vollständig aufnehmen kann, wird die Nachricht tatsächlich in den Puffer geschrieben und die Funktion kehrt fast augenblicklich zurück. Im umgekehrten Fall wird der Aufrufer-Thread absorbiert, bis der Platz im Puffer aufgebraucht ist (da Nachrichten von der anderen Seite verbraucht werden), und danach wird die Nachricht tatsächlich geschrieben und die Funktion abgeschlossen. | Wenn im Puffer des Sockets genügend Platz vorhanden ist, wird die Nachricht geschrieben und die Funktion kehrt zurück. Im gegenteiligen Fall kehrt die Funktion sofort zurück, ohne die Nachricht tatsächlich zu senden (das Senden kann später wiederholt werden). |
Du hast noch keinen Stern hinterlassen? Mach es jetzt ;)!
Um einen klassischen blockierenden TCP- Server zu erstellen, müssen Sie lediglich ein tcp::TcpServer- Objekt erstellen:
# include < MinimalSocket/tcp/TcpServer.h >
MinimalSocket::Port port = 15768 ; // the port to bind
MinimalSocket::tcp::TcpServer< true > tcp_server (
port, MinimalSocket::AddressFamily::IP_V4);öffne es:
// open the server: binds the port and start to listen on the port
bool success = tcp_server.open();und jetzt sind Sie bereit, neue Kunden anzunehmen:
// accepts the next client that will ask the connection
MinimalSocket::tcp::TcpConnectionBlocking accepted_connection =
tcp_server.acceptNewClient(); // blocking till a client actually asks the
// connectionSie können nun Nachrichten mit dem akzeptierten Client austauschen, indem Sie einfach Folgendes tun:
// receive a message
std:: size_t message_max_size = 1000 ;
std::string
received_message // resized to the nunber of bytes actually received
= accepted_connection.receive(message_max_size);
// send a message
accepted_connection.send( " a message to send " );Wenn Sie stattdessen einen nicht blockierenden Server benötigen, können Sie ihn auf ähnliche Weise erstellen:
MinimalSocket::Port port = 15768 ; // the port to bind
MinimalSocket::tcp::TcpServer< false > tcp_server (
port, MinimalSocket::AddressFamily::IP_V4);
tcp_server.open();Diese Serverversion ist nicht blockierend, was bedeutet, dass die Akzeptanzfunktion sofort zurückkehrt:
// check if a client asked for the connection. If no, the function immediately
// returns a nullopt. On the contrary, the returned optional contains the
// handler to the connected client
std::optional<MinimalSocket::tcp::TcpConnectionBlocking>
maybe_accepted_connection = tcp_server.acceptNewClient();Beachten Sie, dass, obwohl der Server an sich nicht blockiert, der eventuell akzeptierte Client-Handler blockiert. Sie können es auch in einen nicht blockierenden Socket umwandeln, indem Sie den Socket an einen nicht blockierenden Handler übertragen:
MinimalSocket::tcp::TcpConnectionNonBlocking accepted_connection_nn_block =
maybe_accepted_connection-> turnToNonBlocking ();Um einen TCP- Client zu erstellen, müssen Sie lediglich ein tcp::TcpClient- Objekt erstellen:
# include < MinimalSocket/tcp/TcpClient.h >
MinimalSocket::Port server_port = 15768 ;
std::string server_address = " 192.168.125.85 " ;
MinimalSocket::tcp::TcpClient< true > tcp_client (
MinimalSocket::Address{server_address, server_port});öffne es:
// Open the server. Here, the client will ask the connection to specified
// server. After that, the client will be actually connected.
bool success =
tcp_client.open(); // blocking till the connection is actually establishedSie können nun Informationen mit dem Remote-Server empfangen und senden, indem Sie einfach Folgendes tun:
// send a message
tcp_client.send( " a message to send " );
// receive a message
std:: size_t message_max_size = 1000 ;
std::string
received_message // resized to the nunber of bytes actually received
= tcp_client.receive(message_max_size);Wenn Sie stattdessen einen nicht blockierenden Client benötigen, können Sie ihn auf ähnliche Weise erstellen und verwenden:
MinimalSocket::Port server_port = 15768 ;
std::string server_address = " 192.168.125.85 " ;
MinimalSocket::tcp::TcpClient< false > tcp_client (
MinimalSocket::Address{server_address, server_port});
tcp_client.open();
std:: size_t message_max_size = 1000 ;
// non blocking receive: returns immediately with an empty message in case no
// new data were available, or with a non empty message in the contrary case
std::string received_message = tcp_client.receive(message_max_size);Um einen normalen UDP -Socket zu erstellen, müssen Sie lediglich ein udp::UDp- Objekt erstellen:
# include < MinimalSocket/udp/UdpSocket.h >
MinimalSocket::Port this_socket_port = 15768 ;
MinimalSocket::udp::Udp< true > udp_socket (this_socket_port,
MinimalSocket::AddressFamily::IP_V6);öffne es:
// Open the server. This will bind the specified port.
bool success = udp_socket.open();Sie können jetzt Informationen mit anderen UDP -Sockets empfangen und senden:
// send a message to another udp
MinimalSocket::Address other_recipient_udp =
MinimalSocket::Address{ " 192.168.125.85 " , 15768 };
udp_socket.sendTo( " a message to send " , other_recipient_udp);
// receive a message from another udp reaching this one
std:: size_t message_max_size = 1000 ;
auto received_message = udp_socket.receive(message_max_size);
// check the sender address
MinimalSocket::Address other_sender_udp = received_message->sender;
// access the received message
std::string received_message_content // resized to the nunber of bytes
// actually received
= received_message->received_message;Sie können sich auch dafür entscheiden, einen geöffneten UDP -Socket mit einer bestimmten Adresse zu „verbinden“. Beachten Sie, dass dies lediglich bedeutet, dass von anderen Peers eingehende Nachrichten herausgefiltert werden, da UDP- Sockets nicht verbindungsorientiert sind:
MinimalSocket::Address permanent_sender_udp =
MinimalSocket::Address{ " 192.168.125.85 " , 15768 };
MinimalSocket::udp::UdpConnected< true > udp_connected_socket =
udp_socket.connect(
permanent_sender_udp); // ownership of the underlying socket is
// transfered from udp_socket to
// udp_connected_socket, meaning that you can't
// use anymore udp_socket (unless you re-open
// it)Jetzt können Sie Daten senden und empfangen, ohne den Empfänger/Absender angeben zu müssen:
// receive a message
std:: size_t message_max_size = 1000 ;
std::string
received_message // resized to the nunber of bytes actually received
= udp_connected_socket.receive(message_max_size);
// send a message
udp_connected_socket.send( " a message to send " );Sie können auch nicht blockierende UDP -Sockets erstellen und verwenden:
MinimalSocket::Port this_socket_port = 15768 ;
MinimalSocket::udp::Udp< false > udp_socket (
this_socket_port, MinimalSocket::AddressFamily::IP_V6);
udp_socket.open();
std:: size_t message_max_size = 1000 ;
// non blocking receive: returns immediately with an empty message in case no
// new data were available, or with a non empty message in the contrary case
//
// struct ReceiveStringResult {
// Address sender;
// std::string received_message;
// };
std::optional<MinimalSocket::ReceiveStringResult> received_message =
udp_socket.receive(message_max_size);Du hast noch keinen Stern hinterlassen? Mach es jetzt ;)!
Beispiele für die Verwendung von TCP -Sockets finden Sie hier, während UDP -Beispiele hier besprochen werden.
AUFMERKSAMKEIT!!! Die Ausführung der Beispiele wird möglicherweise beim ersten Mal von Ihrer Firewall blockiert: Richten Sie Ihre Firewall ordnungsgemäß ein oder führen Sie die Beispiele mit Administratorrechten aus
Du hast noch keinen Stern hinterlassen? Mach es jetzt ;)!
Um diese Bibliothek zu nutzen, können Sie sich auf CMake verlassen. Genauer gesagt können Sie dieses Paket abrufen und auf die MinimalSocket -Bibliothek verlinken:
include (FetchContent)
set (BUILD_MinimalCppSocket_SAMPLES OFF CACHE BOOL "" FORCE) # you don't want the samples in this case
FetchContent_Declare(
min_sock
GIT_REPOSITORY https://github.com/andreacasalino/Minimal-Socket
GIT_TAG master
)
FetchContent_MakeAvailable(min_sock)und dann auf die MinimalSocket -Bibliothek verlinken:
target_link_libraries ( ${TARGET_NAME}
MinimalSocket
)Alle systemspezifischen Module sind intern enthalten und werden nicht offengelegt. Darüber hinaus sind wsock32 und ws2_32 unter Windows privat verknüpft und Sie müssen sie nicht erneut verknüpfen, wenn Sie MinimalSocket verwenden.
