Minimal Socket
1.0.0
MinimalSocket memberi Anda pustaka C++ modern untuk mengatur dan membuat koneksi soket tcp dan udp , dengan cara yang sepenuhnya agnostik platform. Sistem yang didukung adalah: Windows , distro Linux apa pun, dan MacOS .
Bagian Fitur merinci berbagai fitur MinimalSocket . Baca Penggunaan dan Contoh untuk melihat betapa mudahnya menggunakan MinimalSocket .
Ini adalah proyek CMake , periksa dukungan CMake untuk melihat bagaimana perpustakaan ini dapat diintegrasikan.
Ingatlah untuk meninggalkan bintang jika Anda merasa perpustakaan ini berguna.
Belum meninggalkan bintang ? Lakukan sekarang ;)!
MinimalSocket memungkinkan Anda membangun dan mengatur koneksi tcp dan udp . Pesan dapat dikirim dan diterima baik dalam buffer byte atau string. Faktanya, ini adalah satu-satunya kemampuan yang Anda perlukan untuk sebuah soket, karena pesan yang lebih kompleks dapat diserialisasikan ke dalam atau diinternalisasikan dari buffer byte, antara lain dengan menggunakan pendekatan seperti Google Protocol Buffers atau NanoPb.
Ini adalah karakteristik MinimalSocket yang paling menonjol :
Tabel ini merangkum perbedaan antara perilaku pemblokiran dan non pemblokiran pada soket yang dapat dibuat menggunakan MinimalSocket :
| Perilaku Memblokir, penelepon diblokir hingga selesai atau batas waktu tercapai (jika ditentukan) | Perilaku Tanpa Pemblokiran, fungsi segera kembali | |
|---|---|---|
| menerima klien baru (hanya tcp) | thread pemanggil diserap sampai klien baru benar-benar meminta untuk terhubung atau batas waktu tercapai (jika ada yang ditentukan) | jika permintaan koneksi dari klien sudah dimasukkan dalam antrean sebelum memanggil fungsi terima, pengendali koneksi baru akan dikembalikan, jika tidak maka nullopt akan dikembalikan. |
| menerima pesan baru (tcp dan udp) | thread pemanggil diserap sampai pesan baru dikirim ke soket atau batas waktu tercapai (jika ada yang ditentukan) | jika pesan telah dikirim dan sudah dimasukkan ke dalam antrian di buffer soket sebelum memanggil fungsi terima, pesan itu akan dikembalikan, jika tidak, pesan kosong akan dikembalikan. |
| kirim pesan baru (tcp dan udp) | Jika buffer soket tidak penuh dan seluruhnya dapat menampung pesan yang akan dikirim, pesan tersebut sebenarnya ditulis dalam buffer dan fungsinya kembali hampir seketika. Sebaliknya, thread pemanggil diserap sampai ruang di buffer habis (saat pesan dikonsumsi dari sisi lain) dan setelah itu pesan benar-benar ditulis dan fungsinya selesai. | Jika ada cukup ruang di buffer soket, pesan ditulis dan fungsinya kembali. Sebaliknya, fungsi akan segera kembali tanpa benar-benar mengirim pesan (pengiriman dapat dicoba lagi nanti) |
Belum meninggalkan bintang ? Lakukan sekarang ;)!
Untuk membuat server tcp pemblokiran klasik, Anda hanya perlu membuat objek tcp::TcpServer :
# include < MinimalSocket/tcp/TcpServer.h >
MinimalSocket::Port port = 15768 ; // the port to bind
MinimalSocket::tcp::TcpServer< true > tcp_server (
port, MinimalSocket::AddressFamily::IP_V4);buka:
// open the server: binds the port and start to listen on the port
bool success = tcp_server.open();dan sekarang Anda siap menerima klien baru:
// accepts the next client that will ask the connection
MinimalSocket::tcp::TcpConnectionBlocking accepted_connection =
tcp_server.acceptNewClient(); // blocking till a client actually asks the
// connectionAnda sekarang dapat bertukar pesan dengan klien yang diterima hanya dengan melakukan ini:
// 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 " );Jika Anda memerlukan server non-pemblokiran, Anda dapat membuatnya dengan cara serupa:
MinimalSocket::Port port = 15768 ; // the port to bind
MinimalSocket::tcp::TcpServer< false > tcp_server (
port, MinimalSocket::AddressFamily::IP_V4);
tcp_server.open();Versi server ini tidak akan memblokir, artinya fungsi terima akan segera kembali:
// 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();Perhatikan bahwa meskipun server itu sendiri tidak memblokir, pengendali klien yang akhirnya diterima juga memblokir. Anda juga dapat mengubahnya menjadi soket non-pemblokiran, dengan mentransfer soket ke pengendali non-pemblokiran:
MinimalSocket::tcp::TcpConnectionNonBlocking accepted_connection_nn_block =
maybe_accepted_connection-> turnToNonBlocking ();Untuk membuat klien tcp Anda hanya perlu membuat objek tcp::TcpClient :
# 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});buka:
// 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 establishedAnda sekarang dapat menerima dan mengirim informasi dengan server jarak jauh hanya dengan melakukan ini:
// 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);Jika Anda memerlukan klien yang tidak memblokir, Anda dapat membuatnya dan menggunakannya dengan cara yang sama:
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);Untuk membuat soket udp normal, Anda hanya perlu membuat objek udp::Udp :
# include < MinimalSocket/udp/UdpSocket.h >
MinimalSocket::Port this_socket_port = 15768 ;
MinimalSocket::udp::Udp< true > udp_socket (this_socket_port,
MinimalSocket::AddressFamily::IP_V6);buka:
// Open the server. This will bind the specified port.
bool success = udp_socket.open();Anda sekarang dapat menerima dan mengirim informasi dengan soket udp lainnya:
// 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;Anda juga dapat memutuskan untuk "menghubungkan" soket udp yang terbuka ke alamat tertentu. Berhati-hatilah karena ini berarti pesan yang masuk dari rekan lain akan disaring, karena soket udp tidak berorientasi koneksi:
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)Sekarang Anda dapat mengirim dan menerima data tanpa harus menentukan penerima/pengirim:
// 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 " );Anda juga dapat membuat dan menggunakan soket udp yang tidak memblokir:
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);Belum meninggalkan bintang ? Lakukan sekarang ;)!
Contoh penggunaan tentang soket tcp dapat ditemukan di sini, sedangkan contoh udp dibahas di sini.
PERHATIAN!!! Eksekusi Sampel mungkin diblokir pertama kali oleh firewall Anda: atur firewall Anda dengan benar atau jalankan sampel dengan hak administrator
Belum meninggalkan bintang ? Lakukan sekarang ;)!
Untuk menggunakan perpustakaan ini Anda dapat mengandalkan CMake. Lebih tepatnya, Anda dapat mengambil paket ini dan menautkan ke perpustakaan MinimalSocket :
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)lalu tautkan ke perpustakaan MinimalSocket :
target_link_libraries ( ${TARGET_NAME}
MinimalSocket
)Semua modul khusus sistem disertakan secara internal dan tidak diekspos. Selain itu, di Windows , wsock32 dan ws2_32 ditautkan secara pribadi dan Anda tidak perlu menautkannya lagi saat menggunakan MinimalSocket .
