open_source / socket-cpp

Browse Code »

Commit 48b4c725c9739b3959576d5f9043d2fa1338445a

Authored by Peter M. Groen 2022-04-19 00:20:52 +0200

0 parents

Setting up Socket-pp

Inline Side-by-side

Showing 68 changed files with 7940 additions and 0 deletions

CMakeLists.txt 0 → 100644

View file @48b4c72

		1	+++ a/CMakeLists.txt
		1	+cmake_minmum_required(VERSION 3.20)
		2	+project(osdev-socket-cpp)
		3	+
		4	+LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
		5	+
		6	+# ===========================================================================
		7	+# == Include build information
		8	+include(osdevversion)
		9	+include(projectheader)
		10	+
		11	+project_header(osdev-socket-cpp)
		12	+
		13	+include(compiler)
		14	+
		15	+add_subdirectory(src)
		16	+add_subdirectory(examples)
		17	+add_subdirectory(tests)

examples/linux/canrecv.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/linux/canrecv.cpp
		1	+// canrecv.cpp
		2	+//
		3	+// Linux SoxketCAN reader example.
		4	+//
		5	+//
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2021 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+
		40	+#include <iostream>
		41	+#include <iomanip>
		42	+#include <string>
		43	+#include <chrono>
		44	+#include <thread>
		45	+#include "sockpp/can_socket.h"
		46	+#include "sockpp/can_frame.h"
		47	+#include "sockpp/version.h"
		48	+
		49	+#include <net/if.h>
		50	+#include <sys/ioctl.h>
		51	+
		52	+using namespace std;
		53	+
		54	+// The clock to use to get time and pace the app.
		55	+using sysclock = chrono::system_clock;
		56	+
		57	+// --------------------------------------------------------------------------
		58	+
		59	+int main(int argc, char* argv[])
		60	+{
		61	+ cout << "Sample SocketCAN writer for 'sockpp' "
		62	+ << sockpp::SOCKPP_VERSION << endl;
		63	+
		64	+ string canIface = (argc > 1) ? argv[1] : "can0";
		65	+ canid_t canID = (argc > 2) ? atoi(argv[2]) : 0x20;
		66	+
		67	+ sockpp::socket_initializer sockInit;
		68	+
		69	+ sockpp::can_address addr(canIface);
		70	+ sockpp::can_socket sock(addr);
		71	+
		72	+ if (!sock) {
		73	+ cerr << "Error binding to the CAN interface " << canIface << "\n\t"
		74	+ << sock.last_error_str() << endl;
		75	+ return 1;
		76	+ }
		77	+
		78	+ cout << "Created CAN socket on " << sock.address() << endl;
		79	+ time_t t = sysclock::to_time_t(sysclock::now());
		80	+
		81	+ cout.setf(ios::fixed, ios::floatfield);
		82	+ cout << setfill('0');
		83	+
		84	+ while (true) {
		85	+ sockpp::can_frame frame;
		86	+ sock.recv(&frame);
		87	+ auto t = sock.last_frame_timestamp();
		88	+
		89	+ cout << t << " ";
		90	+ for (uint8_t i=0; i<frame.can_dlc; ++i)
		91	+ cout << hex << uppercase << setw(2) << unsigned(frame.data[i]) << " ";
		92	+ cout << endl;
		93	+ }
		94	+
		95	+ return (!sock) ? 1 : 0;
		96	+}

examples/linux/cantime.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/linux/cantime.cpp
		1	+// cantime.cpp
		2	+//
		3	+// Linux SoxketCAN writer example.
		4	+//
		5	+// This writes the 1-sec, 32-bit, Linux time_t value to the CAN bus each
		6	+// time it ticks. This is a simple (though not overly precise) way to
		7	+// synchronize the time for nodes on the bus
		8	+//
		9	+// --------------------------------------------------------------------------
		10	+// This file is part of the "sockpp" C++ socket library.
		11	+//
		12	+// Copyright (c) 2021 Frank Pagliughi
		13	+// All rights reserved.
		14	+//
		15	+// Redistribution and use in source and binary forms, with or without
		16	+// modification, are permitted provided that the following conditions are
		17	+// met:
		18	+//
		19	+// 1. Redistributions of source code must retain the above copyright notice,
		20	+// this list of conditions and the following disclaimer.
		21	+//
		22	+// 2. Redistributions in binary form must reproduce the above copyright
		23	+// notice, this list of conditions and the following disclaimer in the
		24	+// documentation and/or other materials provided with the distribution.
		25	+//
		26	+// 3. Neither the name of the copyright holder nor the names of its
		27	+// contributors may be used to endorse or promote products derived from this
		28	+// software without specific prior written permission.
		29	+//
		30	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		31	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		32	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		33	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		34	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		35	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		36	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		37	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		38	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		39	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		40	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		41	+// --------------------------------------------------------------------------
		42	+
		43	+#include <iostream>
		44	+#include <string>
		45	+#include <chrono>
		46	+#include <thread>
		47	+#include "sockpp/can_socket.h"
		48	+#include "sockpp/can_frame.h"
		49	+#include "sockpp/version.h"
		50	+
		51	+#include <net/if.h>
		52	+#include <sys/ioctl.h>
		53	+
		54	+using namespace std;
		55	+
		56	+// The clock to use to get time and pace the app.
		57	+using sysclock = chrono::system_clock;
		58	+
		59	+// --------------------------------------------------------------------------
		60	+
		61	+int main(int argc, char* argv[])
		62	+{
		63	+ cout << "Sample SocketCAN writer for 'sockpp' "
		64	+ << sockpp::SOCKPP_VERSION << endl;
		65	+
		66	+ string canIface = (argc > 1) ? argv[1] : "can0";
		67	+ canid_t canID = (argc > 2) ? atoi(argv[2]) : 0x20;
		68	+
		69	+ sockpp::socket_initializer sockInit;
		70	+
		71	+ sockpp::can_address addr(canIface);
		72	+ sockpp::can_socket sock(addr);
		73	+
		74	+ if (!sock) {
		75	+ cerr << "Error binding to the CAN interface " << canIface << "\n\t"
		76	+ << sock.last_error_str() << endl;
		77	+ return 1;
		78	+ }
		79	+
		80	+ cout << "Created CAN socket on " << sock.address() << endl;
		81	+ time_t t = sysclock::to_time_t(sysclock::now());
		82	+
		83	+ while (true) {
		84	+ // Sleep until the clock ticks to the next second
		85	+ this_thread::sleep_until(sysclock::from_time_t(t+1));
		86	+
		87	+ // Re-read the time in case we fell behind
		88	+ t = sysclock::to_time_t(sysclock::now());
		89	+
		90	+ // Write the time to the CAN bus as a 32-bit int
		91	+ auto nt = uint32_t(t);
		92	+
		93	+ sockpp::can_frame frame { canID, &nt, sizeof(nt) };
		94	+ sock.send(frame);
		95	+ }
		96	+
		97	+ return (!sock) ? 1 : 0;
		98	+}

examples/tcp/tcp6echo.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcp6echo.cpp
		1	+// tcpecho.cpp
		2	+//
		3	+// Simple TCP echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2014-2017 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/tcp6_connector.h"
		42	+#include "sockpp/version.h"
		43	+
		44	+using namespace std;
		45	+using namespace std::chrono;
		46	+
		47	+// --------------------------------------------------------------------------
		48	+
		49	+int main(int argc, char* argv[])
		50	+{
		51	+ cout << "Sample IPv6 TCP echo client for 'sockpp' "
		52	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		53	+
		54	+ std::string host = (argc > 1) ? argv[1] : "::1";
		55	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		56	+
		57	+ sockpp::socket_initializer sockInit;
		58	+
		59	+ // Implicitly creates an inet6_address from {host,port}
		60	+ // and then tries the connection.
		61	+
		62	+ sockpp::tcp6_connector conn({host, port});
		63	+ if (!conn) {
		64	+ cerr << "Error connecting to server at "
		65	+ << sockpp::inet6_address(host, port)
		66	+ << "\n\t" << conn.last_error_str() << endl;
		67	+ return 1;
		68	+ }
		69	+
		70	+ cout << "Created a connection from " << conn.address() << endl;
		71	+
		72	+ // Set a timeout for the responses
		73	+ if (!conn.read_timeout(seconds(5))) {
		74	+ cerr << "Error setting timeout on TCP stream: "
		75	+ << conn.last_error_str() << endl;
		76	+ }
		77	+
		78	+ string s, sret;
		79	+ while (getline(cin, s) && !s.empty()) {
		80	+ if (conn.write(s) != ssize_t(s.length())) {
		81	+ cerr << "Error writing to the TCP stream: "
		82	+ << conn.last_error_str() << endl;
		83	+ break;
		84	+ }
		85	+
		86	+ sret.resize(s.length());
		87	+ ssize_t n = conn.read_n(&sret[0], s.length());
		88	+
		89	+ if (n != ssize_t(s.length())) {
		90	+ cerr << "Error reading from TCP stream: "
		91	+ << conn.last_error_str() << endl;
		92	+ break;
		93	+ }
		94	+
		95	+ cout << sret << endl;
		96	+ }
		97	+
		98	+ return (!conn) ? 1 : 0;
		99	+}

examples/tcp/tcp6echosvr.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcp6echosvr.cpp
		1	+// tcp6echosvr.cpp
		2	+//
		3	+// A multi-threaded TCP v6 echo server for sockpp library.
		4	+// This is a simple thread-per-connection TCP server for IPv6.
		5	+//
		6	+// USAGE:
		7	+// tcp6echosvr [port]
		8	+//
		9	+// --------------------------------------------------------------------------
		10	+// This file is part of the "sockpp" C++ socket library.
		11	+//
		12	+// Copyright (c) 2019 Frank Pagliughi
		13	+// All rights reserved.
		14	+//
		15	+// Redistribution and use in source and binary forms, with or without
		16	+// modification, are permitted provided that the following conditions are
		17	+// met:
		18	+//
		19	+// 1. Redistributions of source code must retain the above copyright notice,
		20	+// this list of conditions and the following disclaimer.
		21	+//
		22	+// 2. Redistributions in binary form must reproduce the above copyright
		23	+// notice, this list of conditions and the following disclaimer in the
		24	+// documentation and/or other materials provided with the distribution.
		25	+//
		26	+// 3. Neither the name of the copyright holder nor the names of its
		27	+// contributors may be used to endorse or promote products derived from this
		28	+// software without specific prior written permission.
		29	+//
		30	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		31	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		32	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		33	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		34	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		35	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		36	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		37	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		38	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		39	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		40	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		41	+// --------------------------------------------------------------------------
		42	+
		43	+#include <iostream>
		44	+#include <thread>
		45	+#include "sockpp/tcp6_acceptor.h"
		46	+#include "sockpp/version.h"
		47	+
		48	+using namespace std;
		49	+
		50	+// --------------------------------------------------------------------------
		51	+// The thread function. This is run in a separate thread for each socket.
		52	+// Ownership of the socket object is transferred to the thread, so when this
		53	+// function exits, the socket is automatically closed.
		54	+
		55	+void run_echo(sockpp::tcp6_socket sock)
		56	+{
		57	+ ssize_t n;
		58	+ char buf[512];
		59	+
		60	+ while ((n = sock.read(buf, sizeof(buf))) > 0)
		61	+ sock.write_n(buf, n);
		62	+
		63	+ cout << "Connection closed from " << sock.peer_address() << endl;
		64	+}
		65	+
		66	+// --------------------------------------------------------------------------
		67	+// The main thread runs the TCP port acceptor. Each time a connection is
		68	+// made, a new thread is spawned to handle it, leaving this main thread to
		69	+// immediately wait for the next connection.
		70	+
		71	+int main(int argc, char* argv[])
		72	+{
		73	+ cout << "Sample IPv6 TCP echo server for 'sockpp' "
		74	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		75	+
		76	+ in_port_t port = (argc > 1) ? atoi(argv[1]) : 12345;
		77	+
		78	+ sockpp::socket_initializer sockInit;
		79	+ sockpp::tcp6_acceptor acc(port);
		80	+
		81	+ if (!acc) {
		82	+ cerr << "Error creating the acceptor: " << acc.last_error_str() << endl;
		83	+ return 1;
		84	+ }
		85	+ cout << "Awaiting connections on port " << port << "..." << endl;
		86	+
		87	+ while (true) {
		88	+ sockpp::inet6_address peer;
		89	+
		90	+ // Accept a new client connection
		91	+ sockpp::tcp6_socket sock = acc.accept(&peer);
		92	+ cout << "Received a connection request from " << peer << endl;
		93	+
		94	+ if (!sock) {
		95	+ cerr << "Error accepting incoming connection: "
		96	+ << acc.last_error_str() << endl;
		97	+ }
		98	+ else {
		99	+ // Create a thread and transfer the new stream to it.
		100	+ thread thr(run_echo, std::move(sock));
		101	+ thr.detach();
		102	+ }
		103	+ }
		104	+
		105	+ return 0;
		106	+}
		107	+
		108	+
		109	+

examples/tcp/tcpecho.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcpecho.cpp
		1	+// tcpecho.cpp
		2	+//
		3	+// Simple TCP echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2014-2017 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/tcp_connector.h"
		42	+#include "sockpp/version.h"
		43	+
		44	+using namespace std;
		45	+using namespace std::chrono;
		46	+
		47	+int main(int argc, char* argv[])
		48	+{
		49	+ cout << "Sample TCP echo client for 'sockpp' "
		50	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		51	+
		52	+ string host = (argc > 1) ? argv[1] : "localhost";
		53	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		54	+
		55	+ sockpp::socket_initializer sockInit;
		56	+
		57	+ // Implicitly creates an inet_address from {host,port}
		58	+ // and then tries the connection.
		59	+
		60	+ sockpp::tcp_connector conn({host, port});
		61	+ if (!conn) {
		62	+ cerr << "Error connecting to server at "
		63	+ << sockpp::inet_address(host, port)
		64	+ << "\n\t" << conn.last_error_str() << endl;
		65	+ return 1;
		66	+ }
		67	+
		68	+ cout << "Created a connection from " << conn.address() << endl;
		69	+
		70	+ // Set a timeout for the responses
		71	+ if (!conn.read_timeout(seconds(5))) {
		72	+ cerr << "Error setting timeout on TCP stream: "
		73	+ << conn.last_error_str() << endl;
		74	+ }
		75	+
		76	+ string s, sret;
		77	+ while (getline(cin, s) && !s.empty()) {
		78	+ if (conn.write(s) != ssize_t(s.length())) {
		79	+ cerr << "Error writing to the TCP stream: "
		80	+ << conn.last_error_str() << endl;
		81	+ break;
		82	+ }
		83	+
		84	+ sret.resize(s.length());
		85	+ ssize_t n = conn.read_n(&sret[0], s.length());
		86	+
		87	+ if (n != ssize_t(s.length())) {
		88	+ cerr << "Error reading from TCP stream: "
		89	+ << conn.last_error_str() << endl;
		90	+ break;
		91	+ }
		92	+
		93	+ cout << sret << endl;
		94	+ }
		95	+
		96	+ return (!conn) ? 1 : 0;
		97	+}

examples/tcp/tcpechomt.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcpechomt.cpp
		1	+// tcpechomt.cpp
		2	+//
		3	+// TCP echo client that uses separate read and write threads.
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2014-2017 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include <thread>
		42	+#include "sockpp/tcp_connector.h"
		43	+#include "sockpp/version.h"
		44	+
		45	+using namespace std;
		46	+
		47	+// --------------------------------------------------------------------------
		48	+// The read thread will run independently, retrieving packets from the
		49	+// server and writing them to the console. When the main (write) thread
		50	+// shuts down the socket, we exit.
		51	+
		52	+void read_thr(sockpp::tcp_socket rdSock)
		53	+{
		54	+ char buf[512];
		55	+ ssize_t n;
		56	+
		57	+ while ((n = rdSock.read(buf, sizeof(buf))) > 0) {
		58	+ cout.write(buf, n);
		59	+ cout << endl;
		60	+ }
		61	+
		62	+ if (n < 0) {
		63	+ cout << "Read error [" << rdSock.last_error() << "]: "
		64	+ << rdSock.last_error_str() << endl;
		65	+ }
		66	+ rdSock.shutdown();
		67	+}
		68	+
		69	+// --------------------------------------------------------------------------
		70	+
		71	+int main(int argc, char* argv[])
		72	+{
		73	+ cout << "Sample multi-threaded TCP echo client for 'sockpp' "
		74	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		75	+
		76	+ string host = (argc > 1) ? argv[1] : "localhost";
		77	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		78	+
		79	+ sockpp::socket_initializer sockInit;
		80	+
		81	+ // Implicitly creates an inet_address from {host,port}
		82	+ // and then tries the connection.
		83	+
		84	+ sockpp::tcp_connector conn({host, port});
		85	+ if (!conn) {
		86	+ cerr << "Error connecting to server at "
		87	+ << sockpp::inet_address(host, port)
		88	+ << "\n\t" << conn.last_error_str() << endl;
		89	+ return 1;
		90	+ }
		91	+
		92	+ cout << "Created a connection from " << conn.address() << endl;
		93	+
		94	+ // We create a read thread and send it a clone (dup) of the
		95	+ // connector socket.
		96	+
		97	+ std::thread rdThr(read_thr, std::move(conn.clone()));
		98	+
		99	+ // The write loop get user input and writes it to the socket.
		100	+
		101	+ string s, sret;
		102	+ while (getline(cin, s) && !s.empty()) {
		103	+ if (conn.write(s) != (int) s.length()) {
		104	+ if (conn.last_error() == EPIPE) {
		105	+ cerr << "It appears that the socket was closed." << endl;
		106	+ }
		107	+ else {
		108	+ cerr << "Error writing to the TCP stream ["
		109	+ << conn.last_error() << "]: "
		110	+ << conn.last_error_str() << endl;
		111	+ }
		112	+ break;
		113	+ }
		114	+ }
		115	+ int ret = !conn ? 1 : 0;
		116	+
		117	+ // Shutting down the socket will cause the read thread to exit.
		118	+ // We wait for it to exit before we leave the app.
		119	+
		120	+ conn.shutdown(SHUT_WR);
		121	+ rdThr.join();
		122	+
		123	+ return ret;
		124	+}

examples/tcp/tcpechosvr.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcpechosvr.cpp
		1	+// tcpechosvr.cpp
		2	+//
		3	+// A multi-threaded TCP echo server for sockpp library.
		4	+// This is a simple thread-per-connection TCP server.
		5	+//
		6	+// USAGE:
		7	+// tcpechosvr [port]
		8	+//
		9	+// --------------------------------------------------------------------------
		10	+// This file is part of the "sockpp" C++ socket library.
		11	+//
		12	+// Copyright (c) 2014-2017 Frank Pagliughi
		13	+// All rights reserved.
		14	+//
		15	+// Redistribution and use in source and binary forms, with or without
		16	+// modification, are permitted provided that the following conditions are
		17	+// met:
		18	+//
		19	+// 1. Redistributions of source code must retain the above copyright notice,
		20	+// this list of conditions and the following disclaimer.
		21	+//
		22	+// 2. Redistributions in binary form must reproduce the above copyright
		23	+// notice, this list of conditions and the following disclaimer in the
		24	+// documentation and/or other materials provided with the distribution.
		25	+//
		26	+// 3. Neither the name of the copyright holder nor the names of its
		27	+// contributors may be used to endorse or promote products derived from this
		28	+// software without specific prior written permission.
		29	+//
		30	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		31	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		32	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		33	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		34	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		35	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		36	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		37	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		38	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		39	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		40	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		41	+// --------------------------------------------------------------------------
		42	+
		43	+#include <iostream>
		44	+#include <thread>
		45	+#include "sockpp/tcp_acceptor.h"
		46	+#include "sockpp/version.h"
		47	+
		48	+using namespace std;
		49	+
		50	+// --------------------------------------------------------------------------
		51	+// The thread function. This is run in a separate thread for each socket.
		52	+// Ownership of the socket object is transferred to the thread, so when this
		53	+// function exits, the socket is automatically closed.
		54	+
		55	+void run_echo(sockpp::tcp_socket sock)
		56	+{
		57	+ ssize_t n;
		58	+ char buf[512];
		59	+
		60	+ while ((n = sock.read(buf, sizeof(buf))) > 0)
		61	+ sock.write_n(buf, n);
		62	+
		63	+ cout << "Connection closed from " << sock.peer_address() << endl;
		64	+}
		65	+
		66	+// --------------------------------------------------------------------------
		67	+// The main thread runs the TCP port acceptor. Each time a connection is
		68	+// made, a new thread is spawned to handle it, leaving this main thread to
		69	+// immediately wait for the next connection.
		70	+
		71	+int main(int argc, char* argv[])
		72	+{
		73	+ cout << "Sample TCP echo server for 'sockpp' "
		74	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		75	+
		76	+ in_port_t port = (argc > 1) ? atoi(argv[1]) : 12345;
		77	+
		78	+ sockpp::socket_initializer sockInit;
		79	+
		80	+ sockpp::tcp_acceptor acc(port);
		81	+
		82	+ if (!acc) {
		83	+ cerr << "Error creating the acceptor: " << acc.last_error_str() << endl;
		84	+ return 1;
		85	+ }
		86	+ //cout << "Acceptor bound to address: " << acc.address() << endl;
		87	+ cout << "Awaiting connections on port " << port << "..." << endl;
		88	+
		89	+ while (true) {
		90	+ sockpp::inet_address peer;
		91	+
		92	+ // Accept a new client connection
		93	+ sockpp::tcp_socket sock = acc.accept(&peer);
		94	+ cout << "Received a connection request from " << peer << endl;
		95	+
		96	+ if (!sock) {
		97	+ cerr << "Error accepting incoming connection: "
		98	+ << acc.last_error_str() << endl;
		99	+ }
		100	+ else {
		101	+ // Create a thread and transfer the new stream to it.
		102	+ thread thr(run_echo, std::move(sock));
		103	+ thr.detach();
		104	+ }
		105	+ }
		106	+
		107	+ return 0;
		108	+}
		109	+
		110	+
		111	+

examples/tcp/tcpechotest.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/tcp/tcpechotest.cpp
		1	+// tcpechotest.cpp
		2	+//
		3	+// TCP echo timing client.
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2020 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include <chrono>
		42	+#include <random>
		43	+#include "sockpp/tcp_connector.h"
		44	+#include "sockpp/version.h"
		45	+
		46	+using namespace std;
		47	+using namespace std::chrono;
		48	+
		49	+const size_t DFLT_N = 100000;
		50	+const size_t DFLT_SZ = 512;
		51	+
		52	+using fpsec = std::chrono::duration<double, std::chrono::seconds::period>;
		53	+
		54	+// --------------------------------------------------------------------------
		55	+
		56	+int main(int argc, char* argv[])
		57	+{
		58	+ cout << "Unix-domain echo timing test client for 'sockpp' "
		59	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		60	+
		61	+ string host = (argc > 1) ? argv[1] : "localhost";
		62	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		63	+
		64	+ size_t n = (argc > 3) ? size_t(atoll(argv[3])) : DFLT_N;
		65	+ size_t sz = (argc > 4) ? size_t(atoll(argv[4])) : DFLT_SZ;
		66	+
		67	+ sockpp::socket_initializer sockInit;
		68	+
		69	+ auto t_start = high_resolution_clock::now();
		70	+
		71	+
		72	+ sockpp::tcp_connector conn({host, port});
		73	+ if (!conn) {
		74	+ cerr << "Error connecting to server at "
		75	+ << sockpp::inet_address(host, port)
		76	+ << "\n\t" << conn.last_error_str() << endl;
		77	+ return 1;
		78	+ }
		79	+
		80	+ cout << "Created a connection from " << conn.address() << endl;
		81	+ cout << "Created a connection to " << conn.peer_address() << endl;
		82	+
		83	+ // Set a timeout for the responses
		84	+ if (!conn.read_timeout(seconds(2))) {
		85	+ cerr << "Error setting timeout on TCP stream: "
		86	+ << conn.last_error_str() << endl;
		87	+ }
		88	+ string s, sret;
		89	+
		90	+ random_device rd;
		91	+ mt19937 reng(rd());
		92	+ uniform_int_distribution<int> dist(0, 25);
		93	+
		94	+ for (size_t i=0; i<sz; ++i)
		95	+ s.push_back('a' + static_cast<char>(dist(reng)));
		96	+
		97	+ auto t_start_tx = high_resolution_clock::now();
		98	+
		99	+ for (size_t i=0; i<n; ++i) {
		100	+ if (conn.write(s) != (ssize_t) s.length()) {
		101	+ cerr << "Error writing to the UNIX stream" << endl;
		102	+ break;
		103	+ }
		104	+
		105	+ sret.resize(s.length());
		106	+ int n = conn.read_n(&sret[0], s.length());
		107	+
		108	+ if (n != (int) s.length()) {
		109	+ cerr << "Error reading from UNIX stream" << endl;
		110	+ break;
		111	+ }
		112	+ }
		113	+
		114	+ auto t_end = high_resolution_clock::now();
		115	+ cout << "Total time: " << fpsec(t_end - t_start).count() << "s" << endl;
		116	+
		117	+ auto t_tx = fpsec(t_end - t_start_tx).count();
		118	+ auto rate = size_t(n / t_tx);
		119	+ cout << "Transfer time: " << t_tx << "s\n "
		120	+ << rate << " msg/s" << endl;
		121	+
		122	+ return (!conn) ? 1 : 0;
		123	+}

examples/udp/udp6echo.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/udp/udp6echo.cpp
		1	+// udp6echo.cpp
		2	+//
		3	+// Simple UDP v6 echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2019 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/udp6_socket.h"
		42	+#include "sockpp/version.h"
		43	+
		44	+using namespace std;
		45	+
		46	+// --------------------------------------------------------------------------
		47	+
		48	+int main(int argc, char* argv[])
		49	+{
		50	+ cout << "Sample IPv6 UDP echo client for 'sockpp' "
		51	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		52	+
		53	+ string host = (argc > 1) ? argv[1] : "localhost";
		54	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		55	+
		56	+ sockpp::socket_initializer sockInit;
		57	+
		58	+ sockpp::udp6_socket sock;
		59	+
		60	+ if (!sock.connect(sockpp::inet6_address(host, port))) {
		61	+ cerr << "Error connecting to server at " << host << ":" << port
		62	+ << "\n\t" << sock.last_error_str() << endl;
		63	+ return 1;
		64	+ }
		65	+
		66	+ cout << "Created UDP socket at: " << sock.address() << endl;
		67	+
		68	+ string s, sret;
		69	+ while (getline(cin, s) && !s.empty()) {
		70	+ if (sock.send(s) != ssize_t(s.length())) {
		71	+ cerr << "Error writing to the UDP socket: "
		72	+ << sock.last_error_str() << endl;
		73	+ break;
		74	+ }
		75	+
		76	+ sret.resize(s.length());
		77	+ ssize_t n = sock.recv(&sret[0], s.length());
		78	+
		79	+ if (n != ssize_t(s.length())) {
		80	+ cerr << "Error reading from UDP socket: "
		81	+ << sock.last_error_str() << endl;
		82	+ break;
		83	+ }
		84	+
		85	+ cout << sret << endl;
		86	+ }
		87	+
		88	+ return (!sock) ? 1 : 0;
		89	+}

examples/udp/udpecho.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/udp/udpecho.cpp
		1	+// udpecho.cpp
		2	+//
		3	+// Simple UDP v4 echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2019 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/udp_socket.h"
		42	+#include "sockpp/version.h"
		43	+
		44	+using namespace std;
		45	+
		46	+// --------------------------------------------------------------------------
		47	+
		48	+int main(int argc, char* argv[])
		49	+{
		50	+ cout << "Sample UDP echo client for 'sockpp' "
		51	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		52	+
		53	+ string host = (argc > 1) ? argv[1] : "localhost";
		54	+ in_port_t port = (argc > 2) ? atoi(argv[2]) : 12345;
		55	+
		56	+ sockpp::socket_initializer sockInit;
		57	+
		58	+ sockpp::udp_socket sock;
		59	+
		60	+ if (!sock.connect(sockpp::inet_address(host, port))) {
		61	+ cerr << "Error connecting to server at " << host << ":" << port
		62	+ << "\n\t" << sock.last_error_str() << endl;
		63	+ return 1;
		64	+ }
		65	+
		66	+ cout << "Created UDP socket at: " << sock.address() << endl;
		67	+
		68	+ string s, sret;
		69	+ while (getline(cin, s) && !s.empty()) {
		70	+ if (sock.send(s) != ssize_t(s.length())) {
		71	+ cerr << "Error writing to the UDP socket: "
		72	+ << sock.last_error_str() << endl;
		73	+ break;
		74	+ }
		75	+
		76	+ sret.resize(s.length());
		77	+ ssize_t n = sock.recv(&sret[0], s.length());
		78	+
		79	+ if (n != ssize_t(s.length())) {
		80	+ cerr << "Error reading from UDP socket: "
		81	+ << sock.last_error_str() << endl;
		82	+ break;
		83	+ }
		84	+
		85	+ cout << sret << endl;
		86	+ }
		87	+
		88	+ return (!sock) ? 1 : 0;
		89	+}

examples/udp/udpechosvr.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/udp/udpechosvr.cpp
		1	+// udpechosvr.cpp
		2	+//
		3	+// A simple multi-threaded TCP/IP UDP echo server for sockpp library.
		4	+//
		5	+// This runs a UDP echo server for both IPv4 and IPv6, each in a separate
		6	+// thread. They both use the same port number, either as provided by the user
		7	+// on the command line, or defaulting to 12345.
		8	+//
		9	+// USAGE:
		10	+// uspechosvr [port]
		11	+//
		12	+// You can test with a netcat client, like:
		13	+// $ nc -u localhost 12345 # IPv4
		14	+// $ nc -6u localhost 12345 # IPv6
		15	+//
		16	+// --------------------------------------------------------------------------
		17	+// This file is part of the "sockpp" C++ socket library.
		18	+//
		19	+// Copyright (c) 2019 Frank Pagliughi
		20	+// All rights reserved.
		21	+//
		22	+// Redistribution and use in source and binary forms, with or without
		23	+// modification, are permitted provided that the following conditions are
		24	+// met:
		25	+//
		26	+// 1. Redistributions of source code must retain the above copyright notice,
		27	+// this list of conditions and the following disclaimer.
		28	+//
		29	+// 2. Redistributions in binary form must reproduce the above copyright
		30	+// notice, this list of conditions and the following disclaimer in the
		31	+// documentation and/or other materials provided with the distribution.
		32	+//
		33	+// 3. Neither the name of the copyright holder nor the names of its
		34	+// contributors may be used to endorse or promote products derived from this
		35	+// software without specific prior written permission.
		36	+//
		37	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		38	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		39	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		40	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		41	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		42	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		43	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		44	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		45	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		46	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		47	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		48	+// --------------------------------------------------------------------------
		49	+
		50	+#include <iostream>
		51	+#include <thread>
		52	+#include "sockpp/udp_socket.h"
		53	+#include "sockpp/udp6_socket.h"
		54	+#include "sockpp/version.h"
		55	+
		56	+using namespace std;
		57	+
		58	+// --------------------------------------------------------------------------
		59	+// The thread function. This is run in a separate thread for each socket.
		60	+// Ownership of the socket object is transferred to the thread, so when this
		61	+// function exits, the socket is automatically closed.
		62	+
		63	+template <typename UDPSOCK>
		64	+void run_echo(UDPSOCK sock)
		65	+{
		66	+ ssize_t n;
		67	+ char buf[512];
		68	+
		69	+ // Each UDP socket type knows its address type as `addr_t`
		70	+ typename UDPSOCK::addr_t srcAddr;
		71	+
		72	+ // Read some data, also getting the address of the sender,
		73	+ // then just send it back.
		74	+ while ((n = sock.recv_from(buf, sizeof(buf), &srcAddr)) > 0)
		75	+ sock.send_to(buf, n, srcAddr);
		76	+}
		77	+
		78	+// --------------------------------------------------------------------------
		79	+// The main thread creates the two UDP sockets (one each for IPv4 and IPv6),
		80	+// and then starts them running the echo function each in a separate thread.
		81	+
		82	+int main(int argc, char* argv[])
		83	+{
		84	+ cout << "Sample UDP echo server for 'sockpp' "
		85	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		86	+
		87	+ in_port_t port = (argc > 1) ? atoi(argv[1]) : 12345;
		88	+
		89	+ sockpp::socket_initializer sockInit;
		90	+
		91	+ sockpp::udp_socket udpsock;
		92	+ if (!udpsock) {
		93	+ cerr << "Error creating the UDP v4 socket: " << udpsock.last_error_str() << endl;
		94	+ return 1;
		95	+ }
		96	+
		97	+ if (!udpsock.bind(sockpp::inet_address("localhost", port))) {
		98	+ cerr << "Error binding the UDP v4 socket: " << udpsock.last_error_str() << endl;
		99	+ return 1;
		100	+ }
		101	+
		102	+ sockpp::udp6_socket udp6sock;
		103	+ if (!udp6sock) {
		104	+ cerr << "Error creating the UDP v6 socket: " << udp6sock.last_error_str() << endl;
		105	+ return 1;
		106	+ }
		107	+
		108	+ if (!udp6sock.bind(sockpp::inet6_address("localhost", port))) {
		109	+ cerr << "Error binding the UDP v6 socket: " << udp6sock.last_error_str() << endl;
		110	+ return 1;
		111	+ }
		112	+
		113	+ // Spin up a thread to run the IPv4 socket.
		114	+ thread thr(run_echo<sockpp::udp_socket>, std::move(udpsock));
		115	+ thr.detach();
		116	+
		117	+ // Run the IPv6 socket in this thread. (Call doesn't return)
		118	+ run_echo(std::move(udp6sock));
		119	+ return 0;
		120	+}
		121	+

examples/unix/undgramecho.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/unix/undgramecho.cpp
		1	+// udpecho.cpp
		2	+//
		3	+// Simple Unix-domain UDP echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2019 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/unix_dgram_socket.h"
		42	+
		43	+using namespace std;
		44	+
		45	+// --------------------------------------------------------------------------
		46	+
		47	+int main(int argc, char* argv[])
		48	+{
		49	+ sockpp::socket_initializer sockInit;
		50	+
		51	+ string cliAddr { "/tmp/undgramecho.sock" },
		52	+ svrAddr { "/tmp/undgramechosvr.sock" };
		53	+
		54	+ sockpp::unix_dgram_socket sock;
		55	+
		56	+ // A Unix-domain UDP client needs to bind to its own address
		57	+ // before it can send or receive packets
		58	+
		59	+ if (!sock.bind(sockpp::unix_address(cliAddr))) {
		60	+ cerr << "Error connecting to client address at '" << cliAddr << "'"
		61	+ << "\n\t" << sock.last_error_str() << endl;
		62	+ return 1;
		63	+ }
		64	+
		65	+ // "Connect" to the server address. This is a convenience to set the
		66	+ // default 'send_to' address, as there is no real connection.
		67	+
		68	+ if (!sock.connect(sockpp::unix_address(svrAddr))) {
		69	+ cerr << "Error connecting to server at '" << svrAddr << "'"
		70	+ << "\n\t" << sock.last_error_str() << endl;
		71	+ return 1;
		72	+ }
		73	+
		74	+ cout << "Created UDP socket at: " << sock.address() << endl;
		75	+
		76	+ string s, sret;
		77	+ while (getline(cin, s) && !s.empty()) {
		78	+ if (sock.send(s) != ssize_t(s.length())) {
		79	+ cerr << "Error writing to the UDP socket: "
		80	+ << sock.last_error_str() << endl;
		81	+ break;
		82	+ }
		83	+
		84	+ sret.resize(s.length());
		85	+ ssize_t n = sock.recv(&sret[0], s.length());
		86	+
		87	+ if (n != ssize_t(s.length())) {
		88	+ cerr << "Error reading from UDP socket: "
		89	+ << sock.last_error_str() << endl;
		90	+ break;
		91	+ }
		92	+
		93	+ cout << sret << endl;
		94	+ }
		95	+
		96	+ return (!sock) ? 1 : 0;
		97	+}

examples/unix/undgramechosvr.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/unix/undgramechosvr.cpp
		1	+// undgramechosvr.cpp
		2	+//
		3	+// A simple multi-threaded TCP/IP UDP echo server for sockpp library.
		4	+//
		5	+// This runs a UDP echo server for both IPv4 and IPv6, each in a separate
		6	+// thread. They both use the same port number, either as provided by the user
		7	+// on the command line, or defaulting to 12345.
		8	+//
		9	+// USAGE:
		10	+// undgramechosvr [port]
		11	+//
		12	+// You can test with a netcat client, like:
		13	+// $ nc -u localhost 12345 # IPv4
		14	+// $ nc -6u localhost 12345 # IPv6
		15	+//
		16	+// --------------------------------------------------------------------------
		17	+// This file is part of the "sockpp" C++ socket library.
		18	+//
		19	+// Copyright (c) 2019 Frank Pagliughi
		20	+// All rights reserved.
		21	+//
		22	+// Redistribution and use in source and binary forms, with or without
		23	+// modification, are permitted provided that the following conditions are
		24	+// met:
		25	+//
		26	+// 1. Redistributions of source code must retain the above copyright notice,
		27	+// this list of conditions and the following disclaimer.
		28	+//
		29	+// 2. Redistributions in binary form must reproduce the above copyright
		30	+// notice, this list of conditions and the following disclaimer in the
		31	+// documentation and/or other materials provided with the distribution.
		32	+//
		33	+// 3. Neither the name of the copyright holder nor the names of its
		34	+// contributors may be used to endorse or promote products derived from this
		35	+// software without specific prior written permission.
		36	+//
		37	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		38	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		39	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		40	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		41	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		42	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		43	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		44	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		45	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		46	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		47	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		48	+// --------------------------------------------------------------------------
		49	+
		50	+#include <iostream>
		51	+#include "sockpp/unix_dgram_socket.h"
		52	+#include "sockpp/version.h"
		53	+
		54	+using namespace std;
		55	+
		56	+// --------------------------------------------------------------------------
		57	+// The main thread creates the UDP socket, and then starts them running the
		58	+// echo service in a loop.
		59	+
		60	+int main(int argc, char* argv[])
		61	+{
		62	+ cout << "Sample Unix-domain datagram echo server for 'sockpp' "
		63	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		64	+
		65	+ sockpp::socket_initializer sockInit;
		66	+
		67	+ sockpp::unix_dgram_socket sock;
		68	+ if (!sock) {
		69	+ cerr << "Error creating the socket: " << sock.last_error_str() << endl;
		70	+ return 1;
		71	+ }
		72	+
		73	+ if (!sock.bind(sockpp::unix_address("/tmp/undgramechosvr.sock"))) {
		74	+ cerr << "Error binding the socket: " << sock.last_error_str() << endl;
		75	+ return 1;
		76	+ }
		77	+
		78	+ // Run the socket in this thread.
		79	+ ssize_t n;
		80	+ char buf[512];
		81	+
		82	+ sockpp::unix_address srcAddr;
		83	+
		84	+ cout << "Awaiting packets on: '" << sock.address() << "'" << endl;
		85	+
		86	+ // Read some data, also getting the address of the sender,
		87	+ // then just send it back.
		88	+ while ((n = sock.recv_from(buf, sizeof(buf), &srcAddr)) > 0)
		89	+ sock.send_to(buf, n, srcAddr);
		90	+
		91	+ return 0;
		92	+}
		93	+

examples/unix/unecho.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/unix/unecho.cpp
		1	+// unecho.cpp
		2	+//
		3	+// Simple Unix-domain echo client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2014-2017 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include "sockpp/unix_connector.h"
		42	+#include "sockpp/version.h"
		43	+
		44	+using namespace std;
		45	+
		46	+// --------------------------------------------------------------------------
		47	+
		48	+int main(int argc, char* argv[])
		49	+{
		50	+ cout << "Sample Unix-domain echo client for 'sockpp' "
		51	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		52	+
		53	+ string path = (argc > 1) ? argv[1] : "/tmp/unechosvr.sock";
		54	+
		55	+ sockpp::socket_initializer sockInit;
		56	+
		57	+ sockpp::unix_connector conn;
		58	+
		59	+ bool ok = conn.connect(sockpp::unix_address(path));
		60	+ if (!ok) {
		61	+ cerr << "Error connecting to UNIX socket at " << path
		62	+ << "\n\t" << conn.last_error_str() << endl;
		63	+ return 1;
		64	+ }
		65	+
		66	+ cout << "Created a connection to '" << conn.peer_address() << "'" << endl;
		67	+
		68	+ string s, sret;
		69	+ while (getline(cin, s) && !s.empty()) {
		70	+ if (conn.write(s) != (int) s.length()) {
		71	+ cerr << "Error writing to the UNIX stream" << endl;
		72	+ break;
		73	+ }
		74	+
		75	+ sret.resize(s.length());
		76	+ int n = conn.read_n(&sret[0], s.length());
		77	+
		78	+ if (n != (int) s.length()) {
		79	+ cerr << "Error reading from UNIX stream" << endl;
		80	+ break;
		81	+ }
		82	+
		83	+ cout << sret << endl;
		84	+ }
		85	+
		86	+ return (!conn) ? 1 : 0;
		87	+}

examples/unix/unechosvr.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/unix/unechosvr.cpp
		1	+// unechosvr.cpp
		2	+//
		3	+// A multi-threaded UNIX-domain echo server for sockpp library.
		4	+// This is a simple thread-per-connection UNIX server.
		5	+//
		6	+// USAGE:
		7	+// unechosvr [path]
		8	+//
		9	+// --------------------------------------------------------------------------
		10	+// This file is part of the "sockpp" C++ socket library.
		11	+//
		12	+// Copyright (c) 2014-2017 Frank Pagliughi
		13	+// All rights reserved.
		14	+//
		15	+// Redistribution and use in source and binary forms, with or without
		16	+// modification, are permitted provided that the following conditions are
		17	+// met:
		18	+//
		19	+// 1. Redistributions of source code must retain the above copyright notice,
		20	+// this list of conditions and the following disclaimer.
		21	+//
		22	+// 2. Redistributions in binary form must reproduce the above copyright
		23	+// notice, this list of conditions and the following disclaimer in the
		24	+// documentation and/or other materials provided with the distribution.
		25	+//
		26	+// 3. Neither the name of the copyright holder nor the names of its
		27	+// contributors may be used to endorse or promote products derived from this
		28	+// software without specific prior written permission.
		29	+//
		30	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		31	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		32	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		33	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		34	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		35	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		36	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		37	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		38	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		39	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		40	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		41	+// --------------------------------------------------------------------------
		42	+
		43	+#include <iostream>
		44	+#include <thread>
		45	+#include "sockpp/unix_acceptor.h"
		46	+#include "sockpp/version.h"
		47	+
		48	+using namespace std;
		49	+
		50	+// --------------------------------------------------------------------------
		51	+// The thread function. This is run in a separate thread for each socket.
		52	+// Ownership of the socket object is transferred to the thread, so when this
		53	+// function exits, the socket is automatically closed.
		54	+
		55	+void run_echo(sockpp::unix_socket sock)
		56	+{
		57	+ int n;
		58	+ char buf[512];
		59	+
		60	+ while ((n = sock.read(buf, sizeof(buf))) > 0)
		61	+ sock.write_n(buf, n);
		62	+
		63	+ cout << "Connection closed" << endl;
		64	+}
		65	+
		66	+// --------------------------------------------------------------------------
		67	+// The main thread runs the UNIX acceptor.
		68	+// Each time a connection is made, a new thread is spawned to handle it,
		69	+// leaving this main thread to immediately wait for the next connection.
		70	+
		71	+int main(int argc, char* argv[])
		72	+{
		73	+ cout << "Sample Unix-domain echo server for 'sockpp' "
		74	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		75	+
		76	+ string path = "/tmp/unechosvr.sock";
		77	+
		78	+ if (argc > 1) {
		79	+ path = argv[1];
		80	+ }
		81	+
		82	+ sockpp::socket_initializer sockInit;
		83	+ sockpp::unix_acceptor acc;
		84	+
		85	+ bool ok = acc.open(sockpp::unix_address(path));
		86	+
		87	+ if (!ok) {
		88	+ cerr << "Error creating the acceptor: " << acc.last_error_str() << endl;
		89	+ return 1;
		90	+ }
		91	+ cout << "Acceptor bound to address: '" << acc.address() << "'..." << endl;
		92	+
		93	+ while (true) {
		94	+ // Accept a new client connection
		95	+ auto sock = acc.accept();
		96	+ cout << "Received a connection" << endl;
		97	+
		98	+ if (!sock) {
		99	+ cerr << "Error accepting incoming connection: "
		100	+ << acc.last_error_str() << endl;
		101	+ }
		102	+ else {
		103	+ // Create a thread and transfer the new stream to it.
		104	+ thread thr(run_echo, std::move(sock));
		105	+ thr.detach();
		106	+ }
		107	+ }
		108	+
		109	+ return 0;
		110	+}
		111	+

examples/unix/unechotest.cpp 0 → 100644

View file @48b4c72

		1	+++ a/examples/unix/unechotest.cpp
		1	+// unechotest.cpp
		2	+//
		3	+// Unix-domain echo timing test client
		4	+//
		5	+// --------------------------------------------------------------------------
		6	+// This file is part of the "sockpp" C++ socket library.
		7	+//
		8	+// Copyright (c) 2020 Frank Pagliughi
		9	+// All rights reserved.
		10	+//
		11	+// Redistribution and use in source and binary forms, with or without
		12	+// modification, are permitted provided that the following conditions are
		13	+// met:
		14	+//
		15	+// 1. Redistributions of source code must retain the above copyright notice,
		16	+// this list of conditions and the following disclaimer.
		17	+//
		18	+// 2. Redistributions in binary form must reproduce the above copyright
		19	+// notice, this list of conditions and the following disclaimer in the
		20	+// documentation and/or other materials provided with the distribution.
		21	+//
		22	+// 3. Neither the name of the copyright holder nor the names of its
		23	+// contributors may be used to endorse or promote products derived from this
		24	+// software without specific prior written permission.
		25	+//
		26	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		27	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		28	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		29	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		30	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		31	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		32	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		33	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		34	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		35	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		36	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		37	+// --------------------------------------------------------------------------
		38	+
		39	+#include <iostream>
		40	+#include <string>
		41	+#include <chrono>
		42	+#include <random>
		43	+#include "sockpp/unix_connector.h"
		44	+#include "sockpp/version.h"
		45	+
		46	+using namespace std;
		47	+using namespace std::chrono;
		48	+
		49	+const size_t DFLT_N = 100000;
		50	+const size_t DFLT_SZ = 512;
		51	+
		52	+using fpsec = std::chrono::duration<double, std::chrono::seconds::period>;
		53	+
		54	+// --------------------------------------------------------------------------
		55	+
		56	+int main(int argc, char* argv[])
		57	+{
		58	+ cout << "Unix-domain echo timing test client for 'sockpp' "
		59	+ << sockpp::SOCKPP_VERSION << '\n' << endl;
		60	+
		61	+ string path = (argc > 1) ? argv[1] : "/tmp/unechosvr.sock";
		62	+ size_t n = (argc > 2) ? size_t(atoll(argv[2])) : DFLT_N;
		63	+ size_t sz = (argc > 3) ? size_t(atoll(argv[3])) : DFLT_SZ;
		64	+
		65	+ sockpp::socket_initializer sockInit;
		66	+
		67	+ auto t_start = high_resolution_clock::now();
		68	+ sockpp::unix_connector conn;
		69	+
		70	+ bool ok = conn.connect(sockpp::unix_address(path));
		71	+ if (!ok) {
		72	+ cerr << "Error connecting to UNIX socket at " << path
		73	+ << "\n\t" << conn.last_error_str() << endl;
		74	+ return 1;
		75	+ }
		76	+
		77	+ cout << "Created a connection to '" << conn.peer_address() << "'" << endl;
		78	+
		79	+ string s, sret;
		80	+
		81	+ random_device rd;
		82	+ mt19937 reng(rd());
		83	+ uniform_int_distribution<char> dist(0, 25);
		84	+
		85	+ for (size_t i=0; i<sz; ++i)
		86	+ s.push_back('a' + dist(reng));
		87	+
		88	+ auto t_start_tx = high_resolution_clock::now();
		89	+
		90	+ for (size_t i=0; i<n; ++i) {
		91	+ if (conn.write(s) != (ssize_t) s.length()) {
		92	+ cerr << "Error writing to the UNIX stream" << endl;
		93	+ break;
		94	+ }
		95	+
		96	+ sret.resize(s.length());
		97	+ int n = conn.read_n(&sret[0], s.length());
		98	+
		99	+ if (n != (int) s.length()) {
		100	+ cerr << "Error reading from UNIX stream" << endl;
		101	+ break;
		102	+ }
		103	+ }
		104	+
		105	+ auto t_end = high_resolution_clock::now();
		106	+ cout << "Total time: " << fpsec(t_end - t_start).count() << "s" << endl;
		107	+
		108	+ auto t_tx = fpsec(t_end - t_start_tx).count();
		109	+ auto rate = size_t(n / t_tx);
		110	+ cout << "Transfer time: " << t_tx << "s\n "
		111	+ << rate << " msg/s" << endl;
		112	+
		113	+ return (!conn) ? 1 : 0;
		114	+}

include/socket-cpp/acceptor.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/acceptor.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/inet_address.h"
		4	+#include "socket-cpp/stream_socket.h"
		5	+
		6	+namespace osdev {
		7	+namespace components {
		8	+namespace socket-cpp {
		9	+
		10	+/**
		11	+ * Class for creating a streaming server.
		12	+ * Objects of this class bind and listen on streaming ports for incoming
		13	+ * connections. Normally, a server thread creates one of these and blocks on
		14	+ * the call to accept incoming connections. The call to accept creates and
		15	+ * returns a @ref stream_socket which can then be used for the actual
		16	+ * communications.
		17	+ */
		18	+class acceptor : public socket
		19	+{
		20	+ /** The base class */
		21	+ using base = socket;
		22	+
		23	+ // Non-copyable
		24	+ acceptor(const acceptor&) = delete;
		25	+ acceptor& operator=(const acceptor&) = delete;
		26	+
		27	+protected:
		28	+ /** The default listener queue size. */
		29	+ static const int DFLT_QUE_SIZE = 4;
		30	+
		31	+ /**
		32	+ * Creates an underlying acceptor socket.
		33	+ * The acceptor uses a stream socket type, but for our purposes is not
		34	+ * classified (derived from) a streaming socket, since it doesn't
		35	+ * support read and write to the socket.
		36	+ * @param domain The communications domain (address family).
		37	+ * @return An OS handle to a stream socket.
		38	+ */
		39	+ static socket_t create_handle(int domain) {
		40	+ return stream_socket::create_handle(domain);
		41	+ }
		42	+
		43	+public:
		44	+ /**
		45	+ * Creates an unconnected acceptor.
		46	+ */
		47	+ acceptor() {}
		48	+ /**
		49	+ * Creates an acceptor from an existing OS socket
		50	+ * handle and claims ownership of the handle.
		51	+ * @param handle A socket handle from the operating system.
		52	+ */
		53	+ explicit acceptor(socket_t handle) : base(handle) {}
		54	+ /**
		55	+ * Creates an acceptor socket and starts it listening to the specified
		56	+ * address.
		57	+ * @param addr The address to which this server should be bound.
		58	+ * @param queSize The listener queue size.
		59	+ */
		60	+ acceptor(const sock_address& addr, int queSize=DFLT_QUE_SIZE) {
		61	+ open(addr, queSize);
		62	+ }
		63	+ /**
		64	+ * Move constructor.
		65	+ * Creates an acceptor by moving the other acceptor to this one.
		66	+ * @param acc Another acceptor
		67	+ */
		68	+ acceptor(acceptor&& acc) : base(std::move(acc)) {}
		69	+ /**
		70	+ * Creates an unbound acceptor socket with an open OS socket handle.
		71	+ * An application would need to manually bind and listen to this
		72	+ * acceptor to get incoming connections.
		73	+ * @param domain The communications domain (address family).
		74	+ * @return An open, but unbound acceptor socket.
		75	+ */
		76	+ static acceptor create(int domain);
		77	+ /**
		78	+ * Move assignment.
		79	+ * @param rhs The other socket to move into this one.
		80	+ * @return A reference to this object.
		81	+ */
		82	+ acceptor& operator=(acceptor&& rhs) {
		83	+ base::operator=(std::move(rhs));
		84	+ return *this;
		85	+ }
		86	+ /**
		87	+ * Sets the socket listening on the address to which it is bound.
		88	+ * @param queSize The listener queue size.
		89	+ * @return @em true on success, @em false on error
		90	+ */
		91	+ bool listen(int queSize=DFLT_QUE_SIZE) {
		92	+ return check_ret_bool(::listen(handle(), queSize));
		93	+ };
		94	+ /**
		95	+ * Opens the acceptor socket, binds it to the specified address, and starts
		96	+ * listening.
		97	+ * @param addr The address to which this server should be bound.
		98	+ * @param queSize The listener queue size.
		99	+ * @param reuseSock Whether the SO_REUSEPORT (or SO_REUSEADDR on Win32)
		100	+ * socket option should be used before binding and
		101	+ * listening.
		102	+ * @return @em true on success, @em false on error
		103	+ */
		104	+ bool open(const sock_address& addr, int queSize=DFLT_QUE_SIZE, bool reuseSock=true);
		105	+ /**
		106	+ * Accepts an incoming TCP connection and gets the address of the client.
		107	+ * @param clientAddr Pointer to the variable that will get the
		108	+ * address of a client when it connects.
		109	+ * @return A socket to the remote client.
		110	+ */
		111	+ stream_socket accept(sock_address* clientAddr=nullptr);
		112	+};
		113	+
		114	+
		115	+/**
		116	+ * Base template class for streaming servers of specific address families.
		117	+ * This is a base for creating socket acceptor classes for an individual
		118	+ * family. In most cases, all that is needed is a type definition specifying
		119	+ * which addresses type should be used to receive incoming connections,
		120	+ * like:
		121	+ * using tcp_acceptor = acceptor_tmpl<tcp_socket>;
		122	+ */
		123	+template <typename STREAM_SOCK, typename ADDR=typename STREAM_SOCK::addr_t>
		124	+class acceptor_tmpl : public acceptor
		125	+{
		126	+ /** The base class */
		127	+ using base = acceptor;
		128	+
		129	+ // Non-copyable
		130	+ acceptor_tmpl(const acceptor_tmpl&) =delete;
		131	+ acceptor_tmpl& operator=(const acceptor_tmpl&) =delete;
		132	+
		133	+public:
		134	+ /** The type of streaming socket from the acceptor. */
		135	+ using stream_sock_t = STREAM_SOCK;
		136	+ /** The type of address for the acceptor and streams. */
		137	+ using addr_t = ADDR;
		138	+
		139	+ /**
		140	+ * Creates an unconnected acceptor.
		141	+ */
		142	+ acceptor_tmpl() {}
		143	+ /**
		144	+ * Creates a acceptor and starts it listening on the specified address.
		145	+ * @param addr The TCP address on which to listen.
		146	+ * @param queSize The listener queue size.
		147	+ */
		148	+ acceptor_tmpl(const addr_t& addr, int queSize=DFLT_QUE_SIZE) {
		149	+ open(addr, queSize);
		150	+ }
		151	+ /**
		152	+ * Creates a acceptor and starts it listening on the specified port.
		153	+ * The acceptor binds to the specified port for any address on the local
		154	+ * host.
		155	+ * @param port The TCP port on which to listen.
		156	+ * @param queSize The listener queue size.
		157	+ */
		158	+ acceptor_tmpl(in_port_t port, int queSize=DFLT_QUE_SIZE) {
		159	+ open(port, queSize);
		160	+ }
		161	+ /**
		162	+ * Move constructor.
		163	+ * Creates an acceptor by moving the other acceptor to this one.
		164	+ * @param acc Another acceptor
		165	+ */
		166	+ acceptor_tmpl(acceptor_tmpl&& acc) : base(std::move(acc)) {}
		167	+ /**
		168	+ * Creates an unbound acceptor socket with an open OS socket handle.
		169	+ * An application would need to manually bind and listen to this
		170	+ * acceptor to get incoming connections.
		171	+ * @return An open, but unbound acceptor socket.
		172	+ */
		173	+ static acceptor_tmpl create() {
		174	+ return base::create(addr_t::ADDRESS_FAMILY);
		175	+ }
		176	+ /**
		177	+ * Move assignment.
		178	+ * @param rhs The other socket to move into this one.
		179	+ * @return A reference to this object.
		180	+ */
		181	+ acceptor_tmpl& operator=(acceptor_tmpl&& rhs) {
		182	+ base::operator=(std::move(rhs));
		183	+ return *this;
		184	+ }
		185	+ /**
		186	+ * Gets the local address to which we are bound.
		187	+ * @return The local address to which we are bound.
		188	+ */
		189	+ addr_t address() const { return addr_t(base::address()); }
		190	+ /**
		191	+ * Binds the socket to the specified address.
		192	+ * @param addr The address to which we get bound.
		193	+ * @return @em true on success, @em false on error
		194	+ */
		195	+ bool bind(const addr_t& addr) { return base::bind(addr); }
		196	+ /**
		197	+ * Opens the acceptor socket, binds it to the specified address, and starts
		198	+ * listening.
		199	+ * @param addr The address to which this server should be bound.
		200	+ * @param queSize The listener queue size.
		201	+ * @return @em true on success, @em false on error
		202	+ */
		203	+ bool open(const addr_t& addr, int queSize=DFLT_QUE_SIZE) {
		204	+ return base::open(addr, queSize);
		205	+ }
		206	+ /**
		207	+ * Opens the acceptor socket, binds the socket to all adapters and starts it
		208	+ * listening.
		209	+ * @param port The TCP port on which to listen.
		210	+ * @param queSize The listener queue size.
		211	+ * @return @em true on success, @em false on error
		212	+ */
		213	+ bool open(in_port_t port, int queSize=DFLT_QUE_SIZE) {
		214	+ return open(addr_t(port), queSize);
		215	+ }
		216	+ /**
		217	+ * Accepts an incoming connection and gets the address of the client.
		218	+ * @param clientAddr Pointer to the variable that will get the
		219	+ * address of a client when it connects.
		220	+ * @return A tcp_socket to the remote client.
		221	+ */
		222	+ stream_sock_t accept(addr_t* clientAddr=nullptr) {
		223	+ return stream_sock_t(base::accept(clientAddr));
		224	+ }
		225	+};
		226	+
		227	+} // End namespace socket-cpp
		228	+} // End namespace components
		229	+} // End namespace osdev
		230	+

include/socket-cpp/can_address.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/can_address.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/platform.h"
		4	+#include "socket-cpp/sock_address.h"
		5	+#include <iostream>
		6	+#include <string>
		7	+#include <cstring>
		8	+#include <sys/un.h>
		9	+
		10	+#include <linux/can.h>
		11	+
		12	+namespace osdev {
		13	+namespace components {
		14	+namespace socket-cpp {
		15	+
		16	+/**
		17	+ * Class that represents a Linux SocketCAN address.
		18	+ * This inherits from the CAN form of a socket address, @em sockaddr_can.
		19	+ */
		20	+class can_address : public sock_address
		21	+{
		22	+ /** The underlying C struct for SocketCAN addresses */
		23	+ sockaddr_can addr_;
		24	+
		25	+ /** The size of the underlying address struct, in bytes */
		26	+ static constexpr size_t SZ = sizeof(sockaddr_can);
		27	+
		28	+public:
		29	+ /** The address family for this type of address */
		30	+ static constexpr sa_family_t ADDRESS_FAMILY = AF_CAN;
		31	+
		32	+ /** Iface to use to indicate binding to all interfaces */
		33	+ static const unsigned ALL_IFACE = 0;
		34	+
		35	+ /**
		36	+ * Constructs an empty address.
		37	+ * The address is initialized to all zeroes.
		38	+ */
		39	+ can_address() : addr_() {}
		40	+ /**
		41	+ * Creates an address for binding to a specific CAN interface
		42	+ * @param ifindex The interface index to use. This must, obviously, be
		43	+ * an index to a CAN interface.
		44	+ */
		45	+ explicit can_address(unsigned ifindex);
		46	+ /**
		47	+ * Constructs an address for the specified CAN interface.
		48	+ * The interface might be "can0", "can1", "vcan0", etc.
		49	+ * @param iface The name of the CAN interface
		50	+ */
		51	+ can_address(const std::string& iface);
		52	+ /**
		53	+ * Constructs the address by copying the specified structure.
		54	+ * @param addr The generic address
		55	+ * @throws std::invalid_argument if the address is not a SocketCAN
		56	+ * address (i.e. family is not AF_CAN)
		57	+ */
		58	+ explicit can_address(const sockaddr& addr);
		59	+ /**
		60	+ * Constructs the address by copying the specified structure.
		61	+ * @param addr The other address
		62	+ */
		63	+ can_address(const sock_address& addr) {
		64	+ std::memcpy(&addr_, addr.sockaddr_ptr(), SZ);
		65	+ }
		66	+ /**
		67	+ * Constructs the address by copying the specified structure.
		68	+ * @param addr The other address
		69	+ * @throws std::invalid_argument if the address is not properly
		70	+ * initialized as a SocketCAN address (i.e. family is not
		71	+ * AF_CAN)
		72	+ */
		73	+ can_address(const sockaddr_can& addr) : addr_(addr) {}
		74	+ /**
		75	+ * Constructs the address by copying the specified address.
		76	+ * @param addr The other address
		77	+ */
		78	+ can_address(const can_address& addr) : addr_(addr.addr_) {}
		79	+ /**
		80	+ * Checks if the address is set to some value.
		81	+ * This doesn't attempt to determine if the address is valid, simply
		82	+ * that it's not all zero.
		83	+ * @return @em true if the address has been set, @em false otherwise.
		84	+ */
		85	+ bool is_set() const { return family() != AF_UNSPEC; }
		86	+ /**
		87	+ * Gets the name of the CAN interface to which this address refers.
		88	+ * @return The name of the CAN interface to which this address refers.
		89	+ */
		90	+ std::string iface() const;
		91	+ /**
		92	+ * Gets the size of the address structure.
		93	+ * Note: In this implementation, this should return sizeof(this) but
		94	+ * more convenient in some places, and the implementation might change
		95	+ * in the future, so it might be more compatible with future revisions
		96	+ * to use this call.
		97	+ * @return The size of the address structure.
		98	+ */
		99	+ socklen_t size() const override { return socklen_t(SZ); }
		100	+
		101	+ // TODO: Do we need a:
		102	+ // create(iface)
		103	+ // to mimic the inet_address behavior?
		104	+
		105	+ /**
		106	+ * Gets a pointer to this object cast to a const @em sockaddr.
		107	+ * @return A pointer to this object cast to a const @em sockaddr.
		108	+ */
		109	+ const sockaddr* sockaddr_ptr() const override {
		110	+ return reinterpret_cast<const sockaddr*>(&addr_);
		111	+ }
		112	+ /**
		113	+ * Gets a pointer to this object cast to a @em sockaddr.
		114	+ * @return A pointer to this object cast to a @em sockaddr.
		115	+ */
		116	+ sockaddr* sockaddr_ptr() override {
		117	+ return reinterpret_cast<sockaddr*>(&addr_);
		118	+ }
		119	+ /**
		120	+ * Gets a const pointer to this object cast to a @em sockaddr_can.
		121	+ * @return const sockaddr_can pointer to this object.
		122	+ */
		123	+ const sockaddr_can* sockaddr_can_ptr() const { return &addr_; }
		124	+ /**
		125	+ * Gets a pointer to this object cast to a @em sockaddr_can.
		126	+ * @return sockaddr_can pointer to this object.
		127	+ */
		128	+ sockaddr_can* sockaddr_can_ptr() { return &addr_; }
		129	+ /**
		130	+ * Gets a printable string for the address.
		131	+ * @return A string representation of the address in the form
		132	+ * "unix:<path>"
		133	+ */
		134	+ std::string to_string() const {
		135	+ return std::string("can:") + iface();
		136	+ }
		137	+};
		138	+
		139	+// --------------------------------------------------------------------------
		140	+
		141	+/**
		142	+ * Stream inserter for the address.
		143	+ * @param os The output stream
		144	+ * @param addr The address
		145	+ * @return A reference to the output stream.
		146	+ */
		147	+std::ostream& operator<<(std::ostream& os, const can_address& addr);
		148	+
		149	+} // End namespace socket-cpp
		150	+} // End namespace components
		151	+} // End namespace osdev

include/socket-cpp/can_frame.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/can_frame.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/platform.h"
		4	+#include <string>
		5	+#include <cstring>
		6	+//#include <sys/un.h>
		7	+#include <linux/can.h>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace socket-cpp {
		12	+
		13	+/**
		14	+ * Class that represents a Linux SocketCAN frame.
		15	+ * This inherits from the Linux CAN frame struct, just providing easier
		16	+ construction.
		17	+ */
		18	+class can_frame : public ::can_frame
		19	+{
		20	+ using base = ::can_frame;
		21	+
		22	+ /** The size of the underlying address struct, in bytes */
		23	+ static constexpr size_t SZ = sizeof(::can_frame);
		24	+
		25	+public:
		26	+ /**
		27	+ * Constructs an empty frame.
		28	+ * The frame is initialized to all zeroes.
		29	+ */
		30	+ can_frame() : base{} {}
		31	+ /**
		32	+ * Constructs a frame with the specified ID and data.
		33	+ * @param canID The CAN identifier for the frame
		34	+ * @param data The data field for the frame
		35	+ */
		36	+ can_frame(canid_t canID, const std::string& data)
		37	+ : can_frame{ canID, data.data(), data.length() } {}
		38	+ /**
		39	+ * Constructs a frame with the specified ID and data.
		40	+ * @param canID The CAN identifier for the frame
		41	+ * @param data The data field for the frame
		42	+ * @param n The number of bytes in the data field
		43	+ */
		44	+ can_frame(canid_t canID, const void* data, size_t n) : base{} {
		45	+ this->can_id = canID;
		46	+ this->can_dlc = n;
		47	+ ::memcpy(&this->data, data, n);
		48	+ }
		49	+};
		50	+
		51	+} // End namespace socket-cpp
		52	+} // End namespace components
		53	+} // End namespace osdev

include/socket-cpp/can_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/can_socket.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/datagram_socket.h"
		4	+#include "socket-cpp/can_address.h"
		5	+#include "socket-cpp/can_frame.h"
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace socket-cpp {
		10	+
		11	+/**
		12	+ * Socket type for Linux SocketCAN.
		13	+ *
		14	+ * Note that technically these are RAW sockets, not DGRAM. We can/should
		15	+ * organize the underlying hierarch to properly indicate this, but for
		16	+ * practical usge, it doesn't matter too MUCH.
		17	+ * The BCM CAN sockets are DGRAM sockets, but those aren't implemented yet.
		18	+ * It wouldn't take too much to add them, though.
		19	+ */
		20	+class can_socket : public datagram_socket
		21	+{
		22	+ /** The base class */
		23	+ using base = datagram_socket;
		24	+
		25	+ // Non-copyable
		26	+ can_socket(const can_socket&) =delete;
		27	+ can_socket& operator=(const can_socket&) =delete;
		28	+
		29	+ /**
		30	+ * We can't connect to a raw CAN socket;
		31	+ * we can only bind the address/iface.
		32	+ */
		33	+ bool connect(const sock_address&) =delete;
		34	+
		35	+protected:
		36	+ static socket_t create_handle(int type, int protocol) {
		37	+ return socket_t(::socket(PROTOCOL_FAMILY, type, protocol));
		38	+ }
		39	+
		40	+public:
		41	+ /**
		42	+ * The SocketCAN protocol family.
		43	+ * Note that AF_CAN == PF_CAN, which is used in many of the CAN
		44	+ * examples.
		45	+ */
		46	+ static const int PROTOCOL_FAMILY = AF_CAN;
		47	+
		48	+ /** The socket 'type' for communications semantics. */
		49	+ static constexpr int COMM_TYPE = SOCK_RAW;
		50	+
		51	+ /**
		52	+ * Creates an uninitialized CAN socket.
		53	+ */
		54	+ can_socket() {}
		55	+ /**
		56	+ * Creates a CAN socket from an existing OS socket handle and
		57	+ * claims ownership of the handle.
		58	+ * @param handle A socket handle from the operating system.
		59	+ */
		60	+ explicit can_socket(socket_t handle) : base(handle) {}
		61	+ /**
		62	+ * Creates a CAN socket and binds it to the address.
		63	+ * @param addr The address to bind.
		64	+ */
		65	+ explicit can_socket(const can_address& addr);
		66	+ /**
		67	+ * Move constructor.
		68	+ * @param other The other socket to move to this one
		69	+ */
		70	+ can_socket(can_socket&& other) : base(std::move(other)) {}
		71	+ /**
		72	+ * Move assignment.
		73	+ * @param rhs The other socket to move into this one.
		74	+ * @return A reference to this object.
		75	+ */
		76	+ can_socket& operator=(can_socket&& rhs) {
		77	+ base::operator=(std::move(rhs));
		78	+ return *this;
		79	+ }
		80	+
		81	+ /**
		82	+ * Gets the system time of the last frame read from the socket.
		83	+ * @return The system time of the last frame read from the socket with
		84	+ * microsecond precision.
		85	+ */
		86	+ std::chrono::system_clock::time_point last_frame_time();
		87	+ /**
		88	+ * Gets a floating point timestamp of the last frame read from the
		89	+ * socket.
		90	+ * This is the number of seconds since the Unix epoch (time_t), with
		91	+ * floating-point, microsecond precision.
		92	+ * @return A floating-point timestamp with microsecond precision.
		93	+ */
		94	+ double last_frame_timestamp();
		95	+
		96	+ // ----- I/O -----
		97	+
		98	+ /**
		99	+ * Sends a frame to the CAN interfacce at the specified address.
		100	+ * @param frame The CAN frame to send.
		101	+ * @param flags The flags. See send(2).
		102	+ * @param addr The remote destination of the data.
		103	+ * @return the number of bytes sent on success or, @em -1 on failure.
		104	+ */
		105	+ ssize_t send_to(const can_frame& frame, int flags, const can_address& addr) {
		106	+ return check_ret(
		107	+ ::sendto(handle(), &frame, sizeof(can_frame), flags,
		108	+ addr.sockaddr_ptr(), addr.size())
		109	+ );
		110	+ }
		111	+
		112	+ /**
		113	+ * Sends a frame to the CAN interface at the specified address.
		114	+ * @param frame The CAN frame to send.
		115	+ * @param addr The remote destination of the data.
		116	+ * @return the number of bytes sent on success or, @em -1 on failure.
		117	+ */
		118	+ ssize_t send_to(const can_frame& frame, const can_address& addr) {
		119	+ return check_ret(
		120	+ ::sendto(handle(), &frame, sizeof(can_frame), 0,
		121	+ addr.sockaddr_ptr(), addr.size())
		122	+ );
		123	+ }
		124	+ /**
		125	+ * Sends a frame to the CAN bus.
		126	+ * The socket should be bound before calling this.
		127	+ * @param frame The CAN frame to send.
		128	+ * @param flags The option bit flags. See send(2).
		129	+ * @return @em zero on success, @em -1 on failure.
		130	+ */
		131	+ ssize_t send(const can_frame& frame, int flags=0) {
		132	+ return check_ret(::send(handle(), &frame, sizeof(can_frame), flags));
		133	+ }
		134	+ /**
		135	+ * Receives a message from the CAN interface at the specified address.
		136	+ * @param frame CAN frame to get the incoming data.
		137	+ * @param flags The option bit flags. See send(2).
		138	+ * @param srcAddr Receives the address of the peer that sent the
		139	+ * message
		140	+ * @return The number of bytes read or @em -1 on error.
		141	+ */
		142	+ ssize_t recv_from(can_frame* frame, int flags, can_address* srcAddr=nullptr);
		143	+ /**
		144	+ * Receives a message on the socket.
		145	+ * @param frame CAN frame to get the incoming data.
		146	+ * @param flags The option bit flags. See send(2).
		147	+ * @return The number of bytes read or @em -1 on error.
		148	+ */
		149	+ ssize_t recv(can_frame* frame, int flags=0) {
		150	+ return check_ret(::recv(handle(), frame, sizeof(can_frame), flags));
		151	+ }
		152	+};
		153	+
		154	+} // End namespace socket-cpp
		155	+} // End namespace components
		156	+} // End namespace osdev

include/socket-cpp/connector.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/connector.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/stream_socket.h"
		4	+#include "socket-cpp/sock_address.h"
		5	+
		6	+namespace osdev {
		7	+namespace components {
		8	+namespace socket-cpp {
		9	+
		10	+/**
		11	+ * Class to create a client stream connection.
		12	+ * This is a base class for creating active, streaming sockets that initiate
		13	+ * connections to a server. It can be used to derive classes that implement
		14	+ * TCP on IPv4 or IPv6.
		15	+ */
		16	+class connector : public stream_socket
		17	+{
		18	+ /** The base class */
		19	+ using base = stream_socket;
		20	+
		21	+ // Non-copyable
		22	+ connector(const connector&) =delete;
		23	+ connector& operator=(const connector&) =delete;
		24	+
		25	+public:
		26	+ /**
		27	+ * Creates an unconnected connector.
		28	+ */
		29	+ connector() {}
		30	+ /**
		31	+ * Creates the connector and attempts to connect to the specified
		32	+ * address.
		33	+ * @param addr The remote server address.
		34	+ */
		35	+ connector(const sock_address& addr) { connect(addr); }
		36	+ /**
		37	+ * Move constructor.
		38	+ * Creates a connector by moving the other connector to this one.
		39	+ * @param conn Another connector.
		40	+ */
		41	+ connector(connector&& conn) : base(std::move(conn)) {}
		42	+ /**
		43	+ * Move assignment.
		44	+ * @param rhs The other connector to move into this one.
		45	+ * @return A reference to this object.
		46	+ */
		47	+ connector& operator=(connector&& rhs) {
		48	+ base::operator=(std::move(rhs));
		49	+ return *this;
		50	+ }
		51	+ /**
		52	+ * Determines if the socket connected to a remote host.
		53	+ * Note that this is not a reliable determination if the socket is
		54	+ * currently connected, but rather that an initial connection was
		55	+ * established.
		56	+ * @return @em true If the socket connected to a remote host,
		57	+ * @em false if not.
		58	+ */
		59	+ bool is_connected() const { return is_open(); }
		60	+ /**
		61	+ * Attempts to connect to the specified server.
		62	+ * If the socket is currently connected, this will close the current
		63	+ * connection and open the new one.
		64	+ * @param addr The remote server address.
		65	+ * @return @em true on success, @em false on error
		66	+ */
		67	+ bool connect(const sock_address& addr);
		68	+};
		69	+
		70	+/**
		71	+ * Class to create a client TCP connection.
		72	+ */
		73	+template <typename STREAM_SOCK, typename ADDR=typename STREAM_SOCK::addr_t>
		74	+class connector_tmpl : public connector
		75	+{
		76	+ /** The base class */
		77	+ using base = connector;
		78	+
		79	+ // Non-copyable
		80	+ connector_tmpl(const connector_tmpl&) =delete;
		81	+ connector_tmpl& operator=(const connector_tmpl&) =delete;
		82	+
		83	+public:
		84	+ /** The type of streaming socket from the acceptor. */
		85	+ using stream_sock_t = STREAM_SOCK;
		86	+ /** The type of address for the connector. */
		87	+ using addr_t = ADDR;
		88	+
		89	+ /**
		90	+ * Creates an unconnected connector.
		91	+ */
		92	+ connector_tmpl() {}
		93	+ /**
		94	+ * Creates the connector and attempts to connect to the specified
		95	+ * address.
		96	+ * @param addr The remote server address.
		97	+ */
		98	+ connector_tmpl(const addr_t& addr) : base(addr) {}
		99	+ /**
		100	+ * Move constructor.
		101	+ * Creates a connector by moving the other connector to this one.
		102	+ * @param conn Another connector.
		103	+ */
		104	+ connector_tmpl(connector_tmpl&& rhs) : base(std::move(rhs)) {}
		105	+ /**
		106	+ * Move assignment.
		107	+ * @param rhs The other connector to move into this one.
		108	+ * @return A reference to this object.
		109	+ */
		110	+ connector_tmpl& operator=(connector_tmpl&& rhs) {
		111	+ base::operator=(std::move(rhs));
		112	+ return *this;
		113	+ }
		114	+ /**
		115	+ * Gets the local address to which the socket is bound.
		116	+ * @return The local address to which the socket is bound.
		117	+ * @throw sys_error on error
		118	+ */
		119	+ addr_t address() const { return addr_t(base::address()); }
		120	+ /**
		121	+ * Gets the address of the remote peer, if this socket is connected.
		122	+ * @return The address of the remote peer, if this socket is connected.
		123	+ * @throw sys_error on error
		124	+ */
		125	+ addr_t peer_address() const { return addr_t(base::peer_address()); }
		126	+ /**
		127	+ * Binds the socket to the specified address.
		128	+ * This call is optional for a client connector, though it is rarely
		129	+ * used.
		130	+ * @param addr The address to which we get bound.
		131	+ * @return @em true on success, @em false on error
		132	+ */
		133	+ bool bind(const addr_t& addr) { return base::bind(addr); }
		134	+ /**
		135	+ * Attempts to connects to the specified server.
		136	+ * If the socket is currently connected, this will close the current
		137	+ * connection and open the new one.
		138	+ * @param addr The remote server address.
		139	+ * @return @em true on success, @em false on error
		140	+ */
		141	+ bool connect(const addr_t& addr) { return base::connect(addr); }
		142	+};
		143	+
		144	+} // End namespace socket-cpp
		145	+} // End namespace components
		146	+} // End namespace osdev
		147	+

include/socket-cpp/datagram_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/datagram_socket.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/socket.h"
		4	+
		5	+namespace osdev {
		6	+namespace components {
		7	+namespace socket-cpp {
		8	+
		9	+/**
		10	+ * Base class for datagram sockets.
		11	+ *
		12	+ * Datagram sockets are normally connectionless, where each packet is
		13	+ * individually routed and delivered.
		14	+ */
		15	+class datagram_socket : public socket
		16	+{
		17	+ /** The base class */
		18	+ using base = socket;
		19	+
		20	+ // Non-copyable
		21	+ datagram_socket(const datagram_socket&) =delete;
		22	+ datagram_socket& operator=(const datagram_socket&) =delete;
		23	+
		24	+protected:
		25	+ static socket_t create_handle(int domain, int protocol=0) {
		26	+ return socket_t(::socket(domain, COMM_TYPE, protocol));
		27	+ }
		28	+
		29	+ static socket_t create_handle(int domain, int type, int protocol) {
		30	+ return socket_t(::socket(domain, type, protocol));
		31	+ }
		32	+
		33	+public:
		34	+ /** The socket 'type' for communications semantics. */
		35	+ static constexpr int COMM_TYPE = SOCK_DGRAM;
		36	+
		37	+ /**
		38	+ * Creates an uninitialized datagram socket.
		39	+ */
		40	+ datagram_socket() {}
		41	+ /**
		42	+ * Creates a datagram socket from an existing OS socket handle and
		43	+ * claims ownership of the handle.
		44	+ * @param handle A socket handle from the operating system.
		45	+ */
		46	+ explicit datagram_socket(socket_t handle) : base(handle) {}
		47	+ /**
		48	+ * Creates a UDP socket and binds it to the address.
		49	+ * @param addr The address to bind.
		50	+ */
		51	+ explicit datagram_socket(const sock_address& addr);
		52	+ /**
		53	+ * Move constructor.
		54	+ * @param other The other socket to move to this one
		55	+ */
		56	+ datagram_socket(datagram_socket&& other)
		57	+ : base(std::move(other)) {}
		58	+ /**
		59	+ * Move assignment.
		60	+ * @param rhs The other socket to move into this one.
		61	+ * @return A reference to this object.
		62	+ */
		63	+ datagram_socket& operator=(datagram_socket&& rhs) {
		64	+ base::operator=(std::move(rhs));
		65	+ return *this;
		66	+ }
		67	+ /**
		68	+ * Connects the socket to the remote address.
		69	+ * In the case of datagram sockets, this does not create an actual
		70	+ * connection, but rather specifies the address to which datagrams are
		71	+ * sent by default and the only address from which packets are
		72	+ * received.
		73	+ * @param addr The address on which to "connect".
		74	+ * @return @em true on success, @em false on failure
		75	+ */
		76	+ bool connect(const sock_address& addr) {
		77	+ return check_ret_bool(::connect(handle(), addr.sockaddr_ptr(),
		78	+ addr.size()));
		79	+ }
		80	+
		81	+ // ----- I/O -----
		82	+
		83	+ /**
		84	+ * Sends a message to the socket at the specified address.
		85	+ * @param buf The data to send.
		86	+ * @param n The number of bytes in the data buffer.
		87	+ * @param flags The flags. See send(2).
		88	+ * @param addr The remote destination of the data.
		89	+ * @return the number of bytes sent on success or, @em -1 on failure.
		90	+ */
		91	+ ssize_t send_to(const void* buf, size_t n, int flags, const sock_address& addr) {
		92	+ #if defined(_WIN32)
		93	+ return check_ret(::sendto(handle(), reinterpret_cast<const char*>(buf), int(n),
		94	+ flags, addr.sockaddr_ptr(), addr.size()));
		95	+ #else
		96	+ return check_ret(::sendto(handle(), buf, n, flags,
		97	+ addr.sockaddr_ptr(), addr.size()));
		98	+ #endif
		99	+ }
		100	+ /**
		101	+ * Sends a string to the socket at the specified address.
		102	+ * @param s The string to send.
		103	+ * @param flags The flags. See send(2).
		104	+ * @param addr The remote destination of the data.
		105	+ * @return the number of bytes sent on success or, @em -1 on failure.
		106	+ */
		107	+ ssize_t send_to(const std::string& s, int flags, const sock_address& addr) {
		108	+ return send_to(s.data(), s.length(), flags, addr);
		109	+ }
		110	+ /**
		111	+ * Sends a message to another socket.
		112	+ * @param buf The data to send.
		113	+ * @param n The number of bytes in the data buffer.
		114	+ * @param addr The remote destination of the data.
		115	+ * @return the number of bytes sent on success or, @em -1 on failure.
		116	+ */
		117	+ ssize_t send_to(const void* buf, size_t n, const sock_address& addr) {
		118	+ return send_to(buf, n, 0, addr);
		119	+ }
		120	+ /**
		121	+ * Sends a string to another socket.
		122	+ * @param s The string to send.
		123	+ * @param addr The remote destination of the data.
		124	+ * @return the number of bytes sent on success or, @em -1 on failure.
		125	+ */
		126	+ ssize_t send_to(const std::string& s, const sock_address& addr) {
		127	+ return send_to(s.data(), s.length(), 0, addr);
		128	+ }
		129	+ /**
		130	+ * Sends a message to the socket at the default address.
		131	+ * The socket should be connected before calling this.
		132	+ * @param buf The date to send.
		133	+ * @param n The number of bytes in the data buffer.
		134	+ * @param flags The option bit flags. See send(2).
		135	+ * @return @em zero on success, @em -1 on failure.
		136	+ */
		137	+ ssize_t send(const void* buf, size_t n, int flags=0) {
		138	+ #if defined(_WIN32)
		139	+ return check_ret(::send(handle(), reinterpret_cast<const char*>(buf),
		140	+ int(n), flags));
		141	+ #else
		142	+ return check_ret(::send(handle(), buf, n, flags));
		143	+ #endif
		144	+ }
		145	+ /**
		146	+ * Sends a string to the socket at the default address.
		147	+ * The socket should be connected before calling this
		148	+ * @param s The string to send.
		149	+ * @param flags The option bit flags. See send(2).
		150	+ * @return @em zero on success, @em -1 on failure.
		151	+ */
		152	+ ssize_t send(const std::string& s, int flags=0) {
		153	+ return send(s.data(), s.length(), flags);
		154	+ }
		155	+ /**
		156	+ * Receives a message on the socket.
		157	+ * @param buf Buffer to get the incoming data.
		158	+ * @param n The number of bytes to read.
		159	+ * @param flags The option bit flags. See send(2).
		160	+ * @param srcAddr Receives the address of the peer that sent the
		161	+ * message
		162	+ * @return The number of bytes read or @em -1 on error.
		163	+ */
		164	+ ssize_t recv_from(void* buf, size_t n, int flags, sock_address* srcAddr=nullptr);
		165	+ /**
		166	+ * Receives a message on the socket.
		167	+ * @param buf Buffer to get the incoming data.
		168	+ * @param n The number of bytes to read.
		169	+ * @param srcAddr Receives the address of the peer that sent the
		170	+ * message
		171	+ * @return The number of bytes read or @em -1 on error.
		172	+ */
		173	+ ssize_t recv_from(void* buf, size_t n, sock_address* srcAddr=nullptr) {
		174	+ return recv_from(buf, n, 0, srcAddr);
		175	+ }
		176	+ /**
		177	+ * Receives a message on the socket.
		178	+ * @param buf Buffer to get the incoming data.
		179	+ * @param n The number of bytes to read.
		180	+ * @param flags The option bit flags. See send(2).
		181	+ * @return The number of bytes read or @em -1 on error.
		182	+ */
		183	+ ssize_t recv(void* buf, size_t n, int flags=0) {
		184	+ #if defined(_WIN32)
		185	+ return check_ret(::recv(handle(), reinterpret_cast<char*>(buf),
		186	+ int(n), flags));
		187	+ #else
		188	+ return check_ret(::recv(handle(), buf, n, flags));
		189	+ #endif
		190	+ }
		191	+};
		192	+
		193	+/**
		194	+ * Base class for datagram sockets.
		195	+ *
		196	+ * Datagram sockets are normally connectionless, where each packet is
		197	+ * individually routed and delivered.
		198	+ */
		199	+template <typename ADDR>
		200	+class datagram_socket_tmpl : public datagram_socket
		201	+{
		202	+ /** The base class */
		203	+ using base = datagram_socket;
		204	+
		205	+public:
		206	+ /** The address family for this type of address */
		207	+ static constexpr sa_family_t ADDRESS_FAMILY = ADDR::ADDRESS_FAMILY;
		208	+ /** The type of address for the socket. */
		209	+ using addr_t = ADDR;
		210	+
		211	+ /**
		212	+ * Creates an unbound datagram socket.
		213	+ * This can be used as a client or later bound as a server socket.
		214	+ */
		215	+ datagram_socket_tmpl() : base(create_handle(ADDRESS_FAMILY)) {}
		216	+ /**
		217	+ * Creates a datagram socket from an existing OS socket handle and
		218	+ * claims ownership of the handle.
		219	+ * @param handle A socket handle from the operating system.
		220	+ */
		221	+ datagram_socket_tmpl(socket_t handle) : base(handle) {}
		222	+ /**
		223	+ * Creates a datagram socket and binds it to the address.
		224	+ * @param addr The address to bind.
		225	+ */
		226	+ datagram_socket_tmpl(const ADDR& addr) : base(addr) {}
		227	+ /**
		228	+ * Move constructor.
		229	+ * @param other The other socket to move to this one
		230	+ */
		231	+ datagram_socket_tmpl(datagram_socket_tmpl&& other)
		232	+ : base(std::move(other)) {}
		233	+ /**
		234	+ * Move assignment.
		235	+ * @param rhs The other socket to move into this one.
		236	+ * @return A reference to this object.
		237	+ */
		238	+ datagram_socket_tmpl& operator=(datagram_socket_tmpl&& rhs) {
		239	+ base::operator=(std::move(rhs));
		240	+ return *this;
		241	+ }
		242	+
		243	+ /**
		244	+ * Creates a pair of connected stream sockets.
		245	+ *
		246	+ * Whether this will work at all is highly system and domain dependent.
		247	+ * Currently it is only known to work for Unix-domain sockets on *nix
		248	+ * systems.
		249	+ *
		250	+ * @param protocol The protocol to be used with the socket. (Normally 0)
		251	+ *
		252	+ * @return A std::tuple of stream sockets. On error both sockets will be
		253	+ * in an error state with the last error set.
		254	+ */
		255	+ static std::tuple<datagram_socket_tmpl, datagram_socket_tmpl> pair(int protocol=0) {
		256	+ auto pr = base::pair(addr_t::ADDRESS_FAMILY, COMM_TYPE, protocol);
		257	+ return std::make_tuple<datagram_socket_tmpl, datagram_socket_tmpl>(
		258	+ datagram_socket_tmpl{std::get<0>(pr).release()},
		259	+ datagram_socket_tmpl{std::get<1>(pr).release()});
		260	+ }
		261	+ /**
		262	+ * Binds the socket to the local address.
		263	+ * Datagram sockets can bind to a local address/adapter to filter which
		264	+ * incoming packets to receive.
		265	+ * @param addr The address on which to bind.
		266	+ * @return @em true on success, @em false on failure
		267	+ */
		268	+ bool bind(const ADDR& addr) { return base::bind(addr); }
		269	+ /**
		270	+ * Connects the socket to the remote address.
		271	+ * In the case of datagram sockets, this does not create an actual
		272	+ * connection, but rather specifies the address to which datagrams are
		273	+ * sent by default and the only address from which packets are
		274	+ * received.
		275	+ * @param addr The address on which to "connect".
		276	+ * @return @em true on success, @em false on failure
		277	+ */
		278	+ bool connect(const ADDR& addr) { return base::connect(addr); }
		279	+
		280	+ // ----- I/O -----
		281	+
		282	+ /**
		283	+ * Sends a message to the socket at the specified address.
		284	+ * @param buf The data to send.
		285	+ * @param n The number of bytes in the data buffer.
		286	+ * @param flags The option bit flags. See send(2).
		287	+ * @param addr The remote destination of the data.
		288	+ * @return the number of bytes sent on success or, @em -1 on failure.
		289	+ */
		290	+ ssize_t send_to(const void* buf, size_t n, int flags, const ADDR& addr) {
		291	+ return base::send_to(buf, n, flags, addr);
		292	+ }
		293	+ /**
		294	+ * Sends a string to the socket at the specified address.
		295	+ * @param s The string to send.
		296	+ * @param flags The flags. See send(2).
		297	+ * @param addr The remote destination of the data.
		298	+ * @return the number of bytes sent on success or, @em -1 on failure.
		299	+ */
		300	+ ssize_t send_to(const std::string& s, int flags, const ADDR& addr) {
		301	+ return base::send_to(s, flags, addr);
		302	+ }
		303	+ /**
		304	+ * Sends a message to another socket.
		305	+ * @param buf The data to send.
		306	+ * @param n The number of bytes in the data buffer.
		307	+ * @param addr The remote destination of the data.
		308	+ * @return the number of bytes sent on success or, @em -1 on failure.
		309	+ */
		310	+ ssize_t send_to(const void* buf, size_t n, const ADDR& addr) {
		311	+ return base::send_to(buf, n, 0, addr);
		312	+ }
		313	+ /**
		314	+ * Sends a string to another socket.
		315	+ * @param s The string to send.
		316	+ * @param addr The remote destination of the data.
		317	+ * @return the number of bytes sent on success or, @em -1 on failure.
		318	+ */
		319	+ ssize_t send_to(const std::string& s, const ADDR& addr) {
		320	+ return base::send_to(s, addr);
		321	+ }
		322	+ /**
		323	+ * Receives a message on the socket.
		324	+ * @param buf Buffer to get the incoming data.
		325	+ * @param n The number of bytes to read.
		326	+ * @param flags The option bit flags. See send(2).
		327	+ * @param srcAddr Receives the address of the peer that sent
		328	+ * the message
		329	+ * @return The number of bytes read or @em -1 on error.
		330	+ */
		331	+ ssize_t recv_from(void* buf, size_t n, int flags, ADDR* srcAddr) {
		332	+ return base::recv_from(buf, n, flags, srcAddr);
		333	+ }
		334	+ /**
		335	+ * Receives a message on the socket.
		336	+ * @param buf Buffer to get the incoming data.
		337	+ * @param n The number of bytes to read.
		338	+ * @param srcAddr Receives the address of the peer that sent
		339	+ * the message
		340	+ * @return The number of bytes read or @em -1 on error.
		341	+ */
		342	+ ssize_t recv_from(void* buf, size_t n, ADDR* srcAddr=nullptr) {
		343	+ return base::recv_from(buf, n, srcAddr);
		344	+ }
		345	+};
		346	+
		347	+} // End namespace socket-cpp
		348	+} // End namespace components
		349	+} // End namespace osdev
		350	+

include/socket-cpp/exception.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/exception.h
		1	+#pragma once
		2	+
		3	+#include <cerrno>
		4	+#include <stdexcept>
		5	+#include <string>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace socket-cpp {
		10	+
		11	+/**
		12	+ * System error.
		13	+ * These are errors that are resulted from system socket calls. The error
		14	+ * codes are platform 'errno' values (or similar), and the messages are
		15	+ * typically derived from the system.
		16	+ */
		17	+class sys_error : public std::runtime_error
		18	+{
		19	+ /** The system error number (errno) */
		20	+ int errno_;
		21	+
		22	+public:
		23	+ /**
		24	+ * Creates an error using the current system 'errno' value.
		25	+ */
		26	+ sys_error() : sys_error(errno) {}
		27	+ /**
		28	+ * Constructs an error with the specified system errno.
		29	+ * @param err The error number. This is the system errno value.
		30	+ */
		31	+ explicit sys_error(int err);
		32	+ /**
		33	+ * Get the error number.
		34	+ * @return The system error number.
		35	+ */
		36	+ int error() const { return errno_; }
		37	+ /**
		38	+ * Gets a string describing the specified error.
		39	+ * This is typically the returned message from the system strerror().
		40	+ * @param err The system error number.
		41	+ * @return A string describing the specified error.
		42	+ */
		43	+ static std::string error_str(int err);
		44	+};
		45	+
		46	+/**
		47	+ * Errors from getaddrinfo.
		48	+ * These are errors relating to DNS lookup, returned from the getaddrinfo system call.
		49	+ * Their codes are declared in <netdb.h>.
		50	+ */
		51	+class getaddrinfo_error : public std::runtime_error
		52	+{
		53	+ /** The error number, as returned by getaddrinfo. */
		54	+ int error_;
		55	+ /** The hostname being resolved. */
		56	+ std::string hostname_;
		57	+
		58	+public:
		59	+ /**
		60	+ * Constructs an error with the specified getaddrinfo error code.
		61	+ * @param err The error number, as returned by getaddrinfo.
		62	+ * @param hostname The DNS name being resolved that triggered the error.
		63	+ */
		64	+ getaddrinfo_error(int err, const std::string &hostname);
		65	+ /**
		66	+ * Get the error number.
		67	+ * @return The error number returned by getaddrinfo.
		68	+ */
		69	+ int error() const { return error_; }
		70	+ /**
		71	+ * Get the hostname that triggered the error.
		72	+ * @return The hostname that getaddrinfo failed to resolve.
		73	+ */
		74	+ const std::string &hostname() const { return hostname_; }
		75	+};
		76	+
		77	+} // End namespace socket-cpp
		78	+} // End namespace components
		79	+} // End namespace osdev
		80	+

include/socket-cpp/inet6_address.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/inet6_address.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/platform.h"
		4	+#include "socket-cpp/sock_address.h"
		5	+#include <iostream>
		6	+#include <string>
		7	+#include <cstring>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace socket-cpp {
		12	+
		13	+/**
		14	+ * Class that represents an internet (IPv6) address. This inherits from the
		15	+ * IP-specific form of a socket address, @em sockaddr_in.
		16	+ */
		17	+class inet6_address : public sock_address
		18	+{
		19	+ /** The underlying C IPv6 struct */
		20	+ sockaddr_in6 addr_;
		21	+
		22	+ /** The size of the underlying address struct, in bytes */
		23	+ static constexpr size_t SZ = sizeof(sockaddr_in6);
		24	+
		25	+public:
		26	+ /** The address family for this type of address */
		27	+ static constexpr sa_family_t ADDRESS_FAMILY = AF_INET6;
		28	+
		29	+ /**
		30	+ * Constructs an empty address.
		31	+ * The address is initialized to all zeroes.
		32	+ */
		33	+ inet6_address() : addr_() {}
		34	+ /**
		35	+ * Constructs an address for any iface using the specified port.
		36	+ * This is a convenient way for a server to specify an address that will
		37	+ * bind to all interfaces.
		38	+ * @param port The port number in native/host byte order.
		39	+ */
		40	+ explicit inet6_address(in_port_t port) {
		41	+ const in6_addr ANY IN6ADDR_ANY_INIT;
		42	+ create(ANY, port);
		43	+ }
		44	+ /**
		45	+ * Constructs an address using the name of the host and the specified
		46	+ * port. This attempts to resolve the host name to an address.
		47	+ *
		48	+ * @param saddr The name of the host.
		49	+ * @param port The port number in native/host byte order.
		50	+ */
		51	+ inet6_address(const std::string& saddr, in_port_t port) {
		52	+ create(saddr, port);
		53	+ }
		54	+ /**
		55	+ * Constructs the address by copying the specified structure.
		56	+ * TODO: Do we actually need a conversion from something that's
		57	+ * cast to a sockaddr, but is really a sockaddr_in6?
		58	+ * @param addr The other address
		59	+ */
		60	+ inet6_address(const sockaddr_storage& addr) {
		61	+ std::memcpy(&addr_, &addr, SZ);
		62	+ }
		63	+ /**
		64	+ * Constructs the address by copying the specified structure.
		65	+ * @param addr The other address
		66	+ */
		67	+ inet6_address(const sock_address& addr) {
		68	+ std::memcpy(&addr_, addr.sockaddr_ptr(), SZ);
		69	+ }
		70	+ /**
		71	+ * Constructs the address by copying the specified structure.
		72	+ * @param addr The other address
		73	+ */
		74	+ inet6_address(const sockaddr_in6& addr) {
		75	+ std::memcpy(&addr_, &addr, SZ);
		76	+ }
		77	+ /**
		78	+ * Constructs the address by copying the specified address.
		79	+ * @param addr The other address
		80	+ */
		81	+ inet6_address(const inet6_address& addr) : addr_(addr.addr_) {}
		82	+ /**
		83	+ * Creates an address on the loopback (localhost) interface.
		84	+ * @param port The port number (in native/host byte order).
		85	+ * @return The full address on the loopback interface.
		86	+ */
		87	+ static inet6_address loopback(in_port_t port) {
		88	+ const in6_addr LOOPBACK IN6ADDR_LOOPBACK_INIT;
		89	+ inet6_address addr;
		90	+ addr.create(LOOPBACK, port);
		91	+ return addr;
		92	+ }
		93	+ /**
		94	+ * Checks if the address is set to some value.
		95	+ * This doesn't attempt to determine if the address is valid, simply
		96	+ * that it's not all zero.
		97	+ * @return bool
		98	+ */
		99	+ bool is_set() const;
		100	+ /**
		101	+ * Attempts to resolve the host name into a 32-bit internet address.
		102	+ * @param saddr The string host name.
		103	+ * @return The internet address in network byte order.
		104	+ */
		105	+ static in6_addr resolve_name(const std::string& saddr);
		106	+ /**
		107	+ * Creates the socket address using the specified host address and port
		108	+ * number.
		109	+ * @param addr The host address (16-byte IPv6 address).
		110	+ * @param port The host port number.
		111	+ */
		112	+ void create(const in6_addr& addr, in_port_t port);
		113	+ /**
		114	+ * Creates the socket address using the specified host name and port
		115	+ * number.
		116	+ * @param saddr The string host name.
		117	+ * @param port The port number in native/host byte order.
		118	+ */
		119	+ void create(const std::string& saddr, in_port_t port);
		120	+ /**
		121	+ * Gets 128-bit IPv6 address.
		122	+ * The address is usually stored in network byte order.
		123	+ * @return The IPv6 address.
		124	+ */
		125	+ in6_addr address() const { return addr_.sin6_addr; }
		126	+ /**
		127	+ * Gets a byte of the 128-bit IPv6 Address.
		128	+ * Note that the address is normally stored in network byte
		129	+ * order.
		130	+ * @param i The byte to read (0-7)
		131	+{
		132	+ return addr_ != sockaddr_in6{};
		133	+ * @return The specified byte in the 128-bit IPv6 Address
		134	+ */
		135	+ uint8_t operator[](int i) const {
		136	+ return addr_.sin6_addr.s6_addr[i];
		137	+ }
		138	+ /**
		139	+ * Gets the port number.
		140	+ * @return The port number in native/host byte order.
		141	+ */
		142	+ in_port_t port() const { return ntohs(addr_.sin6_port); }
		143	+ /**
		144	+ * Gets the size of this structure.
		145	+ * This is equivalent to sizeof(this) but more convenient in some
		146	+ * places.
		147	+ * @return The size of this structure.
		148	+ */
		149	+ socklen_t size() const override { return socklen_t(SZ); }
		150	+ /**
		151	+ * Gets a pointer to this object cast to a @em sockaddr.
		152	+ * @return A pointer to this object cast to a @em sockaddr.
		153	+ */
		154	+ const sockaddr* sockaddr_ptr() const override {
		155	+ return reinterpret_cast<const sockaddr*>(&addr_);
		156	+ }
		157	+ /**
		158	+ * Gets a pointer to this object cast to a @em sockaddr.
		159	+ * @return A pointer to this object cast to a @em sockaddr.
		160	+ */
		161	+ sockaddr* sockaddr_ptr() override {
		162	+ return reinterpret_cast<sockaddr*>(&addr_);
		163	+ }
		164	+ /**
		165	+ * Gets a const pointer to this object cast to a @em
		166	+ * sockaddr_in6.
		167	+ * @return const sockaddr_in6 pointer to this object.
		168	+ */
		169	+ const sockaddr_in6* sockaddr_in6_ptr() const { return &addr_; }
		170	+ /**
		171	+ * Gets a pointer to this object cast to a @em sockaddr_in6.
		172	+ * @return sockaddr_in6 pointer to this object.
		173	+ */
		174	+ sockaddr_in6* sockaddr_in6_ptr() { return &addr_; }
		175	+ /**
		176	+ * Gets a printable string for the address.
		177	+ * This gets the address in the printable form "[addr]:port"
		178	+ * using inet_ntop(). It does not attempt to find the host name
		179	+ * using a lookup.
		180	+ * @return A string representation of the address in the form
		181	+ * '[address]:port'
		182	+ */
		183	+ std::string to_string() const;
		184	+};
		185	+
		186	+// --------------------------------------------------------------------------
		187	+
		188	+/**
		189	+ * Stream inserter for the address.
		190	+ * This uses the simple dot notation of the address as returned from
		191	+ * inet_ntop(). It does not attempt a host lookup.
		192	+ * @param os The output stream
		193	+ * @param addr The address
		194	+ * @return A reference to the output stream.
		195	+ */
		196	+std::ostream& operator<<(std::ostream& os, const inet6_address& addr);
		197	+
		198	+} // End namespace socket-cpp
		199	+} // End namespace components
		200	+} // End namespace osdev

include/socket-cpp/inet_address.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/inet_address.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/sock_address.h"
		4	+#include <iostream>
		5	+#include <string>
		6	+#include <cstring>
		7	+#include <algorithm>
		8	+
		9	+namespace osdev {
		10	+namespace components {
		11	+namespace socket-cpp {
		12	+
		13	+/**
		14	+ * Class that represents an internet (IPv4) address.
		15	+ * This inherits from the IP-specific form of a socket address,
		16	+ * @em sockaddr_in.
		17	+ */
		18	+class inet_address : public sock_address
		19	+{
		20	+ /** The underlying C struct for IPv4 addresses */
		21	+ sockaddr_in addr_;
		22	+
		23	+ /** The size of the underlying address struct, in bytes */
		24	+ static constexpr size_t SZ = sizeof(sockaddr_in);
		25	+
		26	+public:
		27	+ /** The address family for this type of address */
		28	+ static constexpr sa_family_t ADDRESS_FAMILY = AF_INET;
		29	+
		30	+ /**
		31	+ * Constructs an empty address.
		32	+ * The address is initialized to all zeroes.
		33	+ */
		34	+ inet_address() : addr_() {}
		35	+ /**
		36	+ * Constructs an address for any iface using the specified port.
		37	+ * This is a convenient way for a server to specify an address that will
		38	+ * bind to all interfaces.
		39	+ * @param port The port number in native/host byte order.
		40	+ */
		41	+ explicit inet_address(in_port_t port) {
		42	+ create(in_addr_t(INADDR_ANY), port);
		43	+ }
		44	+ /**
		45	+ * Constructs an address for the specified host using the specified
		46	+ * port.
		47	+ * @param addr The 32-bit host address in native/host byte order.
		48	+ * @param port The port number in native/host byte order.
		49	+ */
		50	+ inet_address(uint32_t addr, in_port_t port) { create(addr, port); }
		51	+ /**
		52	+ * Constructs an address using the name of the host and the specified
		53	+ * port. This attempts to resolve the host name to an address.
		54	+ *
		55	+ * @param saddr The name of the host.
		56	+ * @param port The port number in native/host byte order.
		57	+ */
		58	+ inet_address(const std::string& saddr, in_port_t port) {
		59	+ create(saddr, port);
		60	+ }
		61	+ /**
		62	+ * Constructs the address by copying the specified structure.
		63	+ * @param addr The other address
		64	+ */
		65	+ inet_address(const sockaddr& addr) {
		66	+ std::memcpy(&addr_, &addr, SZ);
		67	+ }
		68	+ /**
		69	+ * Constructs the address by copying the specified structure.
		70	+ * @param addr The other address
		71	+ */
		72	+ inet_address(const sock_address& addr) {
		73	+ std::memcpy(&addr_, addr.sockaddr_ptr(), SZ);
		74	+ }
		75	+ /**
		76	+ * Constructs the address by copying the specified structure.
		77	+ * @param addr The other address
		78	+ */
		79	+ inet_address(const sockaddr_in& addr) : addr_(addr) {}
		80	+ /**
		81	+ * Constructs the address by copying the specified address.
		82	+ * @param addr The other address
		83	+ */
		84	+ inet_address(const inet_address& addr) : addr_(addr.addr_) {}
		85	+ /**
		86	+ * Checks if the address is set to some value.
		87	+ * This doesn't attempt to determine if the address is valid, simply
		88	+ * that it's not all zero.
		89	+ * @return bool
		90	+ */
		91	+ bool is_set() const;
		92	+ /**
		93	+ * Attempts to resolve the host name into a 32-bit internet address.
		94	+ * @param saddr The string host name.
		95	+ * @return The internet address in network byte order.
		96	+ * @throw sys_error, getaddrinfo_error
		97	+ */
		98	+ static in_addr_t resolve_name(const std::string& saddr);
		99	+ /**
		100	+ * Creates the socket address using the specified host address and port
		101	+ * number.
		102	+ * @param addr The host address.
		103	+ * @param port The host port number.
		104	+ */
		105	+ void create(in_addr_t addr, in_port_t port);
		106	+ /**
		107	+ * Creates the socket address using the specified host name and port
		108	+ * number.
		109	+ * @param saddr The string host name.
		110	+ * @param port The port number in native/host byte order.
		111	+ * @throw sys_error, getaddrinfo_error
		112	+ */
		113	+ void create(const std::string& saddr, in_port_t port);
		114	+ /**
		115	+ * Gets the 32-bit internet address.
		116	+ * @return The internet address in the local host's byte order.
		117	+ */
		118	+ in_addr_t address() const { return ntohl(addr_.sin_addr.s_addr); }
		119	+ /**
		120	+ * Gets a byte of the 32-bit Internet Address
		121	+ * @param i The byte to read (0-3)
		122	+ * @return The specified byte in the 32-bit Internet Address
		123	+ */
		124	+ uint8_t operator[](int i) const {
		125	+ in_addr_t addr = address();
		126	+ return ((const uint8_t*)&addr)[i];
		127	+ }
		128	+ /**
		129	+ * Gets the port number.
		130	+ * @return The port number in native/host byte order.
		131	+ */
		132	+ in_port_t port() const { return ntohs(addr_.sin_port); }
		133	+ /**
		134	+ * Gets the size of this structure.
		135	+ * This is equivalent to sizeof(this) but more convenient in some
		136	+ * places.
		137	+ * @return The size of this structure.
		138	+ */
		139	+ socklen_t size() const override { return socklen_t(SZ); }
		140	+ /**
		141	+ * Gets a pointer to this object cast to a @em sockaddr.
		142	+ * @return A pointer to this object cast to a @em sockaddr.
		143	+ */
		144	+ const sockaddr* sockaddr_ptr() const override {
		145	+ return reinterpret_cast<const sockaddr*>(&addr_);
		146	+ }
		147	+ /**
		148	+ * Gets a pointer to this object cast to a @em sockaddr.
		149	+ * @return A pointer to this object cast to a @em sockaddr.
		150	+ */
		151	+ sockaddr* sockaddr_ptr() override {
		152	+ return reinterpret_cast<sockaddr*>(&addr_);
		153	+ }
		154	+ /**
		155	+ * Gets a const pointer to this object cast to a @em sockaddr_in.
		156	+ * @return const sockaddr_in pointer to this object.
		157	+ */
		158	+ const sockaddr_in* sockaddr_in_ptr() const {
		159	+ return static_cast<const sockaddr_in*>(&addr_);
		160	+ }
		161	+ /**
		162	+ * Gets a pointer to this object cast to a @em sockaddr_in.
		163	+ * @return sockaddr_in pointer to this object.
		164	+ */
		165	+ sockaddr_in* sockaddr_in_ptr() {
		166	+ return static_cast<sockaddr_in*>(&addr_);
		167	+ }
		168	+ /**
		169	+ * Gets a printable string for the address.
		170	+ * This gets the simple dot notation of the address as returned from
		171	+ * inet_ntop(). It does not attempt a host lookup.
		172	+ * @return A string representation of the address in the form
		173	+ * 'address:port'
		174	+ */
		175	+ std::string to_string() const;
		176	+};
		177	+
		178	+// --------------------------------------------------------------------------
		179	+
		180	+/**
		181	+ * Stream inserter for the address.
		182	+ * This uses the simple dot notation of the address as returned from
		183	+ * inet_ntop(). It does not attempt a host lookup.
		184	+ * @param os The output stream
		185	+ * @param addr The address
		186	+ * @return A reference to the output stream.
		187	+ */
		188	+std::ostream& operator<<(std::ostream& os, const inet_address& addr);
		189	+
		190	+} // End namespace socket-cpp
		191	+} // End namespace components
		192	+} // End namespace osdev

include/socket-cpp/platform.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/platform.h
		1	+#pragma once
		2	+
		3	+namespace osdev {
		4	+namespace components {
		5	+namespace socket-cpp {
		6	+
		7	+#include <cstdint>
		8	+
		9	+#if defined(_WIN32)
		10	+ //#pragma warning(4 : 4996) // Deprecated functions (CRT & all)
		11	+ //#pragma warning(4 : 4250) // Inheritance via dominance
		12	+
		13	+ #if !defined(WIN32_LEAN_AND_MEAN)
		14	+ #define WIN32_LEAN_AND_MEAN
		15	+ #endif
		16	+
		17	+ #if !defined(_CRT_SECURE_NO_DEPRECATE)
		18	+ #define _CRT_SECURE_NO_DEPRECATE
		19	+ #endif
		20	+
		21	+ //#include <cstddef>
		22	+ //#include <windows.h>
		23	+ #include <winsock2.h>
		24	+ #include <ws2tcpip.h>
		25	+
		26	+ #define SOCKPP_SOCKET_T_DEFINED
		27	+ using socket_t = SOCKET;
		28	+
		29	+ using socklen_t = int;
		30	+ using in_port_t = uint16_t;
		31	+ using in_addr_t = uint32_t;
		32	+
		33	+ using sa_family_t = u_short;
		34	+
		35	+ #ifndef _SSIZE_T_DEFINED
		36	+ #define _SSIZE_T_DEFINED
		37	+ #undef ssize_t
		38	+ using ssize_t = SSIZE_T;
		39	+ #endif // _SSIZE_T_DEFINED
		40	+
		41	+ #ifndef _SUSECONDS_T
		42	+ #define _SUSECONDS_T
		43	+ typedef long suseconds_t; // signed # of microseconds in timeval
		44	+ #endif // _SUSECONDS_T
		45	+
		46	+ #define SHUT_RD SD_RECEIVE
		47	+ #define SHUT_WR SD_SEND
		48	+ #define SHUT_RDWR SD_BOTH
		49	+
		50	+ struct iovec
		51	+ {
		52	+ void* iov_base;
		53	+ size_t iov_len;
		54	+ };
		55	+
		56	+#else
		57	+ #include <unistd.h>
		58	+ #include <sys/socket.h>
		59	+ #include <sys/uio.h>
		60	+ #include <arpa/inet.h>
		61	+ #ifdef __FreeBSD__
		62	+ #include <netinet/in.h>
		63	+ #endif
		64	+ #include <netdb.h>
		65	+ #include <signal.h>
		66	+ #include <cerrno>
		67	+#endif
		68	+
		69	+} // End namespace socket-cpp
		70	+} // End namespace components
		71	+} // End namespace osdev
		72	+

include/socket-cpp/sock_address.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/sock_address.h
		1	+#pragma once
		2	+
		3	+#include "socket-cpp/platform.h"
		4	+#include <cstring>
		5	+#include <stdexcept>
		6	+
		7	+namespace osdev {
		8	+namespace components {
		9	+namespace socket-cpp {
		10	+
		11	+/**
		12	+ * Generic socket address.
		13	+ * Abstract base class for socket addresses. The underlying C socket
		14	+ * functions typically take or return an address as a `sockaddr` pointer and
		15	+ * length. So derived classes that wrap the
		16	+ */
		17	+class sock_address
		18	+{
		19	+public:
		20	+ /**
		21	+ * Virtual destructor.
		22	+ */
		23	+ virtual ~sock_address() {}
		24	+ /**
		25	+ * Gets the size of this structure.
		26	+ * This is equivalent to sizeof(this) but more convenient in some
		27	+ * places.
		28	+ * @return The size of this structure.
		29	+ */
		30	+ virtual socklen_t size() const =0;
		31	+ /**
		32	+ * Gets a pointer to this object cast to a @em sockaddr.
		33	+ * @return A pointer to this object cast to a @em sockaddr.
		34	+ */
		35	+ virtual sockaddr* sockaddr_ptr() =0;
		36	+ /**
		37	+ * Gets a pointer to this object cast to a @em sockaddr.
		38	+ * @return A pointer to this object cast to a @em sockaddr.
		39	+ */
		40	+ virtual const sockaddr* sockaddr_ptr() const =0;
		41	+ /**
		42	+ * Gets the network family of the address.
		43	+ * @return The network family of the address (AF_INET, etc). If the
		44	+ * address is not known, returns AF_UNSPEC.
		45	+ */
		46	+ virtual sa_family_t family() const {
		47	+ auto p = sockaddr_ptr();
		48	+ return p ? p->sa_family : AF_UNSPEC;
		49	+ }
		50	+};
		51	+
		52	+/**
		53	+ * Generic socket address.
		54	+ *
		55	+ * This is a wrapper around `sockaddr_storage` which can hold any family
		56	+ * address. This should have enough memory to contain any address struct for
		57	+ * the system on which it is compiled.
		58	+ */
		59	+class sock_address_any : public sock_address
		60	+{
		61	+ /** Storage for any kind of socket address */
		62	+ sockaddr_storage addr_;
		63	+ /** Length of the address (in bytes) */
		64	+ socklen_t sz_;
		65	+
		66	+ /** The maximum size of an address, in bytes */
		67	+ static constexpr size_t MAX_SZ = sizeof(sockaddr_storage);
		68	+
		69	+public:
		70	+ /**
		71	+ * Constructs an empty address.
		72	+ * The address is initialized to all zeroes.
		73	+ */
		74	+ sock_address_any() : addr_{}, sz_{MAX_SZ} {}
		75	+ /**
		76	+ * Constructs an address.
		77	+ * @param addr Pointer to a buffer holding the address.
		78	+ * @param n The number of valid bytes in the address
		79	+ * @throws std::length_error if `n` is greater than the maximum size of
		80	+ * an address.
		81	+ */
		82	+ sock_address_any(const sockaddr* addr, socklen_t n) {
		83	+ if (n > MAX_SZ)
		84	+ throw std::length_error("Address length out of range");
		85	+ std::memcpy(&addr_, addr, sz_ = n);
		86	+ }
		87	+ /**
		88	+ * Constructs an address.
		89	+ * @param addr The buffer holding the address.
		90	+ * @param n The number of valid bytes in the address
		91	+ * @throws std::length_error if `n` is greater than the maximum size of
		92	+ * an address.
		93	+ */
		94	+ sock_address_any(const sockaddr_storage& addr, socklen_t n) {
		95	+ if (n > MAX_SZ)
		96	+ throw std::length_error("Address length out of range");
		97	+ std::memcpy(&addr_, &addr, sz_ = n);
		98	+ }
		99	+ /**
		100	+ * Copies another address to this one.
		101	+ * @param addr The other address to copy into this one.
		102	+ */
		103	+ sock_address_any(const sock_address& addr)
		104	+ : sock_address_any(addr.sockaddr_ptr(), addr.size()) {}
		105	+ /**
		106	+ * Gets the size of the address.
		107	+ * @return The size of the address. This is the number of bytes that are a
		108	+ * valid part of the address.
		109	+ */
		110	+ socklen_t size() const override { return sz_; }
		111	+ /**
		112	+ * Gets a pointer to this object cast to a @em sockaddr.
		113	+ * @return A pointer to this object cast to a @em sockaddr.
		114	+ */
		115	+ const sockaddr* sockaddr_ptr() const override {
		116	+ return reinterpret_cast<const sockaddr*>(&addr_);
		117	+ }
		118	+ /**
		119	+ * Gets a pointer to this object cast to a @em sockaddr.
		120	+ * @return A pointer to this object cast to a @em sockaddr.
		121	+ */
		122	+ sockaddr* sockaddr_ptr() override {
		123	+ return reinterpret_cast<sockaddr*>(&addr_);
		124	+ }
		125	+};
		126	+
		127	+/**
		128	+ * Determines if the two objects refer to the same address.
		129	+ * @param lhs A socket address
		130	+ * @param rhs A socket address
		131	+ * @return @em true if `lhs` and `rhs` refer to the same address, @em false
		132	+ * otherwise.
		133	+ */
		134	+inline bool operator==(const sock_address& lhs, const sock_address& rhs) {
		135	+ return lhs.size() == rhs.size() &&
		136	+ std::memcmp(lhs.sockaddr_ptr(), rhs.sockaddr_ptr(), lhs.size()) == 0;
		137	+}
		138	+
		139	+/**
		140	+ * Determines if the two objects refer to the different address.
		141	+ * @param lhs A socket address
		142	+ * @param rhs A socket address
		143	+ * @return @em true if `lhs` and `rhs` refer to different address, @em false
		144	+ * if they refer to the same address.
		145	+ */
		146	+inline bool operator!=(const sock_address& lhs, const sock_address& rhs) {
		147	+ return !operator==(lhs, rhs);
		148	+}
		149	+
		150	+} // End namespace socket-cpp
		151	+} // End namespace components
		152	+} // End namespace osdev
		153	+

include/socket-cpp/socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/socket.h
		1	+/**
		2	+ * @file socket.h
		3	+ *
		4	+ * Classes for TCP & UDP socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date December 2014
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_socket_h
		48	+#define __sockpp_socket_h
		49	+
		50	+#include "sockpp/sock_address.h"
		51	+#include <chrono>
		52	+#include <string>
		53	+#include <tuple>
		54	+
		55	+namespace sockpp {
		56	+
		57	+/////////////////////////////////////////////////////////////////////////////
		58	+
		59	+#if !defined(SOCKPP_SOCKET_T_DEFINED)
		60	+ typedef int socket_t; ///< The OS socket handle
		61	+ const socket_t INVALID_SOCKET = -1; ///< Invalid socket descriptor
		62	+ #define SOCKPP_SOCKET_T_DEFINED
		63	+#endif
		64	+
		65	+/**
		66	+ * Converts a number of microseconds to a relative timeval.
		67	+ * @param dur A chrono duration of microseconds.
		68	+ * @return A timeval
		69	+ */
		70	+timeval to_timeval(const std::chrono::microseconds& dur);
		71	+
		72	+/**
		73	+ * Converts a chrono duration to a relative timeval.
		74	+ * @param dur A chrono duration.
		75	+ * @return A timeval.
		76	+ */
		77	+template<class Rep, class Period>
		78	+timeval to_timeval(const std::chrono::duration<Rep,Period>& dur) {
		79	+ return to_timeval(std::chrono::duration_cast<std::chrono::microseconds>(dur));
		80	+}
		81	+
		82	+/**
		83	+ * Converts a relative timeval to a chrono duration.
		84	+ * @param tv A timeval.
		85	+ * @return A chrono duration.
		86	+ */
		87	+inline std::chrono::microseconds to_duration(const timeval& tv)
		88	+{
		89	+ auto dur = std::chrono::seconds{tv.tv_sec}
		90	+ + std::chrono::microseconds{tv.tv_usec};
		91	+ return std::chrono::duration_cast<std::chrono::microseconds>(dur);
		92	+}
		93	+
		94	+/**
		95	+ * Converts an absolute timeval to a chrono time_point.
		96	+ * @param tv A timeval.
		97	+ * @return A chrono time_point.
		98	+ */
		99	+inline std::chrono::system_clock::time_point to_timepoint(const timeval& tv)
		100	+{
		101	+ return std::chrono::system_clock::time_point {
		102	+ std::chrono::duration_cast<std::chrono::system_clock::duration>(to_duration(tv))
		103	+ };
		104	+}
		105	+
		106	+/////////////////////////////////////////////////////////////////////////////
		107	+
		108	+/**
		109	+ * Base class for socket objects.
		110	+ *
		111	+ * This class wraps an OS socket handle and maintains strict ownership
		112	+ * semantics. If a socket object has a valid, open socket, then it owns the
		113	+ * handle and will close it when the object is destroyed.
		114	+ *
		115	+ * Objects of this class are not copyable, but they are moveable.
		116	+ */
		117	+class socket
		118	+{
		119	+ /** The OS integer socket handle */
		120	+ socket_t handle_;
		121	+ /** Cache of the last error (errno) */
		122	+ mutable int lastErr_;
		123	+ /**
		124	+ * The OS-specific function to close a socket handle/
		125	+ * @param h The OS socket handle.
		126	+ * @return @em true if the sock is closed, @em false on error.
		127	+ */
		128	+ bool close(socket_t h);
		129	+
		130	+ // Non-copyable.
		131	+ socket(const socket&) =delete;
		132	+ socket& operator=(const socket&) =delete;
		133	+
		134	+protected:
		135	+ /**
		136	+ * Closes the socket without checking for errors or updating the last
		137	+ * error.
		138	+ * This is used in internal open/connect type functions that fail after
		139	+ * creating the socket, but want to preserve the previous failure
		140	+ * condition.
		141	+ * Assumes that the socket handle is valid.
		142	+ * @return Always returns @em false.
		143	+ */
		144	+ bool close_on_err() {
		145	+ close(release());
		146	+ return false;
		147	+ }
		148	+ /**
		149	+ * OS-specific means to retrieve the last error from an operation.
		150	+ * This should be called after a failed system call to set the
		151	+ * lastErr_ member variable. Normally this would be called from
		152	+ * @ref check_ret.
		153	+ */
		154	+ static int get_last_error();
		155	+ /**
		156	+ * Cache the last system error code into this object.
		157	+ * This should be called after a failed system call to store the error
		158	+ * value.
		159	+ */
		160	+ void set_last_error() {
		161	+ lastErr_ = get_last_error();
		162	+ }
		163	+ /**
		164	+ * Checks the value and if less than zero, sets last error.
		165	+ * @tparam T A signed integer type of any size
		166	+ * @param ret The return value from a library or system call.
		167	+ * @return Returns the value sent to it, `ret`.
		168	+ */
		169	+ template <typename T>
		170	+ T check_ret(T ret) const{
		171	+ lastErr_ = (ret < 0) ? get_last_error() : 0;
		172	+ return ret;
		173	+ }
		174	+ /**
		175	+ * Checks the value and if less than zero, sets last error.
		176	+ * @tparam T A signed integer type of any size
		177	+ * @param ret The return value from a library or system call.
		178	+ * @return @em true if the value is a typical system success value (>=0)
		179	+ * or @em false is is an error (<0)
		180	+ */
		181	+ template <typename T>
		182	+ bool check_ret_bool(T ret) const{
		183	+ lastErr_ = (ret < 0) ? get_last_error() : 0;
		184	+ return ret >= 0;
		185	+ }
		186	+ /**
		187	+ * Checks the value and if it is not a valid socket, sets last error.
		188	+ * This is specifically required for Windows which uses an unsigned type
		189	+ * for its SOCKET.
		190	+ * @param ret The return value from a library or system call that returns
		191	+ * a socket, such as socket() or accept().
		192	+ * @return Returns the value sent to it, `ret`.
		193	+ */
		194	+ socket_t check_socket(socket_t ret) const {
		195	+ lastErr_ = (ret == INVALID_SOCKET) ? get_last_error() : 0;
		196	+ return ret;
		197	+ }
		198	+ /**
		199	+ * Checks the value and if it is INVALID_SOCKET, sets last error.
		200	+ * This is specifically required for Windows which uses an unsigned type
		201	+ * for its SOCKET.
		202	+ * @param ret The return value from a library or system call that returns
		203	+ * a socket such as socket() or accept().
		204	+ * @return @em true if the value is a valid socket (not INVALID_SOCKET)
		205	+ * or @em false is is an error (INVALID_SOCKET)
		206	+ */
		207	+ bool check_socket_bool(socket_t ret) const{
		208	+ lastErr_ = (ret == INVALID_SOCKET) ? get_last_error() : 0;
		209	+ return ret != INVALID_SOCKET;
		210	+ }
		211	+
		212	+public:
		213	+ /**
		214	+ * Creates an unconnected (invalid) socket
		215	+ */
		216	+ socket() : handle_(INVALID_SOCKET), lastErr_(0) {}
		217	+ /**
		218	+ * Creates a socket from an existing OS socket handle.
		219	+ * The object takes ownership of the handle and will close it when
		220	+ * destroyed.
		221	+ * @param h An OS socket handle.
		222	+ */
		223	+ explicit socket(socket_t h) : handle_(h), lastErr_(0) {}
		224	+ /**
		225	+ * Move constructor.
		226	+ * This takes ownership of the underlying handle in sock.
		227	+ * @param sock An rvalue reference to a socket object.
		228	+ */
		229	+ socket(socket&& sock) noexcept
		230	+ : handle_(sock.handle_), lastErr_(sock.lastErr_) {
		231	+ sock.handle_ = INVALID_SOCKET;
		232	+ }
		233	+ /**
		234	+ * Destructor closes the socket.
		235	+ */
		236	+ virtual ~socket() { close(); }
		237	+ /**
		238	+ * Initializes the socket (sockpp) library.
		239	+ * This is only required for Win32. On platforms that use a standard
		240	+ * socket implementation this is an empty call.
		241	+ */
		242	+ static void initialize();
		243	+ /**
		244	+ * Shuts down the socket library.
		245	+ * This is only required for Win32. On platforms that use a standard
		246	+ * socket implementation this is an empty call.
		247	+ */
		248	+ static void destroy();
		249	+ /**
		250	+ * Creates a socket with the specified communications characterics.
		251	+ * Not that this is not normally how a socket is creates in the sockpp
		252	+ * library. Applications would typically create a connector (client) or
		253	+ * acceptor (server) socket which would take care of the details.
		254	+ *
		255	+ * This is included for completeness or for creating different types of
		256	+ * sockets than are supported by the library.
		257	+ *
		258	+ * @param domain The communications domain for the sockets (i.e. the
		259	+ * address family)
		260	+ * @param type The communication semantics for the sockets (SOCK_STREAM,
		261	+ * SOCK_DGRAM, etc).
		262	+ * @param protocol The particular protocol to be used with the sockets
		263	+ *
		264	+ * @return A socket with the requested communications characteristics.
		265	+ */
		266	+ static socket create(int domain, int type, int protocol=0);
		267	+ /**
		268	+ * Determines if the socket is open (valid).
		269	+ * @return @em true if the socket is open, @em false otherwise.
		270	+ */
		271	+ bool is_open() const { return handle_ != INVALID_SOCKET; }
		272	+ /**
		273	+ * Determines if the socket is closed or in an error state.
		274	+ * @return @em true if the socket is closed or in an error state, @em
		275	+ * false otherwise.
		276	+ */
		277	+ bool operator!() const {
		278	+ return handle_ == INVALID_SOCKET \|\| lastErr_ != 0;
		279	+ }
		280	+ /**
		281	+ * Determines if the socket is open and in an error-free state.
		282	+ * @return @em true if the socket is open and in an error-free state,
		283	+ * @em false otherwise.
		284	+ */
		285	+ explicit operator bool() const {
		286	+ return handle_ != INVALID_SOCKET && lastErr_ == 0;
		287	+ }
		288	+ /**
		289	+ * Get the underlying OS socket handle.
		290	+ * @return The underlying OS socket handle.
		291	+ */
		292	+ socket_t handle() const { return handle_; }
		293	+ /**
		294	+ * Gets the network family of the address to which the socket is bound.
		295	+ * @return The network family of the address (AF_INET, etc) to which the
		296	+ * socket is bound. If the socket is not bound, or the address
		297	+ * is not known, returns AF_UNSPEC.
		298	+ */
		299	+ virtual sa_family_t family() const {
		300	+ return address().family();
		301	+ }
		302	+ /**
		303	+ * Creates a new socket that refers to this one.
		304	+ * This creates a new object with an independent lifetime, but refers
		305	+ * back to this same socket. On most systems, this duplicates the file
		306	+ * handle using the dup() call.
		307	+ * A typical use of this is to have separate threads for reading and
		308	+ * writing the socket. One thread would get the original socket and the
		309	+ * other would get the cloned one.
		310	+ * @return A new socket object that refers to the same socket as this
		311	+ * one.
		312	+ */
		313	+ socket clone() const;
		314	+ /**
		315	+ * Creates a pair of connected sockets.
		316	+ *
		317	+ * Whether this will work at all is highly system and domain dependent.
		318	+ * Currently it is only known to work for Unix-domain sockets on *nix
		319	+ * systems.
		320	+ *
		321	+ * Note that applications would normally call this from a derived socket
		322	+ * class which would return the properly type-cast sockets to match the
		323	+ * `domain` and `type`.
		324	+ *
		325	+ * @param domain The communications domain for the sockets (i.e. the
		326	+ * address family)
		327	+ * @param type The communication semantics for the sockets (SOCK_STREAM,
		328	+ * SOCK_DGRAM, etc).
		329	+ * @param protocol The particular protocol to be used with the sockets
		330	+ *
		331	+ * @return A std::tuple of sockets. On error both sockets will be in an
		332	+ * error state with the
		333	+ */
		334	+ static std::tuple<socket, socket> pair(int domain, int type, int protocol=0);
		335	+ /**
		336	+ * Clears the error flag for the object.
		337	+ * @param val The value to set the flag, normally zero.
		338	+ */
		339	+ void clear(int val=0) { lastErr_ = val; }
		340	+ /**
		341	+ * Releases ownership of the underlying socket object.
		342	+ * @return The OS socket handle.
		343	+ */
		344	+ socket_t release() {
		345	+ socket_t h = handle_;
		346	+ handle_ = INVALID_SOCKET;
		347	+ return h;
		348	+ }
		349	+ /**
		350	+ * Replaces the underlying managed socket object.
		351	+ * @param h The new socket handle to manage.
		352	+ */
		353	+ void reset(socket_t h=INVALID_SOCKET);
		354	+ /**
		355	+ * Move assignment.
		356	+ * This assigns ownership of the socket from the other object to this
		357	+ * one.
		358	+ * @return A reference to this object.
		359	+ */
		360	+ socket& operator=(socket&& sock) noexcept {
		361	+ // Give our handle to the other to close.
		362	+ std::swap(handle_, sock.handle_);
		363	+ lastErr_ = sock.lastErr_;
		364	+ return *this;
		365	+ }
		366	+ /**
		367	+ * Binds the socket to the specified address.
		368	+ * @param addr The address to which we get bound.
		369	+ * @return @em true on success, @em false on error
		370	+ */
		371	+ bool bind(const sock_address& addr);
		372	+ /**
		373	+ * Gets the local address to which the socket is bound.
		374	+ * @return The local address to which the socket is bound.
		375	+ */
		376	+ sock_address_any address() const;
		377	+ /**
		378	+ * Gets the address of the remote peer, if this socket is connected.
		379	+ * @return The address of the remote peer, if this socket is connected.
		380	+ */
		381	+ sock_address_any peer_address() const;
		382	+ /**
		383	+ * Gets the value of a socket option.
		384	+ *
		385	+ * This is a thin wrapper for the system `getsockopt`.
		386	+ *
		387	+ * @param level The protocol level at which the option resides, such as
		388	+ * SOL_SOCKET.
		389	+ * @param optname The option passed directly to the protocol module.
		390	+ * @param optval The buffer for the value to retrieve
		391	+ * @param optlen Initially contains the lenth of the buffer, and on return
		392	+ * contains the length of the value retrieved.
		393	+ *
		394	+ * @return bool @em true if the value was retrieved, @em false if an error
		395	+ * occurred.
		396	+ */
		397	+ bool get_option(int level, int optname, void* optval, socklen_t* optlen) const;
		398	+ /**
		399	+ * Gets the value of a socket option.
		400	+ *
		401	+ * @param level The protocol level at which the option resides, such as
		402	+ * SOL_SOCKET.
		403	+ * @param optname The option passed directly to the protocol module.
		404	+ * @param val The value to retrieve
		405	+ * @return bool @em true if the value was retrieved, @em false if an error
		406	+ * occurred.
		407	+ */
		408	+ template <typename T>
		409	+ bool get_option(int level, int optname, T* val) const {
		410	+ socklen_t len = sizeof(T);
		411	+ return get_option(level, optname, (void*) val, &len);
		412	+ }
		413	+ /**
		414	+ * Sets the value of a socket option.
		415	+ *
		416	+ * This is a thin wrapper for the system `setsockopt`.
		417	+ *
		418	+ * @param level The protocol level at which the option resides, such as
		419	+ * SOL_SOCKET.
		420	+ * @param optname The option passed directly to the protocol module.
		421	+ * @param optval The buffer with the value to set.
		422	+ * @param optlen Contains the lenth of the value buffer.
		423	+ *
		424	+ * @return bool @em true if the value was set, @em false if an error
		425	+ * occurred.
		426	+ */
		427	+ bool set_option(int level, int optname, const void* optval, socklen_t optlen);
		428	+ /**
		429	+ * Sets the value of a socket option.
		430	+ *
		431	+ * @param level The protocol level at which the option resides, such as
		432	+ * SOL_SOCKET.
		433	+ * @param optname The option passed directly to the protocol module.
		434	+ * @param val The value to set.
		435	+ *
		436	+ * @return bool @em true if the value was set, @em false if an error
		437	+ * occurred.
		438	+ */
		439	+ template <typename T>
		440	+ bool set_option(int level, int optname, const T& val) {
		441	+ return set_option(level, optname, (void*) &val, sizeof(T));
		442	+ }
		443	+ /**
		444	+ * Places the socket into or out of non-blocking mode.
		445	+ * When in non-blocking mode, a call that is not immediately ready to
		446	+ * complete (read, write, accept, etc) will return immediately with the
		447	+ * error EWOULDBLOCK.
		448	+ * @param on Whether to turn non-blocking mode on or off.
		449	+ * @return @em true on success, @em false on failure.
		450	+ */
		451	+ bool set_non_blocking(bool on=true);
		452	+ /**
		453	+ * Gets a string describing the specified error.
		454	+ * This is typically the returned message from the system strerror().
		455	+ * @param errNum The error number.
		456	+ * @return A string describing the specified error.
		457	+ */
		458	+ static std::string error_str(int errNum);
		459	+ /**
		460	+ * Gets the code for the last errror.
		461	+ * This is typically the code from the underlying OS operation.
		462	+ * @return The code for the last errror.
		463	+ */
		464	+ int last_error() const { return lastErr_; }
		465	+ /**
		466	+ * Gets a string describing the last errror.
		467	+ * This is typically the returned message from the system strerror().
		468	+ * @return A string describing the last errror.
		469	+ */
		470	+ std::string last_error_str() const {
		471	+ return error_str(lastErr_);
		472	+ }
		473	+ /**
		474	+ * Shuts down all or part of the full-duplex connection.
		475	+ * @param how Which part of the connection should be shut:
		476	+ * @li SHUT_RD (0) Further reads disallowed.
		477	+ * @li SHUT_WR (1) Further writes disallowed
		478	+ * @li SHUT_RDWR (2) Further reads and writes disallowed.
		479	+ * @return @em true on success, @em false on error.
		480	+ */
		481	+ bool shutdown(int how=SHUT_RDWR);
		482	+ /**
		483	+ * Closes the socket.
		484	+ * After closing the socket, the handle is @em invalid, and can not be
		485	+ * used again until reassigned.
		486	+ * @return @em true if the sock is closed, @em false on error.
		487	+ */
		488	+ bool close();
		489	+};
		490	+
		491	+/////////////////////////////////////////////////////////////////////////////
		492	+
		493	+/**
		494	+ * RAII class to initialize and then shut down the library.
		495	+ * A single object of this class can be declared before any other classes in
		496	+ * the library are used. The lifetime of the object should span the use of
		497	+ * the other classes in the library, so declaring an object at the top of
		498	+ * main() is usually the best choice.
		499	+ * This is only required on some platforms, particularly Windows, but is
		500	+ * harmless on other platforms. On some, such as POSIX, the initializer sets
		501	+ * optional parameters for the library, and the destructor does nothing.
		502	+ */
		503	+class socket_initializer
		504	+{
		505	+public:
		506	+ socket_initializer() { socket::initialize(); }
		507	+ ~socket_initializer() { socket::destroy(); }
		508	+};
		509	+
		510	+/////////////////////////////////////////////////////////////////////////////
		511	+// end namespace sockpp
		512	+}
		513	+
		514	+#endif // __sockpp_socket_h
		515	+

include/socket-cpp/stream_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/stream_socket.h
		1	+/**
		2	+ * @file stream_socket.h
		3	+ *
		4	+ * Classes for stream sockets.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date December 2014
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2017 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_stream_socket_h
		48	+#define __sockpp_stream_socket_h
		49	+
		50	+#include "sockpp/socket.h"
		51	+#include <vector>
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/**
		58	+ * Base class for streaming sockets, such as TCP and Unix Domain.
		59	+ * This is the streaming connection between two peers. It looks like a
		60	+ * readable/writeable device.
		61	+ */
		62	+class stream_socket : public socket
		63	+{
		64	+ /** The base class */
		65	+ using base = socket;
		66	+
		67	+protected:
		68	+ /** Acceptor can create stream sockets. */
		69	+ friend class acceptor;
		70	+
		71	+ /**
		72	+ * Creates a streaming socket.
		73	+ * @return An OS handle to a stream socket.
		74	+ */
		75	+ static socket_t create_handle(int domain) {
		76	+ return (socket_t) ::socket(domain, COMM_TYPE, 0);
		77	+ }
		78	+
		79	+public:
		80	+ /** The socket 'type' for communications semantics. */
		81	+ static constexpr int COMM_TYPE = SOCK_STREAM;
		82	+ /**
		83	+ * Creates an unconnected streaming socket.
		84	+ */
		85	+ stream_socket() {}
		86	+ /**
		87	+ * Creates a streaming socket from an existing OS socket handle and
		88	+ * claims ownership of the handle.
		89	+ * @param handle A socket handle from the operating system.
		90	+ */
		91	+ explicit stream_socket(socket_t handle) : base(handle) {}
		92	+ /**
		93	+ * Creates a stream socket by copying the socket handle from the
		94	+ * specified socket object and transfers ownership of the socket.
		95	+ */
		96	+ stream_socket(stream_socket&& sock) : base(std::move(sock)) {}
		97	+
		98	+
		99	+ /**
		100	+ * Creates a socket with the specified communications characterics.
		101	+ * Not that this is not normally how a socket is creates in the sockpp
		102	+ * library. Applications would typically create a connector (client) or
		103	+ * acceptor (server) socket which would take care of the details.
		104	+ *
		105	+ * This is included for completeness or for creating different types of
		106	+ * sockets than are supported by the library.
		107	+ *
		108	+ * @param domain The communications domain for the sockets (i.e. the
		109	+ * address family)
		110	+ * @param protocol The particular protocol to be used with the sockets
		111	+ *
		112	+ * @return A stream socket with the requested communications
		113	+ * characteristics.
		114	+ */
		115	+ static stream_socket create(int domain, int protocol=0);
		116	+
		117	+ /**
		118	+ * Move assignment.
		119	+ * @param rhs The other socket to move into this one.
		120	+ * @return A reference to this object.
		121	+ */
		122	+ stream_socket& operator=(stream_socket&& rhs) {
		123	+ base::operator=(std::move(rhs));
		124	+ return *this;
		125	+ }
		126	+ /**
		127	+ * Creates a new stream_socket that refers to this one.
		128	+ * This creates a new object with an independent lifetime, but refers
		129	+ * back to this same socket. On most systems, this duplicates the file
		130	+ * handle using the dup() call.
		131	+ * A typical use of this is to have separate threads for reading and
		132	+ * writing the socket. One thread would get the original socket and the
		133	+ * other would get the cloned one.
		134	+ * @return A new stream socket object that refers to the same socket as
		135	+ * this one.
		136	+ */
		137	+ stream_socket clone() const {
		138	+ auto h = base::clone().release();
		139	+ return stream_socket(h);
		140	+ }
		141	+ /**
		142	+ * Reads from the port
		143	+ * @param buf Buffer to get the incoming data.
		144	+ * @param n The number of bytes to try to read.
		145	+ * @return The number of bytes read on success, or @em -1 on error.
		146	+ */
		147	+ virtual ssize_t read(void *buf, size_t n);
		148	+ /**
		149	+ * Best effort attempts to read the specified number of bytes.
		150	+ * This will make repeated read attempts until all the bytes are read in
		151	+ * or until an error occurs.
		152	+ * @param buf Buffer to get the incoming data.
		153	+ * @param n The number of bytes to try to read.
		154	+ * @return The number of bytes read on success, or @em -1 on error. If
		155	+ * successful, the number of bytes read should always be 'n'.
		156	+ */
		157	+ virtual ssize_t read_n(void *buf, size_t n);
		158	+ /**
		159	+ * Reads discontiguous memory ranges from the socket.
		160	+ * @param ranges The vector of memory ranges to fill
		161	+ * @return The number of bytes read, or @em -1 on error.
		162	+ */
		163	+ ssize_t read(const std::vector<iovec>& ranges);
		164	+ /**
		165	+ * Set a timeout for read operations.
		166	+ * Sets the timeout that the device uses for read operations. Not all
		167	+ * devices support timeouts, so the caller should prepare for failure.
		168	+ * @param to The amount of time to wait for the operation to complete.
		169	+ * @return @em true on success, @em false on failure.
		170	+ */
		171	+ virtual bool read_timeout(const std::chrono::microseconds& to);
		172	+ /**
		173	+ * Set a timeout for read operations.
		174	+ * Sets the timout that the device uses for read operations. Not all
		175	+ * devices support timouts, so the caller should prepare for failure.
		176	+ * @param to The amount of time to wait for the operation to complete.
		177	+ * @return @em true on success, @em false on failure.
		178	+ */
		179	+ template<class Rep, class Period>
		180	+ bool read_timeout(const std::chrono::duration<Rep,Period>& to) {
		181	+ return read_timeout(std::chrono::duration_cast<std::chrono::microseconds>(to));
		182	+ }
		183	+ /**
		184	+ * Writes the buffer to the socket.
		185	+ * @param buf The buffer to write
		186	+ * @param n The number of bytes in the buffer.
		187	+ * @return The number of bytes written, or @em -1 on error.
		188	+ */
		189	+ virtual ssize_t write(const void *buf, size_t n);
		190	+ /**
		191	+ * Best effort attempt to write the whole buffer to the socket.
		192	+ * @param buf The buffer to write
		193	+ * @param n The number of bytes in the buffer.
		194	+ * @return The number of bytes written, or @em -1 on error. If
		195	+ * successful, the number of bytes written should always be 'n'.
		196	+ */
		197	+ virtual ssize_t write_n(const void *buf, size_t n);
		198	+ /**
		199	+ * Best effort attempt to write a string to the socket.
		200	+ * @param s The string to write.
		201	+ * @return The number of bytes written, or @em -1 on error. On success,
		202	+ * the number of bytes written should always be the length of
		203	+ * the string.
		204	+ */
		205	+ virtual ssize_t write(const std::string& s) {
		206	+ return write_n(s.data(), s.size());
		207	+ }
		208	+ /**
		209	+ * Writes discontiguous memory ranges to the socket.
		210	+ * @param ranges The vector of memory ranges to write
		211	+ * @return The number of bytes written, or @em -1 on error.
		212	+ */
		213	+ virtual ssize_t write(const std::vector<iovec> &ranges);
		214	+ /**
		215	+ * Set a timeout for write operations.
		216	+ * Sets the timout that the device uses for write operations. Not all
		217	+ * devices support timouts, so the caller should prepare for failure.
		218	+ * @param to The amount of time to wait for the operation to complete.
		219	+ * @return @em true on success, @em false on failure.
		220	+ */
		221	+ virtual bool write_timeout(const std::chrono::microseconds& to);
		222	+ /**
		223	+ * Set a timeout for write operations.
		224	+ * Sets the timout that the device uses for write operations. Not all
		225	+ * devices support timouts, so the caller should prepare for failure.
		226	+ * @param to The amount of time to wait for the operation to complete.
		227	+ * @return @em true on success, @em false on failure.
		228	+ */
		229	+ template<class Rep, class Period>
		230	+ bool write_timeout(const std::chrono::duration<Rep,Period>& to) {
		231	+ return write_timeout(std::chrono::duration_cast<std::chrono::microseconds>(to));
		232	+ }
		233	+};
		234	+
		235	+/////////////////////////////////////////////////////////////////////////////
		236	+
		237	+/**
		238	+ * Template for creating specific stream types (IPv4, IPv6, etc).
		239	+ * This just overrides methods that take a generic address and replace them
		240	+ * with the address type for a specific family. This doesn't add any
		241	+ * runtime functionality, but has compile-time checks that address types
		242	+ * aren't accidentally being mixed for an object.
		243	+ */
		244	+template <typename ADDR>
		245	+class stream_socket_tmpl : public stream_socket
		246	+{
		247	+ /** The base class */
		248	+ using base = stream_socket;
		249	+
		250	+public:
		251	+ /** The address family for this type of address */
		252	+ static constexpr sa_family_t ADDRESS_FAMILY = ADDR::ADDRESS_FAMILY;
		253	+ /** The type of network address used with this socket. */
		254	+ using addr_t = ADDR;
		255	+ /**
		256	+ * Creates an unconnected streaming socket.
		257	+ */
		258	+ stream_socket_tmpl() {}
		259	+ /**
		260	+ * Creates a streaming socket from an existing OS socket handle and
		261	+ * claims ownership of the handle.
		262	+ * @param handle A socket handle from the operating system.
		263	+ */
		264	+ explicit stream_socket_tmpl(socket_t handle) : base(handle) {}
		265	+ /**
		266	+ * Move constructor.
		267	+ * Creates a stream socket by moving the other socket to this one.
		268	+ * @param sock Another stream socket.
		269	+ */
		270	+ stream_socket_tmpl(stream_socket&& sock)
		271	+ : base(std::move(sock)) {}
		272	+ /**
		273	+ * Creates a stream socket by copying the socket handle from the
		274	+ * specified socket object and transfers ownership of the socket.
		275	+ */
		276	+ stream_socket_tmpl(stream_socket_tmpl&& sock)
		277	+ : base(std::move(sock)) {}
		278	+ /**
		279	+ * Move assignment.
		280	+ * @param rhs The other socket to move into this one.
		281	+ * @return A reference to this object.
		282	+ */
		283	+ stream_socket_tmpl& operator=(stream_socket_tmpl&& rhs) {
		284	+ base::operator=(std::move(rhs));
		285	+ return *this;
		286	+ }
		287	+ /**
		288	+ * Cretates a stream socket.
		289	+ * @param protocol The particular protocol to be used with the sockets
		290	+ * @return A stream socket
		291	+ */
		292	+ stream_socket_tmpl create(int protocol=0) {
		293	+ return stream_socket_tmpl(std::move(base::create(ADDRESS_FAMILY, protocol)));
		294	+ }
		295	+ /**
		296	+ * Creates a pair of connected stream sockets.
		297	+ *
		298	+ * Whether this will work at all is highly system and domain dependent.
		299	+ * Currently it is only known to work for Unix-domain sockets on *nix
		300	+ * systems.
		301	+ *
		302	+ * @param protocol The protocol to be used with the socket. (Normally 0)
		303	+ *
		304	+ * @return A std::tuple of stream sockets. On error both sockets will be
		305	+ * in an error state with the last error set.
		306	+ */
		307	+ static std::tuple<stream_socket_tmpl, stream_socket_tmpl> pair(int protocol=0) {
		308	+ auto pr = base::pair(ADDRESS_FAMILY, COMM_TYPE, protocol);
		309	+ return std::make_tuple<stream_socket_tmpl, stream_socket_tmpl>(
		310	+ stream_socket_tmpl{std::get<0>(pr).release()},
		311	+ stream_socket_tmpl{std::get<1>(pr).release()});
		312	+ }
		313	+ /**
		314	+ * Gets the local address to which the socket is bound.
		315	+ * @return The local address to which the socket is bound.
		316	+ * @throw sys_error on error
		317	+ */
		318	+ addr_t address() const { return addr_t(socket::address()); }
		319	+ /**
		320	+ * Gets the address of the remote peer, if this socket is connected.
		321	+ * @return The address of the remote peer, if this socket is connected.
		322	+ * @throw sys_error on error
		323	+ */
		324	+ addr_t peer_address() const { return addr_t(socket::peer_address()); }
		325	+};
		326	+
		327	+/////////////////////////////////////////////////////////////////////////////
		328	+// end namespace sockpp
		329	+}
		330	+
		331	+#endif // __sockpp_socket_h
		332	+

include/socket-cpp/tcp6_acceptor.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp6_acceptor.h
		1	+/// @file tcp6_acceptor.h
		2	+///
		3	+/// Class for a TCP v6 server to accept incoming connections.
		4	+///
		5	+/// @author Frank Pagliughi
		6	+/// @author SoRo Systems, Inc.
		7	+/// @author www.sorosys.com
		8	+///
		9	+/// @date May 2019
		10	+
		11	+// --------------------------------------------------------------------------
		12	+// This file is part of the "sockpp" C++ socket library.
		13	+//
		14	+// Copyright (c) 2019 Frank Pagliughi
		15	+// All rights reserved.
		16	+//
		17	+// Redistribution and use in source and binary forms, with or without
		18	+// modification, are permitted provided that the following conditions are
		19	+// met:
		20	+//
		21	+// 1. Redistributions of source code must retain the above copyright notice,
		22	+// this list of conditions and the following disclaimer.
		23	+//
		24	+// 2. Redistributions in binary form must reproduce the above copyright
		25	+// notice, this list of conditions and the following disclaimer in the
		26	+// documentation and/or other materials provided with the distribution.
		27	+//
		28	+// 3. Neither the name of the copyright holder nor the names of its
		29	+// contributors may be used to endorse or promote products derived from this
		30	+// software without specific prior written permission.
		31	+//
		32	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		33	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		34	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		35	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		36	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		37	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		38	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		39	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		40	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		41	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		42	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		43	+// --------------------------------------------------------------------------
		44	+
		45	+#ifndef __sockpp_tcp6_acceptor_h
		46	+#define __sockpp_tcp6_acceptor_h
		47	+
		48	+#include "sockpp/acceptor.h"
		49	+#include "sockpp/tcp6_socket.h"
		50	+
		51	+namespace sockpp {
		52	+
		53	+/////////////////////////////////////////////////////////////////////////////
		54	+
		55	+/// Class for creating a TCP v6 server.
		56	+/// Objects of this class bind and listen on TCP ports for incoming
		57	+/// connections. Normally, a server thread creates one of these and blocks
		58	+/// on the call to accept incoming connections. The call to accept creates
		59	+/// and returns a @ref tcp6_socket which can then be used for the actual
		60	+/// communications.
		61	+
		62	+using tcp6_acceptor = acceptor_tmpl<tcp6_socket>;
		63	+
		64	+/////////////////////////////////////////////////////////////////////////////
		65	+// end namespace sockpp
		66	+};
		67	+
		68	+#endif // __sockpp_tcp_acceptor_h
		69	+

include/socket-cpp/tcp6_connector.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp6_connector.h
		1	+/**
		2	+ * @file tcp6_connector.h
		3	+ *
		4	+ * Class for creating client-side TCP connections
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date May 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+
		48	+#ifndef __sockpp_tcp6_connector_h
		49	+#define __sockpp_tcp6_connector_h
		50	+
		51	+#include "sockpp/connector.h"
		52	+#include "sockpp/tcp6_socket.h"
		53	+
		54	+namespace sockpp {
		55	+
		56	+/////////////////////////////////////////////////////////////////////////////
		57	+
		58	+/** IPv6 active, connector (client) socket. */
		59	+using tcp6_connector = connector_tmpl<tcp6_socket>;
		60	+
		61	+/////////////////////////////////////////////////////////////////////////////
		62	+// end namespace sockpp
		63	+}
		64	+
		65	+#endif // __sockpp_tcp6_connector_h
		66	+

include/socket-cpp/tcp6_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp6_socket.h
		1	+/**
		2	+ * @file tcp6_socket.h
		3	+ *
		4	+ * Class (typedef) for IPv6 TCP socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_tcp6_socket_h
		48	+#define __sockpp_tcp6_socket_h
		49	+
		50	+#include "sockpp/stream_socket.h"
		51	+#include "sockpp/inet6_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** IPv6 streaming TCP socket */
		58	+using tcp6_socket = stream_socket_tmpl<inet6_address>;
		59	+
		60	+/////////////////////////////////////////////////////////////////////////////
		61	+// end namespace sockpp
		62	+}
		63	+
		64	+#endif // __sockpp_tcp6_socket_h
		65	+

include/socket-cpp/tcp_acceptor.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp_acceptor.h
		1	+/// @file tcp_acceptor.h
		2	+///
		3	+/// Class for a TCP server to accept incoming connections.
		4	+///
		5	+/// @author Frank Pagliughi
		6	+/// @author SoRo Systems, Inc.
		7	+/// @author www.sorosys.com
		8	+///
		9	+/// @date December 2014
		10	+
		11	+// --------------------------------------------------------------------------
		12	+// This file is part of the "sockpp" C++ socket library.
		13	+//
		14	+// Copyright (c) 2014-2019 Frank Pagliughi
		15	+// All rights reserved.
		16	+//
		17	+// Redistribution and use in source and binary forms, with or without
		18	+// modification, are permitted provided that the following conditions are
		19	+// met:
		20	+//
		21	+// 1. Redistributions of source code must retain the above copyright notice,
		22	+// this list of conditions and the following disclaimer.
		23	+//
		24	+// 2. Redistributions in binary form must reproduce the above copyright
		25	+// notice, this list of conditions and the following disclaimer in the
		26	+// documentation and/or other materials provided with the distribution.
		27	+//
		28	+// 3. Neither the name of the copyright holder nor the names of its
		29	+// contributors may be used to endorse or promote products derived from this
		30	+// software without specific prior written permission.
		31	+//
		32	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		33	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		34	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		35	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		36	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		37	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		38	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		39	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		40	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		41	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		42	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		43	+// --------------------------------------------------------------------------
		44	+
		45	+#ifndef __sockpp_tcp_acceptor_h
		46	+#define __sockpp_tcp_acceptor_h
		47	+
		48	+#include "sockpp/acceptor.h"
		49	+#include "sockpp/tcp_socket.h"
		50	+
		51	+namespace sockpp {
		52	+
		53	+/////////////////////////////////////////////////////////////////////////////
		54	+
		55	+/// Class for creating a TCP server.
		56	+/// Objects of this class bind and listen on TCP ports for incoming
		57	+/// connections. Normally, a server thread creates one of these and blocks
		58	+/// on the call to accept incoming connections. The call to accept creates
		59	+/// and returns a @ref tcp_socket which can then be used for the actual
		60	+/// communications.
		61	+
		62	+using tcp_acceptor = acceptor_tmpl<tcp_socket>;
		63	+
		64	+/////////////////////////////////////////////////////////////////////////////
		65	+// end namespace sockpp
		66	+};
		67	+
		68	+#endif // __sockpp_tcp_acceptor_h
		69	+

include/socket-cpp/tcp_connector.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp_connector.h
		1	+/**
		2	+ * @file tcp_connector.h
		3	+ *
		4	+ * Class for creating client-side TCP connections
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date December 2014
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+
		48	+#ifndef __sockpp_tcp_connector_h
		49	+#define __sockpp_tcp_connector_h
		50	+
		51	+#include "sockpp/connector.h"
		52	+#include "sockpp/tcp_socket.h"
		53	+
		54	+namespace sockpp {
		55	+
		56	+/////////////////////////////////////////////////////////////////////////////
		57	+
		58	+/** IPv4 active, connector (client) socket. */
		59	+using tcp_connector = connector_tmpl<tcp_socket>;
		60	+
		61	+/////////////////////////////////////////////////////////////////////////////
		62	+// end namespace sockpp
		63	+};
		64	+
		65	+#endif // __sockpp_tcp_connector_h

include/socket-cpp/tcp_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/tcp_socket.h
		1	+/**
		2	+ * @file tcp_socket.h
		3	+ *
		4	+ * Class (typedef) for IPv4 TCP socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_tcp_socket_h
		48	+#define __sockpp_tcp_socket_h
		49	+
		50	+#include "sockpp/stream_socket.h"
		51	+#include "sockpp/inet_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** IPv4 streaming TCP socket */
		58	+using tcp_socket = stream_socket_tmpl<inet_address>;
		59	+
		60	+/////////////////////////////////////////////////////////////////////////////
		61	+// end namespace sockpp
		62	+}
		63	+
		64	+#endif // __sockpp_tcp_socket_h
		65	+

include/socket-cpp/udp6_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/udp6_socket.h
		1	+/**
		2	+ * @file udp6_socket.h
		3	+ *
		4	+ * Class (typedef) for UDP v6 socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_udp6_socket_h
		48	+#define __sockpp_udp6_socket_h
		49	+
		50	+#include "sockpp/datagram_socket.h"
		51	+#include "sockpp/inet6_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** UDP datagram socket type for IPv6 */
		58	+using udp6_socket = datagram_socket_tmpl<inet6_address>;
		59	+
		60	+/////////////////////////////////////////////////////////////////////////////
		61	+// end namespace sockpp
		62	+}
		63	+
		64	+#endif // __sockpp_udp6_socket_h
		65	+

include/socket-cpp/udp_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/udp_socket.h
		1	+/**
		2	+ * @file udp_socket.h
		3	+ *
		4	+ * Class (typedef) for UDP v4 socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_udp_socket_h
		48	+#define __sockpp_udp_socket_h
		49	+
		50	+#include "sockpp/datagram_socket.h"
		51	+#include "sockpp/inet_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** UDP datagram socket type for IPv4 */
		58	+using udp_socket = datagram_socket_tmpl<inet_address>;
		59	+
		60	+/////////////////////////////////////////////////////////////////////////////
		61	+// end namespace sockpp
		62	+}
		63	+
		64	+#endif // __sockpp_udp_socket_h
		65	+

include/socket-cpp/unix_acceptor.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/unix_acceptor.h
		1	+/// @file unix_acceptor.h
		2	+///
		3	+/// Class for a TCP server to accept incoming connections.
		4	+///
		5	+/// @author Frank Pagliughi
		6	+/// @author SoRo Systems, Inc.
		7	+/// @author www.sorosys.com
		8	+///
		9	+/// @date December 2014
		10	+
		11	+// --------------------------------------------------------------------------
		12	+// This file is part of the "sockpp" C++ socket library.
		13	+//
		14	+// Copyright (c) 2014-2017 Frank Pagliughi
		15	+// All rights reserved.
		16	+//
		17	+// Redistribution and use in source and binary forms, with or without
		18	+// modification, are permitted provided that the following conditions are
		19	+// met:
		20	+//
		21	+// 1. Redistributions of source code must retain the above copyright notice,
		22	+// this list of conditions and the following disclaimer.
		23	+//
		24	+// 2. Redistributions in binary form must reproduce the above copyright
		25	+// notice, this list of conditions and the following disclaimer in the
		26	+// documentation and/or other materials provided with the distribution.
		27	+//
		28	+// 3. Neither the name of the copyright holder nor the names of its
		29	+// contributors may be used to endorse or promote products derived from this
		30	+// software without specific prior written permission.
		31	+//
		32	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		33	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		34	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		35	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		36	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		37	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		38	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		39	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		40	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		41	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		42	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		43	+// --------------------------------------------------------------------------
		44	+
		45	+#ifndef __sockpp_unix_acceptor_h
		46	+#define __sockpp_unix_acceptor_h
		47	+
		48	+#include "sockpp/acceptor.h"
		49	+#include "sockpp/unix_stream_socket.h"
		50	+
		51	+namespace sockpp {
		52	+
		53	+/////////////////////////////////////////////////////////////////////////////
		54	+
		55	+/// Class for creating a Unix-domain server.
		56	+/// Objects of this class bind and listen on Unix-domain ports for
		57	+/// connections. Normally, a server thread creates one of these and blocks
		58	+/// on the call to accept incoming connections. The call to accept creates
		59	+/// and returns a @ref unix_stream_socket which can then be used for the
		60	+/// actual communications.
		61	+
		62	+class unix_acceptor : public acceptor
		63	+{
		64	+ /** The base class */
		65	+ using base = acceptor;
		66	+
		67	+ // Non-copyable
		68	+ unix_acceptor(const unix_acceptor&) =delete;
		69	+ unix_acceptor& operator=(const unix_acceptor&) =delete;
		70	+
		71	+public:
		72	+ /**
		73	+ * Creates an unconnected acceptor.
		74	+ */
		75	+ unix_acceptor() {}
		76	+ /**
		77	+ * Creates a acceptor and starts it listening on the specified address.
		78	+ * @param addr The TCP address on which to listen.
		79	+ * @param queSize The listener queue size.
		80	+ */
		81	+ unix_acceptor(const unix_address& addr, int queSize=DFLT_QUE_SIZE) {
		82	+ open(addr, queSize);
		83	+ }
		84	+ /**
		85	+ * Gets the local address to which we are bound.
		86	+ * @return The local address to which we are bound.
		87	+ */
		88	+ unix_address address() const { return unix_address(base::address()); }
		89	+ /**
		90	+ * Base open call also work.
		91	+ */
		92	+ using base::open;
		93	+ /**
		94	+ * Opens the acceptor socket and binds it to the specified address.
		95	+ * @param addr The address to which this server should be bound.
		96	+ * @param queSize The listener queue size.
		97	+ * @return @em true on success, @em false on error
		98	+ */
		99	+ bool open(const unix_address& addr, int queSize=DFLT_QUE_SIZE) {
		100	+ return base::open(addr, queSize);
		101	+ }
		102	+ /**
		103	+ * Accepts an incoming UNIX connection and gets the address of the
		104	+ * client.
		105	+ * @return A unix_socket to the client.
		106	+ */
		107	+ unix_socket accept() { return unix_socket(base::accept()); }
		108	+};
		109	+
		110	+/////////////////////////////////////////////////////////////////////////////
		111	+// end namespace sockpp
		112	+};
		113	+
		114	+#endif // __sockpp_unix_acceptor_h
		115	+

include/socket-cpp/unix_address.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/unix_address.h
		1	+/**
		2	+ * @file unix_address.h
		3	+ *
		4	+ * Class for a UNIX-domain socket address.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date February 2014
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2017 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_unix_addr_h
		48	+#define __sockpp_unix_addr_h
		49	+
		50	+#include "sockpp/platform.h"
		51	+#include "sockpp/sock_address.h"
		52	+#include <iostream>
		53	+#include <string>
		54	+#include <cstring>
		55	+#include <sys/un.h>
		56	+
		57	+namespace sockpp {
		58	+
		59	+/////////////////////////////////////////////////////////////////////////////
		60	+
		61	+/**
		62	+ * Class that represents a UNIX domain address.
		63	+ * This inherits from the UNIX form of a socket address, @em sockaddr_un.
		64	+ */
		65	+class unix_address : public sock_address
		66	+{
		67	+ /** The underlying C struct for unix-domain addresses */
		68	+ sockaddr_un addr_;
		69	+
		70	+ /** The size of the underlying address struct, in bytes */
		71	+ static constexpr size_t SZ = sizeof(sockaddr_un);
		72	+
		73	+public:
		74	+ /** The address family for this type of address */
		75	+ static constexpr sa_family_t ADDRESS_FAMILY = AF_UNIX;
		76	+
		77	+ // TODO: This only applies to Linux
		78	+ static constexpr size_t MAX_PATH_NAME = 108;
		79	+
		80	+ /**
		81	+ * Constructs an empty address.
		82	+ * The address is initialized to all zeroes.
		83	+ */
		84	+ unix_address() : addr_() {}
		85	+ /**
		86	+ * Constructs an address for the specified path.
		87	+ * @param path The
		88	+ */
		89	+ unix_address(const std::string& path);
		90	+ /**
		91	+ * Constructs the address by copying the specified structure.
		92	+ * @param addr The generic address
		93	+ * @throws std::invalid_argument if the address is not a UNIX-domain
		94	+ * address (i.e. family is not AF_UNIX)
		95	+ */
		96	+ explicit unix_address(const sockaddr& addr);
		97	+ /**
		98	+ * Constructs the address by copying the specified structure.
		99	+ * @param addr The other address
		100	+ */
		101	+ unix_address(const sock_address& addr) {
		102	+ std::memcpy(&addr_, addr.sockaddr_ptr(), SZ);
		103	+ }
		104	+ /**
		105	+ * Constructs the address by copying the specified structure.
		106	+ * @param addr The other address
		107	+ * @throws std::invalid_argument if the address is not properly
		108	+ * initialized as a UNIX-domain address (i.e. family is not
		109	+ * AF_UNIX)
		110	+ */
		111	+ unix_address(const sockaddr_un& addr) : addr_(addr) {}
		112	+ /**
		113	+ * Constructs the address by copying the specified address.
		114	+ * @param addr The other address
		115	+ */
		116	+ unix_address(const unix_address& addr) : addr_(addr.addr_) {}
		117	+ /**
		118	+ * Checks if the address is set to some value.
		119	+ * This doesn't attempt to determine if the address is valid, simply
		120	+ * that it's not all zero.
		121	+ * @return @em true if the address has been set, @em false otherwise.
		122	+ */
		123	+ bool is_set() const { return addr_.sun_path[0] != '\0'; }
		124	+ /**
		125	+ * Gets the path to which this address refers.
		126	+ * @return The path to which this address refers.
		127	+ */
		128	+ std::string path() const { return std::string(addr_.sun_path); }
		129	+ /**
		130	+ * Gets the size of the address structure.
		131	+ * Note: In this implementation, this should return sizeof(this) but
		132	+ * more convenient in some places, and the implementation might change
		133	+ * in the future, so it might be more compatible with future revisions
		134	+ * to use this call.
		135	+ * @return The size of the address structure.
		136	+ */
		137	+ socklen_t size() const override { return socklen_t(SZ); }
		138	+
		139	+ // TODO: Do we need a:
		140	+ // create(path)
		141	+ // to mimic the inet_address behavior?
		142	+
		143	+ /**
		144	+ * Gets a pointer to this object cast to a const @em sockaddr.
		145	+ * @return A pointer to this object cast to a const @em sockaddr.
		146	+ */
		147	+ const sockaddr* sockaddr_ptr() const override {
		148	+ return reinterpret_cast<const sockaddr*>(&addr_);
		149	+ }
		150	+ /**
		151	+ * Gets a pointer to this object cast to a @em sockaddr.
		152	+ * @return A pointer to this object cast to a @em sockaddr.
		153	+ */
		154	+ sockaddr* sockaddr_ptr() override {
		155	+ return reinterpret_cast<sockaddr*>(&addr_);
		156	+ }
		157	+ /**
		158	+ * Gets a const pointer to this object cast to a @em sockaddr_un.
		159	+ * @return const sockaddr_un pointer to this object.
		160	+ */
		161	+ const sockaddr_un* sockaddr_un_ptr() const { return &addr_; }
		162	+ /**
		163	+ * Gets a pointer to this object cast to a @em sockaddr_un.
		164	+ * @return sockaddr_un pointer to this object.
		165	+ */
		166	+ sockaddr_un* sockaddr_un_ptr() { return &addr_; }
		167	+ /**
		168	+ * Gets a printable string for the address.
		169	+ * @return A string representation of the address in the form
		170	+ * "unix:<path>"
		171	+ */
		172	+ std::string to_string() const {
		173	+ return std::string("unix:") + std::string(addr_.sun_path);
		174	+ }
		175	+};
		176	+
		177	+// --------------------------------------------------------------------------
		178	+
		179	+/**
		180	+ * Stream inserter for the address.
		181	+ * @param os The output stream
		182	+ * @param addr The address
		183	+ * @return A reference to the output stream.
		184	+ */
		185	+std::ostream& operator<<(std::ostream& os, const unix_address& addr);
		186	+
		187	+/////////////////////////////////////////////////////////////////////////////
		188	+// end namespace sockpp
		189	+}
		190	+
		191	+#endif // __sockpp_unix_addr_h
		192	+

include/socket-cpp/unix_connector.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/unix_connector.h
		1	+/**
		2	+ * @file unix_connector.h
		3	+ *
		4	+ * Class for creating client-side UNIX-domain socket connections.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date December 2018
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2014-2017 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_unix_connector_h
		48	+#define __sockpp_unix_connector_h
		49	+
		50	+#include "sockpp/connector.h"
		51	+#include "sockpp/unix_stream_socket.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** Unix-domain active connector socket. */
		58	+using unix_connector = connector_tmpl<unix_socket, unix_address>;
		59	+
		60	+/////////////////////////////////////////////////////////////////////////////
		61	+// end namespace sockpp
		62	+};
		63	+
		64	+#endif // __sockpp_unix_connector_h
		65	+

include/socket-cpp/unix_dgram_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/unix_dgram_socket.h
		1	+/**
		2	+ * @file unix_dgram_socket.h
		3	+ *
		4	+ * Class (typedef) for Unix-domain UDP socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_unix_dgram_socket_h
		48	+#define __sockpp_unix_dgram_socket_h
		49	+
		50	+#include "sockpp/datagram_socket.h"
		51	+#include "sockpp/unix_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** Unix-domain datagram socket */
		58	+using unix_datagram_socket = datagram_socket_tmpl<unix_address>;
		59	+
		60	+/** Unix-domain datagram socket (same as `unix_datagram_socket`) */
		61	+using unix_dgram_socket = unix_datagram_socket;
		62	+
		63	+/////////////////////////////////////////////////////////////////////////////
		64	+// end namespace sockpp
		65	+}
		66	+
		67	+#endif // __sockpp_unix_dgram_socket_h
		68	+

include/socket-cpp/unix_stream_socket.h 0 → 100644

View file @48b4c72

		1	+++ a/include/socket-cpp/unix_stream_socket.h
		1	+/**
		2	+ * @file unix_stream_socket.h
		3	+ *
		4	+ * Class (typedef) for Unix-domain streaming socket.
		5	+ *
		6	+ * @author Frank Pagliughi
		7	+ * @author SoRo Systems, Inc.
		8	+ * @author www.sorosys.com
		9	+ *
		10	+ * @date August 2019
		11	+ */
		12	+
		13	+// --------------------------------------------------------------------------
		14	+// This file is part of the "sockpp" C++ socket library.
		15	+//
		16	+// Copyright (c) 2019 Frank Pagliughi
		17	+// All rights reserved.
		18	+//
		19	+// Redistribution and use in source and binary forms, with or without
		20	+// modification, are permitted provided that the following conditions are
		21	+// met:
		22	+//
		23	+// 1. Redistributions of source code must retain the above copyright notice,
		24	+// this list of conditions and the following disclaimer.
		25	+//
		26	+// 2. Redistributions in binary form must reproduce the above copyright
		27	+// notice, this list of conditions and the following disclaimer in the
		28	+// documentation and/or other materials provided with the distribution.
		29	+//
		30	+// 3. Neither the name of the copyright holder nor the names of its
		31	+// contributors may be used to endorse or promote products derived from this
		32	+// software without specific prior written permission.
		33	+//
		34	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		35	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		36	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		37	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		38	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		39	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		40	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		41	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		42	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		43	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		44	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		45	+// --------------------------------------------------------------------------
		46	+
		47	+#ifndef __sockpp_unix_stream_socket_h
		48	+#define __sockpp_unix_stream_socket_h
		49	+
		50	+#include "sockpp/stream_socket.h"
		51	+#include "sockpp/unix_address.h"
		52	+
		53	+namespace sockpp {
		54	+
		55	+/////////////////////////////////////////////////////////////////////////////
		56	+
		57	+/** Streaming Unix-domain socket */
		58	+using unix_stream_socket = stream_socket_tmpl<unix_address>;
		59	+
		60	+/** Streaming Unix-domain socket (same as a `unix_stream_socket` */
		61	+using unix_socket = unix_stream_socket;
		62	+
		63	+/////////////////////////////////////////////////////////////////////////////
		64	+// end namespace sockpp
		65	+}
		66	+
		67	+#endif // __sockpp_unix_stream_socket_h
		68	+

scripts/setup_submodules 0 → 100755

View file @48b4c72

		1	+++ a/scripts/setup_submodules
		1	+#!/bin/bash
		2	+
		3	+# ===============================================
		4	+# == Setting some environment variables
		5	+# ===============================================
		6	+GIT_URL_SUBS="http://gitlab.osdev.nl/open_source"
		7	+FUNC_RESULT="-1"
		8	+
		9	+# Name : print_usage_exit()
		10	+# Description : Print the way this script is intended to be used and exit.
		11	+# Parameters : None.
		12	+# Returns : err_code 1 to the Operating System
		13	+# --------------------------------------------------------------------------------------
		14	+function print_usage_exit()
		15	+{
		16	+ echo "Usage $0 -i\|--install\|-u\|--update"
		17	+ echo " -i or --install Install the submodules mentioned in the submodules.list"
		18	+ echo " -u or --update Update the submodules mentioned in the submodules.list"
		19	+ echo " "
		20	+ exit 1
		21	+}
		22	+
		23	+# Name : check_top_or_sub
		24	+# Description : Determine if we're running in a "single" lib-build or part of a
		25	+# "meta"-repository ( submodule ).
		26	+# Parameters : None
		27	+# Returns : Updates the value FUNC_RESULT.
		28	+# -1 - We're neither a git-repo or submodule.
		29	+# 0 - We're a submodule
		30	+# 1 - We're a top-repo ( Single library )
		31	+# --------------------------------------------------------------------------------------
		32	+function check_top_or_sub()
		33	+{
		34	+ # This function checks if we're the top-repository.
		35	+ # In that case we need the submodules.. If we're already a submodule,
		36	+ # we simply exit this script with a message
		37	+ if [ -e ./.git ]; then
		38	+ FUNC_RESULT="1"
		39	+ return
		40	+ elif [ -e ../.git ]; then
		41	+ if [ -e ../.submodules ]; then
		42	+ echo "Seems like we're already a submodule. Nothing to do here."
		43	+ FUNC_RESULT="0"
		44	+ return
		45	+ fi
		46	+ fi
		47	+ FUNC_RESULT="-1"
		48	+ return
		49	+}
		50	+
		51	+# Name : check_working_dir
		52	+# Description : If we're in the top of our repo, we can run this script further.
		53	+# Parameters : None.
		54	+# Returns : Updates the value FUNC_RESULT.
		55	+# -1 - Not used.
		56	+# 0 - We're not on the top-level
		57	+# 1 - We're at the top-level. Good to go.
		58	+# --------------------------------------------------------------------------------------
		59	+function check_working_dir()
		60	+{
		61	+ FUNC_RESULT="-1"
		62	+ # Check if we're in the top-level directory of our repository.
		63	+ if [ -f ./scripts/submodules.list ]; then
		64	+ # We're good to go
		65	+ FUNC_RESULT="1"
		66	+ return
		67	+ fi
		68	+ FUNC_RESULT="0"
		69	+ return
		70	+}
		71	+
		72	+# Name : read_submodules
		73	+# Description : Read the list of submodules needed for this project
		74	+# Parameters : None
		75	+# Returns : Updates the value FUNC_RESULT
		76	+# 0 - Module list was not found
		77	+# 1 - Module list was found and read.
		78	+# --------------------------------------------------------------------------------------
		79	+function read_submodules()
		80	+{
		81	+ FUNC_RESULT="-1"
		82	+ if [ -e ./scripts/submodules.list ]; then
		83	+ source ./scripts/submodules.list
		84	+ FUNC_RESULT="1"
		85	+ return
		86	+ fi
		87	+
		88	+ echo "Submodules list not found...."
		89	+ FUNC_RESULT="0"
		90	+ return
		91	+}
		92	+
		93	+# Name : add_submodules
		94	+# Description : Configure the repo to add the submodules.
		95	+# Parameters : None.
		96	+# Returns : None.
		97	+# --------------------------------------------------------------------------------------
		98	+function add_submodules()
		99	+{
		100	+ echo -e "Adding SubModule(s)."
		101	+ for SUB_MODULE in ${SUB_MODULES}
		102	+ do
		103	+ echo -e "< ${SUB_MODULE} >"
		104	+ git submodule add -f ${GIT_URL_SUBS}/${SUB_MODULE}.git ${SUB_MODULE}
		105	+ git config submodule.${SUB_MODULE}.url ${GIT_URL_SUBS}/${SUB_MODULE}.git
		106	+ done
		107	+}
		108	+
		109	+# Name : get_submodules
		110	+# Description : Actually get the submodules from gitlab and add them.
		111	+# Parameters : None
		112	+# Returns : None
		113	+# --------------------------------------------------------------------------------------
		114	+function get_submodules()
		115	+{
		116	+ git submodule update --init --recursive
		117	+}
		118	+
		119	+# Name : update_submodules
		120	+# Description : Update the submodules already added.
		121	+# Parameters : None
		122	+# Returns : None
		123	+# --------------------------------------------------------------------------------------
		124	+function update_submodules()
		125	+{
		126	+ git submodule update --recursive
		127	+}
		128	+
		129	+# =============================================================================
		130	+# == T H E M A I N E N T R Y O F T H I S S C R I P T ==
		131	+# =============================================================================
		132	+check_top_or_sub
		133	+if [ "${FUNC_RESULT}" == "0" ]; then
		134	+ echo "Seems like we're a submodule already or not part of a repository."
		135	+ exit 0
		136	+fi
		137	+
		138	+check_working_dir
		139	+if [ "${FUNC_RESULT}" == "0" ]; then
		140	+ echo "Go to the top of this repository and type : scripts/setup_submodules [-i\|--install]"
		141	+ exit 0
		142	+fi
		143	+
		144	+read_submodules
		145	+
		146	+case "$1" in
		147	+ -i\|--install)
		148	+ echo "Installing submodules for this repository ( ${PWD} )"
		149	+ add_submodules
		150	+ get_submodules
		151	+ ;;
		152	+ -u\|--update)
		153	+ echo "Update submodules : ${SUB_MODULES}"
		154	+ update_submodules
		155	+ ;;
		156	+ *)
		157	+ echo "No parameters found..."
		158	+ print_usage_exit
		159	+ ;;
		160	+esac
		161	+

scripts/submodules.list 0 → 100644

View file @48b4c72

		1	+++ a/scripts/submodules.list
		1	+SUB_MODULES="versioning
		2	+cmake"

src/acceptor.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/acceptor.cpp
		1	+#include <cstring>
		2	+#include "sockpp/acceptor.h"
		3	+
		4	+using namespace std;
		5	+
		6	+namespace sockpp {
		7	+
		8	+/////////////////////////////////////////////////////////////////////////////
		9	+
		10	+acceptor acceptor::create(int domain)
		11	+{
		12	+ acceptor acc(create_handle(domain));
		13	+ if (!acc)
		14	+ acc.clear(get_last_error());
		15	+ return acc;
		16	+}
		17	+
		18	+// --------------------------------------------------------------------------
		19	+
		20	+// This attempts to open the acceptor, bind to the requested address, and
		21	+// start listening. On any error it will be sure to leave the underlying
		22	+// socket in an unopened/invalid state.
		23	+// If the acceptor appears to already be opened, this will quietly succeed
		24	+// without doing anything.
		25	+
		26	+bool acceptor::open(const sock_address& addr,
		27	+ int queSize /=DFLT_QUE_SIZE/,
		28	+ bool reuseSock /=true/)
		29	+{
		30	+ // TODO: What to do if we are open but bound to a different address?
		31	+ if (is_open())
		32	+ return true;
		33	+
		34	+ sa_family_t domain = addr.family();
		35	+ socket_t h = create_handle(domain);
		36	+
		37	+ if (!check_socket_bool(h))
		38	+ return false;
		39	+
		40	+ reset(h);
		41	+
		42	+ #if defined(_WIN32)
		43	+ const int REUSE = SO_REUSEADDR;
		44	+ #else
		45	+ const int REUSE = SO_REUSEPORT;
		46	+ #endif
		47	+
		48	+ if (reuseSock && (domain == AF_INET \|\| domain == AF_INET6)) {
		49	+ int reuse = 1;
		50	+ if (!set_option(SOL_SOCKET, REUSE, reuse))
		51	+ return close_on_err();
		52	+ }
		53	+
		54	+ if (!bind(addr) \|\| !listen(queSize))
		55	+ return close_on_err();
		56	+
		57	+ return true;
		58	+}
		59	+
		60	+// --------------------------------------------------------------------------
		61	+
		62	+stream_socket acceptor::accept(sock_address* clientAddr /=nullptr/)
		63	+{
		64	+ sockaddr* p = clientAddr ? clientAddr->sockaddr_ptr() : nullptr;
		65	+ socklen_t len = clientAddr ? clientAddr->size() : 0;
		66	+
		67	+ socket_t s = check_socket(::accept(handle(), p, clientAddr ? &len : nullptr));
		68	+ return stream_socket(s);
		69	+}
		70	+
		71	+/////////////////////////////////////////////////////////////////////////////
		72	+// end namespace sockpp
		73	+}
		74	+

src/connector.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/connector.cpp
		1	+#include "sockpp/connector.h"
		2	+
		3	+namespace sockpp {
		4	+
		5	+bool connector::connect(const sock_address& addr)
		6	+{
		7	+ sa_family_t domain = addr.family();
		8	+ socket_t h = create_handle(domain);
		9	+
		10	+ if (!check_ret_bool(h))
		11	+ return false;
		12	+
		13	+ // This will close the old connection, if any.
		14	+ reset(h);
		15	+
		16	+ if (!check_ret_bool(::connect(h, addr.sockaddr_ptr(), addr.size())))
		17	+ return close_on_err();
		18	+
		19	+ return true;
		20	+}
		21	+
		22	+}
		23	+

src/datagram_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/datagram_socket.cpp
		1	+#include "sockpp/datagram_socket.h"
		2	+#include "sockpp/exception.h"
		3	+#include <algorithm>
		4	+
		5	+using namespace std::chrono;
		6	+
		7	+namespace sockpp {
		8	+
		9	+datagram_socket::datagram_socket(const sock_address& addr)
		10	+{
		11	+ auto domain = addr.family();
		12	+ socket_t h = create_handle(domain);
		13	+
		14	+ if (check_socket_bool(h)) {
		15	+ reset(h);
		16	+ // TODO: If the bind fails, should we close the socket and fail completely?
		17	+ bind(addr);
		18	+ }
		19	+}
		20	+
		21	+ssize_t datagram_socket::recv_from(void* buf, size_t n, int flags,
		22	+ sock_address* srcAddr /=nullptr/)
		23	+{
		24	+ sockaddr* p = srcAddr ? srcAddr->sockaddr_ptr() : nullptr;
		25	+ socklen_t len = srcAddr ? srcAddr->size() : 0;
		26	+
		27	+ // TODO: Check returned length
		28	+ #if defined(_WIN32)
		29	+ return check_ret(::recvfrom(handle(), reinterpret_cast<char*>(buf),
		30	+ int(n), flags, p, &len));
		31	+ #else
		32	+ return check_ret(::recvfrom(handle(), buf, n, flags, p, &len));
		33	+ #endif
		34	+}
		35	+
		36	+
		37	+}
		38	+

src/exception.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/exception.cpp
		1	+#include "sockpp/exception.h"
		2	+#include "sockpp/platform.h"
		3	+#include <cstring>
		4	+
		5	+// Used to explicitly ignore the returned value of a function call.
		6	+#define ignore_result(x) if (x) {}
		7	+
		8	+using namespace std;
		9	+
		10	+namespace sockpp {
		11	+
		12	+sys_error::sys_error(int err) : runtime_error(error_str(err)), errno_(err)
		13	+{
		14	+}
		15	+
		16	+std::string sys_error::error_str(int err)
		17	+{
		18	+ char buf[1024];
		19	+ buf[0] = '\x0';
		20	+
		21	+ #if defined(_WIN32)
		22	+ FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS,
		23	+ NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		24	+ buf, sizeof(buf), NULL);
		25	+ #else
		26	+ #ifdef _GNU_SOURCE
		27	+ #if !defined(__GLIBC__)
		28	+ // use the XSI standard behavior.
		29	+ int e = strerror_r(err, buf, sizeof(buf));
		30	+ auto s = strerror(e);
		31	+ return s ? std::string(s) : std::string();
		32	+ #else
		33	+ // assume GNU exception
		34	+ auto s = strerror_r(err, buf, sizeof(buf));
		35	+ return s ? std::string(s) : std::string();
		36	+ #endif
		37	+ #else
		38	+ ignore_result(strerror_r(err, buf, sizeof(buf)));
		39	+ #endif
		40	+ #endif
		41	+ return std::string(buf);
		42	+}
		43	+
		44	+getaddrinfo_error::getaddrinfo_error(int err, const string& hostname)
		45	+ : runtime_error(gai_strerror(err)), error_(err), hostname_(hostname)
		46	+{
		47	+}
		48	+
		49	+}
		50	+

src/inet6_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/inet6_address.cpp
		1	+#include "sockpp/inet6_address.h"
		2	+#include "sockpp/exception.h"
		3	+
		4	+using namespace std;
		5	+
		6	+namespace sockpp {
		7	+
		8	+bool inet6_address::is_set() const
		9	+{
		10	+ static const auto EMPTY_ADDR = sockaddr_in6{};
		11	+ return std::memcmp(&addr_, &EMPTY_ADDR, SZ) != 0;
		12	+}
		13	+
		14	+in6_addr inet6_address::resolve_name(const string& saddr)
		15	+{
		16	+ #if !defined(_WIN32)
		17	+ in6_addr ia;
		18	+ if (::inet_pton(ADDRESS_FAMILY, saddr.c_str(), &ia) == 1)
		19	+ return ia;
		20	+ #endif
		21	+
		22	+ addrinfo *res, hints = addrinfo{};
		23	+ hints.ai_family = ADDRESS_FAMILY;
		24	+ hints.ai_socktype = SOCK_STREAM;
		25	+
		26	+ int gai_err = ::getaddrinfo(saddr.c_str(), NULL, &hints, &res);
		27	+
		28	+ #if !defined(_WIN32)
		29	+ if (gai_err == EAI_SYSTEM)
		30	+ throw sys_error();
		31	+ #endif
		32	+
		33	+ if (gai_err != 0)
		34	+ throw getaddrinfo_error(gai_err, saddr);
		35	+
		36	+
		37	+ auto ipv6 = reinterpret_cast<sockaddr_in6*>(res->ai_addr);
		38	+ auto addr = ipv6->sin6_addr;
		39	+ freeaddrinfo(res);
		40	+ return addr;
		41	+}
		42	+
		43	+void inet6_address::create(const in6_addr& addr, in_port_t port)
		44	+{
		45	+ addr_ = sockaddr_in6{};
		46	+ addr_.sin6_family = AF_INET6;
		47	+ addr_.sin6_flowinfo = 0;
		48	+ addr_.sin6_addr = addr;
		49	+ addr_.sin6_port = htons(port);
		50	+}
		51	+
		52	+void inet6_address::create(const string& saddr, in_port_t port)
		53	+{
		54	+ addr_ = sockaddr_in6{};
		55	+ addr_.sin6_family = AF_INET6;
		56	+ addr_.sin6_flowinfo = 0;
		57	+ addr_.sin6_addr = resolve_name(saddr.c_str());
		58	+ addr_.sin6_port = htons(port);
		59	+}
		60	+
		61	+string inet6_address::to_string() const
		62	+{
		63	+ char buf[INET6_ADDRSTRLEN];
		64	+ auto str = inet_ntop(AF_INET6, (void*) &(addr_.sin6_addr),
		65	+ buf, INET6_ADDRSTRLEN);
		66	+ return std::string("[") + std::string(str ? str : "<unknown>")
		67	+ + "]:" + std::to_string(unsigned(port()));
		68	+}
		69	+
		70	+ostream& operator<<(ostream& os, const inet6_address& addr)
		71	+{
		72	+ char buf[INET6_ADDRSTRLEN];
		73	+ auto str = inet_ntop(AF_INET6, (void*) &(addr.sockaddr_in6_ptr()->sin6_addr),
		74	+ buf, INET6_ADDRSTRLEN);
		75	+ os << "[" << (str ? str : "<unknown>") << "]:" << unsigned(addr.port());
		76	+ return os;
		77	+}
		78	+
		79	+}
		80	+

src/inet_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/inet_address.cpp
		1	+#include "sockpp/inet_address.h"
		2	+#include "sockpp/exception.h"
		3	+
		4	+using namespace std;
		5	+
		6	+namespace sockpp {
		7	+
		8	+bool inet_address::is_set() const
		9	+{
		10	+ static const auto EMPTY_ADDR = sockaddr_in{};
		11	+ return std::memcmp(&addr_, &EMPTY_ADDR, SZ) != 0;
		12	+}
		13	+
		14	+in_addr_t inet_address::resolve_name(const std::string& saddr)
		15	+{
		16	+ #if !defined(_WIN32)
		17	+ in_addr ia;
		18	+ if (::inet_pton(ADDRESS_FAMILY, saddr.c_str(), &ia) == 1)
		19	+ return ia.s_addr;
		20	+ #endif
		21	+
		22	+ addrinfo *res, hints = addrinfo{};
		23	+ hints.ai_family = ADDRESS_FAMILY;
		24	+ hints.ai_socktype = SOCK_STREAM;
		25	+
		26	+ int gai_err = ::getaddrinfo(saddr.c_str(), NULL, &hints, &res);
		27	+
		28	+ #if !defined(_WIN32)
		29	+ if (gai_err == EAI_SYSTEM)
		30	+ throw sys_error();
		31	+ #endif
		32	+
		33	+ if (gai_err != 0)
		34	+ throw getaddrinfo_error(gai_err, saddr);
		35	+
		36	+ auto ipv4 = reinterpret_cast<sockaddr_in*>(res->ai_addr);
		37	+ auto addr = ipv4->sin_addr.s_addr;
		38	+ freeaddrinfo(res);
		39	+ return addr;
		40	+}
		41	+
		42	+void inet_address::create(uint32_t addr, in_port_t port)
		43	+{
		44	+ addr_ = sockaddr_in{};
		45	+ addr_.sin_family = AF_INET;
		46	+ addr_.sin_addr.s_addr = htonl(addr);
		47	+ addr_.sin_port = htons(port);
		48	+}
		49	+
		50	+void inet_address::create(const std::string& saddr, in_port_t port)
		51	+{
		52	+ addr_ = sockaddr_in{};
		53	+ addr_.sin_family = AF_INET;
		54	+ addr_.sin_addr.s_addr = resolve_name(saddr.c_str());
		55	+ addr_.sin_port = htons(port);
		56	+}
		57	+
		58	+string inet_address::to_string() const
		59	+{
		60	+ char buf[INET_ADDRSTRLEN];
		61	+ auto str = inet_ntop(AF_INET, (void*) &(addr_.sin_addr), buf, INET_ADDRSTRLEN);
		62	+ return std::string(str ? str : "<unknown>")
		63	+ + ":" + std::to_string(unsigned(port()));
		64	+}
		65	+
		66	+ostream& operator<<(ostream& os, const inet_address& addr)
		67	+{
		68	+ char buf[INET_ADDRSTRLEN];
		69	+ auto str = inet_ntop(AF_INET, (void*) &(addr.sockaddr_in_ptr()->sin_addr),
		70	+ buf, INET_ADDRSTRLEN);
		71	+ os << (str ? str : "<unknown>") << ":" << unsigned(addr.port());
		72	+ return os;
		73	+}
		74	+
		75	+}

src/linux/can_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/linux/can_address.cpp
		1	+// can_address.cpp
		2	+//
		3	+// --------------------------------------------------------------------------
		4	+// This file is part of the "sockpp" C++ socket library.
		5	+//
		6	+// Copyright (c) 2014-2021 Frank Pagliughi
		7	+// All rights reserved.
		8	+//
		9	+// Redistribution and use in source and binary forms, with or without
		10	+// modification, are permitted provided that the following conditions are
		11	+// met:
		12	+//
		13	+// 1. Redistributions of source code must retain the above copyright notice,
		14	+// this list of conditions and the following disclaimer.
		15	+//
		16	+// 2. Redistributions in binary form must reproduce the above copyright
		17	+// notice, this list of conditions and the following disclaimer in the
		18	+// documentation and/or other materials provided with the distribution.
		19	+//
		20	+// 3. Neither the name of the copyright holder nor the names of its
		21	+// contributors may be used to endorse or promote products derived from this
		22	+// software without specific prior written permission.
		23	+//
		24	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		25	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		26	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		27	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		28	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		29	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		30	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		31	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		32	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		33	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		34	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		35	+// --------------------------------------------------------------------------
		36	+
		37	+#include "sockpp/can_address.h"
		38	+#include "sockpp/socket.h"
		39	+#include <cstring>
		40	+#include <stdexcept>
		41	+#include <sys/ioctl.h>
		42	+#include <net/if.h>
		43	+
		44	+using namespace std;
		45	+
		46	+namespace sockpp {
		47	+
		48	+/////////////////////////////////////////////////////////////////////////////
		49	+
		50	+constexpr sa_family_t can_address::ADDRESS_FAMILY;
		51	+
		52	+// --------------------------------------------------------------------------
		53	+
		54	+can_address::can_address(unsigned ifindex) : addr_{}
		55	+{
		56	+ addr_.can_family = AF_CAN;
		57	+ addr_.can_ifindex = ifindex;
		58	+}
		59	+
		60	+can_address::can_address(const string& iface) : addr_{}
		61	+{
		62	+ unsigned idx = if_nametoindex(iface.c_str());
		63	+
		64	+ if (idx != 0) {
		65	+ addr_.can_family = AF_CAN;
		66	+ addr_.can_ifindex = idx;
		67	+ }
		68	+}
		69	+
		70	+can_address::can_address(const sockaddr& addr)
		71	+{
		72	+ auto domain = addr.sa_family;
		73	+ if (domain != AF_CAN)
		74	+ throw std::invalid_argument("Not a SocketCAN address");
		75	+
		76	+ std::memcpy(&addr_, &addr, sizeof(sockaddr));
		77	+}
		78	+
		79	+string can_address::iface() const
		80	+{
		81	+ if (addr_.can_family == AF_UNSPEC)
		82	+ return string("none");
		83	+
		84	+ if (addr_.can_ifindex == 0)
		85	+ return string("any");
		86	+
		87	+ char buf[IF_NAMESIZE];
		88	+ const char* iface = if_indextoname(addr_.can_ifindex, buf);
		89	+
		90	+ return string(iface ? iface : "unknown");
		91	+}
		92	+
		93	+
		94	+// --------------------------------------------------------------------------
		95	+
		96	+ostream& operator<<(ostream& os, const can_address& addr)
		97	+{
		98	+ os << "can:" << addr.iface();
		99	+ return os;
		100	+}
		101	+
		102	+/////////////////////////////////////////////////////////////////////////////
		103	+// End namespace sockpp
		104	+}

src/linux/can_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/linux/can_socket.cpp
		1	+// can_socket.cpp
		2	+//
		3	+// --------------------------------------------------------------------------
		4	+// This file is part of the "sockpp" C++ socket library.
		5	+//
		6	+// Copyright (c) 2021 Frank Pagliughi
		7	+// All rights reserved.
		8	+//
		9	+// Redistribution and use in source and binary forms, with or without
		10	+// modification, are permitted provided that the following conditions are
		11	+// met:
		12	+//
		13	+// 1. Redistributions of source code must retain the above copyright notice,
		14	+// this list of conditions and the following disclaimer.
		15	+//
		16	+// 2. Redistributions in binary form must reproduce the above copyright
		17	+// notice, this list of conditions and the following disclaimer in the
		18	+// documentation and/or other materials provided with the distribution.
		19	+//
		20	+// 3. Neither the name of the copyright holder nor the names of its
		21	+// contributors may be used to endorse or promote products derived from this
		22	+// software without specific prior written permission.
		23	+//
		24	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		25	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		26	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		27	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		28	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		29	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		30	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		31	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		32	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		33	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		34	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		35	+// --------------------------------------------------------------------------
		36	+
		37	+#include "sockpp/can_socket.h"
		38	+#include "sockpp/socket.h"
		39	+#include <sys/ioctl.h>
		40	+
		41	+using namespace std;
		42	+using namespace std::chrono;
		43	+
		44	+namespace sockpp {
		45	+
		46	+/////////////////////////////////////////////////////////////////////////////
		47	+
		48	+can_socket::can_socket(const can_address& addr)
		49	+{
		50	+ socket_t h = create_handle(SOCK_RAW, CAN_RAW);
		51	+
		52	+ if (check_socket_bool(h)) {
		53	+ reset(h);
		54	+ bind(addr);
		55	+ }
		56	+}
		57	+
		58	+system_clock::time_point can_socket::last_frame_time()
		59	+{
		60	+ timeval tv {};
		61	+
		62	+ // TODO: Handle error
		63	+ ::ioctl(handle(), SIOCGSTAMP, &tv);
		64	+ return to_timepoint(tv);
		65	+}
		66	+
		67	+double can_socket::last_frame_timestamp()
		68	+{
		69	+ timeval tv {};
		70	+
		71	+ // TODO: Handle error
		72	+ ::ioctl(handle(), SIOCGSTAMP, &tv);
		73	+ return double(tv.tv_sec) + 1.0e-6 * tv.tv_usec;
		74	+}
		75	+
		76	+
		77	+// --------------------------------------------------------------------------
		78	+
		79	+ssize_t can_socket::recv_from(can_frame *frame, int flags,
		80	+ can_address* srcAddr /=nullptr/)
		81	+{
		82	+ sockaddr* p = srcAddr ? srcAddr->sockaddr_ptr() : nullptr;
		83	+ socklen_t len = srcAddr ? srcAddr->size() : 0;
		84	+
		85	+ // TODO: Check returned length
		86	+ return check_ret(::recvfrom(handle(), frame, sizeof(can_frame),
		87	+ flags, p, &len));
		88	+}
		89	+
		90	+/////////////////////////////////////////////////////////////////////////////
		91	+// End namespace sockpp
		92	+}

src/socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/socket.cpp
		1	+#include "sockpp/socket.h"
		2	+#include "sockpp/exception.h"
		3	+#include <algorithm>
		4	+#include <cstring>
		5	+#include <fcntl.h>
		6	+
		7	+// Used to explicitly ignore the returned value of a function call.
		8	+#define ignore_result(x) if (x) {}
		9	+
		10	+using namespace std::chrono;
		11	+
		12	+namespace sockpp {
		13	+
		14	+timeval to_timeval(const microseconds& dur)
		15	+{
		16	+ const seconds sec = duration_cast<seconds>(dur);
		17	+
		18	+ timeval tv;
		19	+ #if defined(_WIN32)
		20	+ tv.tv_sec = long(sec.count());
		21	+ #else
		22	+ tv.tv_sec = time_t(sec.count());
		23	+ #endif
		24	+ tv.tv_usec = suseconds_t(duration_cast<microseconds>(dur - sec).count());
		25	+ return tv;
		26	+}
		27	+
		28	+int socket::get_last_error()
		29	+{
		30	+ #if defined(_WIN32)
		31	+ return ::WSAGetLastError();
		32	+ #else
		33	+ int err = errno;
		34	+ return err;
		35	+ #endif
		36	+}
		37	+
		38	+bool socket::close(socket_t h)
		39	+{
		40	+ #if defined(_WIN32)
		41	+ return ::closesocket(h) >= 0;
		42	+ #else
		43	+ return ::close(h) >= 0;
		44	+ #endif
		45	+}
		46	+
		47	+void socket::initialize()
		48	+{
		49	+ #if defined(_WIN32)
		50	+ WSADATA wsadata;
		51	+ ::WSAStartup(MAKEWORD(2, 0), &wsadata);
		52	+ #else
		53	+ // Don't signal on socket write errors.
		54	+ ::signal(SIGPIPE, SIG_IGN);
		55	+ #endif
		56	+}
		57	+
		58	+void socket::destroy()
		59	+{
		60	+ #if defined(_WIN32)
		61	+ ::WSACleanup();
		62	+ #endif
		63	+}
		64	+
		65	+socket socket::create(int domain, int type, int protocol /=0/)
		66	+{
		67	+ socket sock(::socket(domain, type, protocol));
		68	+ if (!sock)
		69	+ sock.clear(get_last_error());
		70	+ return sock;
		71	+}
		72	+
		73	+socket socket::clone() const
		74	+{
		75	+ socket_t h = INVALID_SOCKET;
		76	+ #if defined(_WIN32)
		77	+ WSAPROTOCOL_INFO protInfo;
		78	+ if (::WSADuplicateSocket(handle_, ::GetCurrentProcessId(), &protInfo) == 0)
		79	+ h = ::WSASocket(AF_INET, SOCK_STREAM, 0, &protInfo, 0, WSA_FLAG_OVERLAPPED);
		80	+ // TODO: Set lastErr_ on failure
		81	+ #else
		82	+ h = ::dup(handle_);
		83	+ #endif
		84	+
		85	+ return socket(h);
		86	+}
		87	+
		88	+std::tuple<socket, socket> socket::pair(int domain, int type, int protocol /=0/)
		89	+{
		90	+ socket sock0, sock1;
		91	+
		92	+ #if !defined(_WIN32)
		93	+ int sv[2];
		94	+ int ret = ::socketpair(domain, type, protocol, sv);
		95	+
		96	+ if (ret == 0) {
		97	+ sock0.reset(sv[0]);
		98	+ sock1.reset(sv[1]);
		99	+ }
		100	+ else {
		101	+ int err = get_last_error();
		102	+ sock0.clear(err);
		103	+ sock1.clear(err);
		104	+ }
		105	+ #else
		106	+ sock0.clear(ENOTSUP);
		107	+ sock1.clear(ENOTSUP);
		108	+ #endif
		109	+
		110	+ // TODO: Should we set an "unsupported" error on Windows?
		111	+
		112	+ return std::make_tuple<socket, socket>(std::move(sock0), std::move(sock1));
		113	+}
		114	+
		115	+void socket::reset(socket_t h /=INVALID_SOCKET/)
		116	+{
		117	+ socket_t oh = handle_;
		118	+ handle_ = h;
		119	+ if (oh != INVALID_SOCKET)
		120	+ close(oh);
		121	+ clear();
		122	+}
		123	+
		124	+bool socket::bind(const sock_address& addr)
		125	+{
		126	+ return check_ret_bool(::bind(handle_, addr.sockaddr_ptr(), addr.size()));
		127	+}
		128	+
		129	+sock_address_any socket::address() const
		130	+{
		131	+ auto addrStore = sockaddr_storage{};
		132	+ socklen_t len = sizeof(sockaddr_storage);
		133	+
		134	+ if (!check_ret_bool(::getsockname(handle_,
		135	+ reinterpret_cast<sockaddr*>(&addrStore), &len)))
		136	+ return sock_address_any{};
		137	+
		138	+ return sock_address_any(addrStore, len);
		139	+}
		140	+
		141	+sock_address_any socket::peer_address() const
		142	+{
		143	+ auto addrStore = sockaddr_storage{};
		144	+ socklen_t len = sizeof(sockaddr_storage);
		145	+
		146	+ if (!check_ret_bool(::getpeername(handle_,
		147	+ reinterpret_cast<sockaddr*>(&addrStore), &len)))
		148	+ return sock_address_any{};
		149	+
		150	+ return sock_address_any(addrStore, len);
		151	+}
		152	+
		153	+bool socket::get_option(int level, int optname, void* optval, socklen_t* optlen) const
		154	+{
		155	+ #if defined(_WIN32)
		156	+ if (optval && optlen) {
		157	+ int len = static_cast<int>(*optlen);
		158	+ if (check_ret_bool(::getsockopt(handle_, level, optname,
		159	+ static_cast<char*>(optval), &len))) {
		160	+ *optlen = static_cast<socklen_t>(len);
		161	+ return true;
		162	+ }
		163	+ }
		164	+ return false;
		165	+ #else
		166	+ return check_ret_bool(::getsockopt(handle_, level, optname, optval, optlen));
		167	+ #endif
		168	+}
		169	+
		170	+bool socket::set_option(int level, int optname, const void* optval, socklen_t optlen)
		171	+{
		172	+ #if defined(_WIN32)
		173	+ return check_ret_bool(::setsockopt(handle_, level, optname,
		174	+ static_cast<const char*>(optval),
		175	+ static_cast<int>(optlen)));
		176	+ #else
		177	+ return check_ret_bool(::setsockopt(handle_, level, optname, optval, optlen));
		178	+ #endif
		179	+}
		180	+
		181	+bool socket::set_non_blocking(bool on /=true/)
		182	+{
		183	+ #if defined(_WIN32)
		184	+ unsigned long mode = on ? 1 : 0;
		185	+ return check_ret_bool(::ioctlsocket(handle_, FIONBIO, &mode));
		186	+ #else
		187	+ /**
		188	+ * TODO: Consider a generic function:
		189	+ * bool set_flag(int flag, bool on=true);
		190	+ * Used like:
		191	+ * set_flag(O_NONBLOCK, on);
		192	+ */
		193	+ int flags = ::fcntl(handle_, F_GETFL, 0);
		194	+
		195	+ if (flags == -1) {
		196	+ set_last_error();
		197	+ return false;
		198	+ }
		199	+ flags = on ? (flags \| O_NONBLOCK) : (flags & ~O_NONBLOCK);
		200	+
		201	+ if (::fcntl(handle_, F_SETFL, flags) == -1) {
		202	+ set_last_error();
		203	+ return false;
		204	+ }
		205	+ return true;
		206	+ #endif
		207	+}
		208	+
		209	+std::string socket::error_str(int err)
		210	+{
		211	+ return sys_error::error_str(err);
		212	+}
		213	+
		214	+bool socket::shutdown(int how /=SHUT_RDWR/)
		215	+{
		216	+ return check_ret_bool(::shutdown(handle_, how));
		217	+}
		218	+
		219	+bool socket::close()
		220	+{
		221	+ if (handle_ != INVALID_SOCKET) {
		222	+ if (!close(release())){
		223	+ set_last_error();
		224	+ return false;
		225	+ }
		226	+ }
		227	+ return true;
		228	+}
		229	+
		230	+}
		231	+

src/stream_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/stream_socket.cpp
		1	+#include "socket-cpp/stream_socket.h"
		2	+#include "socket-cpp/exception.h"
		3	+#include <algorithm>
		4	+#include <memory>
		5	+
		6	+using namespace std::chrono;
		7	+
		8	+namespace socket-cpp {
		9	+
		10	+stream_socket stream_socket::create(int domain, int protocol /=0/)
		11	+{
		12	+ stream_socket sock(::socket(domain, COMM_TYPE, protocol));
		13	+ if (!sock)
		14	+ sock.clear(get_last_error());
		15	+ return sock;
		16	+}
		17	+
		18	+ssize_t stream_socket::read(void *buf, size_t n)
		19	+{
		20	+ #if defined(_WIN32)
		21	+ return check_ret(::recv(handle(), reinterpret_cast<char*>(buf),
		22	+ int(n), 0));
		23	+ #else
		24	+ return check_ret(::recv(handle(), buf, n, 0));
		25	+ #endif
		26	+}
		27	+
		28	+ssize_t stream_socket::read_n(void *buf, size_t n)
		29	+{
		30	+ size_t nr = 0;
		31	+ ssize_t nx = 0;
		32	+
		33	+ uint8_t b = reinterpret_cast<uint8_t>(buf);
		34	+
		35	+ while (nr < n) {
		36	+ if ((nx = read(b+nr, n-nr)) < 0 && last_error() == EINTR)
		37	+ continue;
		38	+
		39	+ if (nx <= 0)
		40	+ break;
		41	+
		42	+ nr += nx;
		43	+ }
		44	+
		45	+ return (nr == 0 && nx < 0) ? nx : ssize_t(nr);
		46	+}
		47	+
		48	+
		49	+ssize_t stream_socket::read(const std::vector<iovec>& ranges)
		50	+{
		51	+ if (ranges.empty())
		52	+ return 0;
		53	+
		54	+ #if !defined(_WIN32)
		55	+ return check_ret(::readv(handle(), ranges.data(), int(ranges.size())));
		56	+ #else
		57	+ std::vector<WSABUF> bufs;
		58	+ for (const auto& iovec : ranges) {
		59	+ bufs.push_back({
		60	+ static_cast<ULONG>(iovec.iov_len),
		61	+ static_cast<CHAR*>(iovec.iov_base)
		62	+ });
		63	+ }
		64	+
		65	+ DWORD flags = 0,
		66	+ nread = 0,
		67	+ nbuf = DWORD(bufs.size());
		68	+
		69	+ auto ret = check_ret(::WSARecv(handle(), bufs.data(), nbuf, &nread, &flags, nullptr, nullptr));
		70	+ return ssize_t(ret == SOCKET_ERROR ? ret : nread);
		71	+ #endif
		72	+}
		73	+
		74	+bool stream_socket::read_timeout(const microseconds& to)
		75	+{
		76	+ auto tv =
		77	+ #if defined(_WIN32)
		78	+ DWORD(duration_cast<milliseconds>(to).count());
		79	+ #else
		80	+ to_timeval(to);
		81	+ #endif
		82	+ return set_option(SOL_SOCKET, SO_RCVTIMEO, tv);
		83	+}
		84	+
		85	+ssize_t stream_socket::write(const void *buf, size_t n)
		86	+{
		87	+ #if defined(_WIN32)
		88	+ return check_ret(::send(handle(), reinterpret_cast<const char*>(buf),
		89	+ int(n) , 0));
		90	+ #else
		91	+ return check_ret(::send(handle(), buf, n , 0));
		92	+ #endif
		93	+}
		94	+
		95	+ssize_t stream_socket::write_n(const void *buf, size_t n)
		96	+{
		97	+ size_t nw = 0;
		98	+ ssize_t nx = 0;
		99	+
		100	+ const uint8_t b = reinterpret_cast<const uint8_t>(buf);
		101	+
		102	+ while (nw < n) {
		103	+ if ((nx = write(b+nw, n-nw)) < 0 && last_error() == EINTR)
		104	+ continue;
		105	+
		106	+ if (nx <= 0)
		107	+ break;
		108	+
		109	+ nw += nx;
		110	+ }
		111	+
		112	+ return (nw == 0 && nx < 0) ? nx : ssize_t(nw);
		113	+}
		114	+
		115	+ssize_t stream_socket::write(const std::vector<iovec>& ranges)
		116	+{
		117	+ if (ranges.empty())
		118	+ return 0;
		119	+
		120	+ #if !defined(_WIN32)
		121	+ return check_ret(::writev(handle(), ranges.data(), int(ranges.size())));
		122	+ #else
		123	+ std::vector<WSABUF> bufs;
		124	+ for (const auto& iovec : ranges) {
		125	+ bufs.push_back({
		126	+ static_cast<ULONG>(iovec.iov_len),
		127	+ static_cast<CHAR*>(iovec.iov_base)
		128	+ });
		129	+ }
		130	+
		131	+ DWORD nwritten = 0,
		132	+ nmsg = DWORD(bufs.size());
		133	+
		134	+ auto ret = check_ret(::WSASend(handle(), bufs.data(), nmsg, &nwritten, 0, nullptr, nullptr));
		135	+ return ssize_t(ret == SOCKET_ERROR ? ret : nwritten);
		136	+ #endif
		137	+}
		138	+
		139	+bool stream_socket::write_timeout(const microseconds& to)
		140	+{
		141	+ auto tv =
		142	+ #if defined(_WIN32)
		143	+ DWORD(duration_cast<milliseconds>(to).count());
		144	+ #else
		145	+ to_timeval(to);
		146	+ #endif
		147	+
		148	+ return set_option(SOL_SOCKET, SO_SNDTIMEO, tv);
		149	+}
		150	+
		151	+}
		152	+

src/unix/unix_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/src/unix/unix_address.cpp
		1	+// unix_address.cpp
		2	+//
		3	+// --------------------------------------------------------------------------
		4	+// This file is part of the "sockpp" C++ socket library.
		5	+//
		6	+// Copyright (c) 2014-2017 Frank Pagliughi
		7	+// All rights reserved.
		8	+//
		9	+// Redistribution and use in source and binary forms, with or without
		10	+// modification, are permitted provided that the following conditions are
		11	+// met:
		12	+//
		13	+// 1. Redistributions of source code must retain the above copyright notice,
		14	+// this list of conditions and the following disclaimer.
		15	+//
		16	+// 2. Redistributions in binary form must reproduce the above copyright
		17	+// notice, this list of conditions and the following disclaimer in the
		18	+// documentation and/or other materials provided with the distribution.
		19	+//
		20	+// 3. Neither the name of the copyright holder nor the names of its
		21	+// contributors may be used to endorse or promote products derived from this
		22	+// software without specific prior written permission.
		23	+//
		24	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		25	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		26	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		27	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		28	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		29	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		30	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		31	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		32	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		33	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		34	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		35	+// --------------------------------------------------------------------------
		36	+
		37	+#include "sockpp/unix_address.h"
		38	+#include <cstring>
		39	+#include <stdexcept>
		40	+
		41	+using namespace std;
		42	+
		43	+namespace sockpp {
		44	+
		45	+/////////////////////////////////////////////////////////////////////////////
		46	+
		47	+constexpr sa_family_t unix_address::ADDRESS_FAMILY;
		48	+constexpr size_t unix_address::MAX_PATH_NAME;
		49	+
		50	+// --------------------------------------------------------------------------
		51	+
		52	+unix_address::unix_address(const string& path)
		53	+{
		54	+ addr_.sun_family = ADDRESS_FAMILY;
		55	+ ::strncpy(addr_.sun_path, path.c_str(), MAX_PATH_NAME);
		56	+}
		57	+
		58	+unix_address::unix_address(const sockaddr& addr)
		59	+{
		60	+ auto domain = addr.sa_family;
		61	+ if (domain != AF_UNIX)
		62	+ throw std::invalid_argument("Not a UNIX-domain address");
		63	+
		64	+ // TODO: We should check the path, or at least see that it has
		65	+ // proper NUL termination.
		66	+ std::memcpy(&addr_, &addr, sizeof(sockaddr));
		67	+}
		68	+
		69	+// --------------------------------------------------------------------------
		70	+
		71	+ostream& operator<<(ostream& os, const unix_address& addr)
		72	+{
		73	+ os << "unix:" << addr.path();
		74	+ return os;
		75	+}
		76	+
		77	+/////////////////////////////////////////////////////////////////////////////
		78	+// End namespace sockpp
		79	+}

tests/udptst.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/udptst.cpp
		1	+// udptst.cpp
		2	+
		3	+#include <iostream>
		4	+#include "sockpp/socket.h"
		5	+
		6	+using namespace std;
		7	+
		8	+// --------------------------------------------------------------------------
		9	+
		10	+int do_recv(sockpp::udp_socket& sock)
		11	+{
		12	+ char buf[6];
		13	+ int n = sock.recv(buf, sizeof(buf));
		14	+
		15	+ if (n < 0) {
		16	+ cerr << "Error sending packet: ["
		17	+ << sock.last_error() << "]" << endl;
		18	+ return -1;
		19	+ }
		20	+
		21	+ cout << "Received " << n << " bytes" << flush;
		22	+ buf[n] = '\0';
		23	+ cout << " '" << buf << "'" << endl;
		24	+ return 0;
		25	+}
		26	+
		27	+// --------------------------------------------------------------------------
		28	+
		29	+int main()
		30	+{
		31	+ in_port_t port = 12345;
		32	+
		33	+ cout << "Testing UDP sockets" << endl;
		34	+ sockpp::udp_socket srvrSock;
		35	+
		36	+ if (!srvrSock) {
		37	+ cerr << "Error creating server socket ["
		38	+ << srvrSock.last_error() << "]" << endl;
		39	+ return 1;
		40	+ }
		41	+
		42	+ if (!srvrSock.bind(port)) {
		43	+ cerr << "Error binding to port: " << port << " ["
		44	+ << srvrSock.last_error() << "]" << endl;
		45	+ return 1;
		46	+ }
		47	+
		48	+ sockpp::udp_socket cliSock;
		49	+
		50	+ if (!cliSock) {
		51	+ cerr << "Error creating server socket ["
		52	+ << cliSock.last_error() << "]" << endl;
		53	+ return 1;
		54	+ }
		55	+
		56	+ sockpp::inet_address localAddr("localhost", port);
		57	+
		58	+ if (!cliSock.connect(localAddr)) {
		59	+ cerr << "Error connecting to port: " << port << " ["
		60	+ << cliSock.last_error() << "]" << endl;
		61	+ return 1;
		62	+ }
		63	+
		64	+ cliSock.send("Hello");
		65	+ do_recv(srvrSock);
		66	+
		67	+ cliSock.close();
		68	+
		69	+ sockpp::udp_socket sock;
		70	+ sock.sendto("bubba", localAddr);
		71	+ do_recv(srvrSock);
		72	+
		73	+ return 0;
		74	+}
		75	+

tests/unit/test_acceptor.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_acceptor.cpp
		1	+// test_acceptor.cpp
		2	+//
		3	+// Unit tests for the `acceptor` class(es).
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/acceptor.h"
		42	+#include "sockpp/inet_address.h"
		43	+#include "catch2/catch.hpp"
		44	+#include <string>
		45	+
		46	+using namespace sockpp;
		47	+
		48	+TEST_CASE("acceptor default constructor", "[acceptor]") {
		49	+ acceptor sock;
		50	+ REQUIRE(!sock);
		51	+ REQUIRE(!sock.is_open());
		52	+}
		53	+
		54	+TEST_CASE("acceptor handle constructor", "[acceptor]") {
		55	+ constexpr auto HANDLE = socket_t(3);
		56	+
		57	+ SECTION("valid handle") {
		58	+ acceptor sock(HANDLE);
		59	+ REQUIRE(sock);
		60	+ REQUIRE(sock.is_open());
		61	+ }
		62	+
		63	+ SECTION("invalid handle") {
		64	+ acceptor sock(INVALID_SOCKET);
		65	+ REQUIRE(!sock);
		66	+ REQUIRE(!sock.is_open());
		67	+ // TODO: Should this set an error?
		68	+ REQUIRE(sock.last_error() == 0);
		69	+ }
		70	+}
		71	+
		72	+TEST_CASE("acceptor address constructor", "[acceptor]") {
		73	+ SECTION("valid address") {
		74	+ const auto ADDR = inet_address("localhost", 12345);
		75	+
		76	+ acceptor sock(ADDR);
		77	+ REQUIRE(sock);
		78	+ REQUIRE(sock.is_open());
		79	+ REQUIRE(sock.last_error() == 0);
		80	+ REQUIRE(sock.address() == ADDR);
		81	+ }
		82	+
		83	+ SECTION("invalid address") {
		84	+ const auto ADDR = sock_address_any{};
		85	+
		86	+ acceptor sock(ADDR);
		87	+ REQUIRE(!sock);
		88	+ REQUIRE(!sock.is_open());
		89	+
		90	+ // Windows returns a different error code than *nix
		91	+ #if defined(_WIN32)
		92	+ REQUIRE(sock.last_error() == WSAEINVAL);
		93	+ #else
		94	+ REQUIRE(sock.last_error() == EAFNOSUPPORT);
		95	+ #endif
		96	+ }
		97	+}
		98	+
		99	+TEST_CASE("acceptor create", "[acceptor]") {
		100	+ SECTION("valid domain") {
		101	+ auto sock = acceptor::create(AF_INET);
		102	+
		103	+ REQUIRE(sock);
		104	+ REQUIRE(sock.is_open());
		105	+ REQUIRE(sock.last_error() == 0);
		106	+
		107	+ // Windows returns unknown family for unbound socket
		108	+ // Windows returns a different error code than *nix
		109	+ #if defined(_WIN32)
		110	+ REQUIRE(sock.family() == AF_UNSPEC);
		111	+ #else
		112	+ REQUIRE(sock.family() == AF_INET);
		113	+ #endif
		114	+ }
		115	+
		116	+ SECTION("invalid domain") {
		117	+ auto sock = acceptor::create(AF_UNSPEC);
		118	+
		119	+ REQUIRE(!sock);
		120	+ REQUIRE(!sock.is_open());
		121	+
		122	+ // Windows returns a different error code than *nix
		123	+ #if defined(_WIN32)
		124	+ REQUIRE(sock.last_error() == WSAEINVAL);
		125	+ #else
		126	+ REQUIRE(sock.last_error() == EAFNOSUPPORT);
		127	+ #endif
		128	+ }
		129	+}
		130	+

tests/unit/test_connector.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_connector.cpp
		1	+// test_connector.cpp
		2	+//
		3	+// Unit tests for the `connector` class(es).
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/connector.h"
		42	+#include "sockpp/sock_address.h"
		43	+#include "catch2/catch.hpp"
		44	+#include <string>
		45	+
		46	+using namespace sockpp;
		47	+
		48	+// Test that connector errors properly when given an empty address.
		49	+TEST_CASE("connector unspecified address", "[connector]") {
		50	+ connector conn;
		51	+ REQUIRE(!conn);
		52	+
		53	+ sock_address_any addr;
		54	+
		55	+ bool ok = conn.connect(addr);
		56	+ REQUIRE(!ok);
		57	+
		58	+ // Windows returns a different error code than *nix
		59	+ #if defined(_WIN32)
		60	+ REQUIRE(conn.last_error() == WSAENOTSOCK);
		61	+ #else
		62	+ REQUIRE(conn.last_error() == EAFNOSUPPORT);
		63	+ #endif
		64	+}
		65	+
		66	+

tests/unit/test_datagram_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_datagram_socket.cpp
		1	+// test_datagram_socket.cpp
		2	+//
		3	+// Unit tests for the `datagram_socket` class(es).
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/datagram_socket.h"
		42	+#include "sockpp/inet_address.h"
		43	+#include "catch2/catch.hpp"
		44	+#include <string>
		45	+
		46	+using namespace sockpp;
		47	+
		48	+TEST_CASE("datagram_socket default constructor", "[datagram_socket]") {
		49	+ datagram_socket sock;
		50	+ REQUIRE(!sock);
		51	+ REQUIRE(!sock.is_open());
		52	+}
		53	+
		54	+TEST_CASE("datagram_socket handle constructor", "[datagram_socket]") {
		55	+ constexpr auto HANDLE = socket_t(3);
		56	+
		57	+ SECTION("valid handle") {
		58	+ datagram_socket sock(HANDLE);
		59	+ REQUIRE(sock);
		60	+ REQUIRE(sock.is_open());
		61	+ }
		62	+
		63	+ SECTION("invalid handle") {
		64	+ datagram_socket sock(INVALID_SOCKET);
		65	+ REQUIRE(!sock);
		66	+ REQUIRE(!sock.is_open());
		67	+ // TODO: Should this set an error?
		68	+ REQUIRE(sock.last_error() == 0);
		69	+ }
		70	+}
		71	+
		72	+TEST_CASE("datagram_socket address constructor", "[datagram_socket]") {
		73	+ SECTION("valid address") {
		74	+ const auto ADDR = inet_address("localhost", 12345);
		75	+
		76	+ datagram_socket sock(ADDR);
		77	+ REQUIRE(sock);
		78	+ REQUIRE(sock.is_open());
		79	+ REQUIRE(sock.last_error() == 0);
		80	+ REQUIRE(sock.address() == ADDR);
		81	+ }
		82	+
		83	+ SECTION("invalid address") {
		84	+ const auto ADDR = sock_address_any();
		85	+
		86	+ datagram_socket sock(ADDR);
		87	+ REQUIRE(!sock);
		88	+ REQUIRE(!sock.is_open());
		89	+
		90	+ // Windows returns a different error code than *nix
		91	+ #if defined(_WIN32)
		92	+ REQUIRE(sock.last_error() == WSAEINVAL);
		93	+ #else
		94	+ REQUIRE(sock.last_error() == EAFNOSUPPORT);
		95	+ #endif
		96	+ }
		97	+}
		98	+

tests/unit/test_inet_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_inet_address.cpp
		1	+// test_inet_address.cpp
		2	+//
		3	+// Unit tests for the `inet_address` class.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2018 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/inet_address.h"
		42	+#include "catch2/catch.hpp"
		43	+#include <string>
		44	+
		45	+using namespace sockpp;
		46	+
		47	+const uint32_t ANY_ADDR { INADDR_ANY }; // Any iface 0x00000000
		48	+const uint32_t LOCALHOST_ADDR { INADDR_LOOPBACK }; // Localhost 0x7F000001
		49	+const std::string LOCALHOST_STR { "localhost" };
		50	+const in_port_t PORT { 12345 };
		51	+
		52	+TEST_CASE("inet_address default constructor", "[address]") {
		53	+ inet_address addr;
		54	+
		55	+ REQUIRE(!addr.is_set());
		56	+ REQUIRE(0 == addr.address());
		57	+ REQUIRE(0 == addr.port());
		58	+ REQUIRE(sizeof(sockaddr_in) == addr.size());
		59	+
		60	+ SECTION("creating address from int32") {
		61	+ addr.create(LOCALHOST_ADDR, PORT);
		62	+
		63	+ REQUIRE(addr.is_set());
		64	+ REQUIRE(LOCALHOST_ADDR == addr.address());
		65	+ REQUIRE(PORT == addr.port());
		66	+
		67	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 0) &0xFF) == addr[0]);
		68	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 8) &0xFF) == addr[1]);
		69	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 16) &0xFF) == addr[2]);
		70	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 24) &0xFF) == addr[3]);
		71	+
		72	+ // Check the low-level struct
		73	+ REQUIRE(AF_INET == addr.sockaddr_in_ptr()->sin_family);
		74	+ REQUIRE(LOCALHOST_ADDR == ntohl(addr.sockaddr_in_ptr()->sin_addr.s_addr));
		75	+ REQUIRE(PORT == ntohs(addr.sockaddr_in_ptr()->sin_port));
		76	+ }
		77	+
		78	+ SECTION("creating address from name") {
		79	+ addr.create(LOCALHOST_STR, PORT);
		80	+
		81	+ REQUIRE(addr.is_set());
		82	+ REQUIRE(LOCALHOST_ADDR == addr.address());
		83	+ REQUIRE(PORT == addr.port());
		84	+
		85	+ // Check the low-level struct
		86	+ REQUIRE(AF_INET == addr.sockaddr_in_ptr()->sin_family);
		87	+ REQUIRE(LOCALHOST_ADDR == ntohl(addr.sockaddr_in_ptr()->sin_addr.s_addr));
		88	+ REQUIRE(PORT == ntohs(addr.sockaddr_in_ptr()->sin_port));
		89	+ }
		90	+}
		91	+
		92	+// When created using only a port number this should use the
		93	+// "any" address to bind to all interfaces (typ for server)
		94	+TEST_CASE("inet_address port-only constructor", "[address]") {
		95	+ inet_address addr(PORT);
		96	+
		97	+ REQUIRE(addr.is_set());
		98	+ REQUIRE(ANY_ADDR == addr.address());
		99	+ REQUIRE(PORT == addr.port());
		100	+
		101	+ // Check the low-level struct
		102	+ REQUIRE(AF_INET == addr.sockaddr_in_ptr()->sin_family);
		103	+}
		104	+
		105	+TEST_CASE("inet_address int32_t constructor", "[address]") {
		106	+ inet_address addr(LOCALHOST_ADDR, PORT);
		107	+
		108	+ REQUIRE(addr.is_set());
		109	+ REQUIRE(LOCALHOST_ADDR == addr.address());
		110	+ REQUIRE(PORT == addr.port());
		111	+
		112	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 0) &0xFF) == addr[0]);
		113	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 8) &0xFF) == addr[1]);
		114	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 16) &0xFF) == addr[2]);
		115	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 24) &0xFF) == addr[3]);
		116	+
		117	+ // Check the low-level struct
		118	+ REQUIRE(AF_INET == addr.sockaddr_in_ptr()->sin_family);
		119	+ REQUIRE(LOCALHOST_ADDR == ntohl(addr.sockaddr_in_ptr()->sin_addr.s_addr));
		120	+ REQUIRE(PORT == ntohs(addr.sockaddr_in_ptr()->sin_port));
		121	+}
		122	+
		123	+TEST_CASE("inet_address name constructor", "[address]") {
		124	+ inet_address addr(LOCALHOST_STR, PORT);
		125	+
		126	+ REQUIRE(addr.is_set());
		127	+ REQUIRE(LOCALHOST_ADDR == addr.address());
		128	+ REQUIRE(PORT == addr.port());
		129	+
		130	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 0) &0xFF) == addr[0]);
		131	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 8) &0xFF) == addr[1]);
		132	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 16) &0xFF) == addr[2]);
		133	+ REQUIRE(uint8_t((LOCALHOST_ADDR >> 24) &0xFF) == addr[3]);
		134	+
		135	+ // Check the low-level struct
		136	+ REQUIRE(AF_INET == addr.sockaddr_in_ptr()->sin_family);
		137	+ REQUIRE(LOCALHOST_ADDR == ntohl(addr.sockaddr_in_ptr()->sin_addr.s_addr));
		138	+ REQUIRE(PORT == ntohs(addr.sockaddr_in_ptr()->sin_port));
		139	+}
		140	+
		141	+TEST_CASE("IPv4 resolve_address", "[address]") {
		142	+ REQUIRE(inet_address::resolve_name("127.0.0.1") == htonl(LOCALHOST_ADDR));
		143	+ REQUIRE(inet_address::resolve_name(LOCALHOST_STR) == htonl(LOCALHOST_ADDR));
		144	+}

tests/unit/test_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_socket.cpp
		1	+// test_socket.cpp
		2	+//
		3	+// Unit tests for the base `socket` class.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/socket.h"
		42	+#include "sockpp/inet_address.h"
		43	+#include "catch2/catch.hpp"
		44	+#include <string>
		45	+
		46	+using namespace sockpp;
		47	+using namespace std::chrono;
		48	+
		49	+/////////////////////////////////////////////////////////////////////////////
		50	+// Aux functions
		51	+
		52	+TEST_CASE("test to_timeval", "aux") {
		53	+ SECTION("concrete function") {
		54	+ timeval tv = to_timeval(microseconds(500));
		55	+ REQUIRE(tv.tv_sec == 0);
		56	+ REQUIRE(tv.tv_usec == 500);
		57	+
		58	+ tv = to_timeval(microseconds(2500000));
		59	+ REQUIRE(tv.tv_sec == 2);
		60	+ REQUIRE(tv.tv_usec == 500000);
		61	+ }
		62	+
		63	+ SECTION("template") {
		64	+ timeval tv = to_timeval(milliseconds(1));
		65	+ REQUIRE(tv.tv_sec == 0);
		66	+ REQUIRE(tv.tv_usec == 1000);
		67	+
		68	+ tv = to_timeval(milliseconds(2500));
		69	+ REQUIRE(tv.tv_sec == 2);
		70	+ REQUIRE(tv.tv_usec == 500000);
		71	+
		72	+ tv = to_timeval(seconds(5));
		73	+ REQUIRE(tv.tv_sec == 5);
		74	+ REQUIRE(tv.tv_usec == 0);
		75	+ }
		76	+}
		77	+
		78	+/////////////////////////////////////////////////////////////////////////////
		79	+// socket class
		80	+
		81	+constexpr in_port_t INET_TEST_PORT = 12346;
		82	+
		83	+TEST_CASE("socket constructors", "[socket]") {
		84	+ SECTION("default constructor") {
		85	+ sockpp::socket sock;
		86	+
		87	+ REQUIRE(!sock);
		88	+ REQUIRE(!sock.is_open());
		89	+ REQUIRE(sock.handle() == INVALID_SOCKET);
		90	+ REQUIRE(sock.last_error() == 0);
		91	+ }
		92	+
		93	+ SECTION("handle constructor") {
		94	+ constexpr auto HANDLE = socket_t(3);
		95	+ sockpp::socket sock(HANDLE);
		96	+
		97	+ REQUIRE(sock);
		98	+ REQUIRE(sock.is_open());
		99	+ REQUIRE(sock.handle() == HANDLE);
		100	+ REQUIRE(sock.last_error() == 0);
		101	+ }
		102	+
		103	+
		104	+ SECTION("move constructor") {
		105	+ constexpr auto HANDLE = socket_t(3);
		106	+ sockpp::socket org_sock(HANDLE);
		107	+
		108	+ sockpp::socket sock(std::move(org_sock));
		109	+
		110	+ // Make sure the new socket got the handle
		111	+ REQUIRE(sock);
		112	+ REQUIRE(sock.handle() == HANDLE);
		113	+ REQUIRE(sock.last_error() == 0);
		114	+
		115	+ // Make sure the handle was moved out of the org_sock
		116	+ REQUIRE(!org_sock);
		117	+ REQUIRE(org_sock.handle() == INVALID_SOCKET);
		118	+ }
		119	+}
		120	+
		121	+// Test the socket error behavior
		122	+TEST_CASE("socket errors", "[socket]") {
		123	+ SECTION("basic errors") {
		124	+ sockpp::socket sock;
		125	+
		126	+ // Operations on an unopened socket should give an error
		127	+ int reuse = 1;
		128	+ socklen_t len = sizeof(int);
		129	+ bool ok = sock.get_option(SOL_SOCKET, SO_REUSEADDR, &reuse, &len);
		130	+
		131	+ // Socket should be in error state
		132	+ REQUIRE(!ok);
		133	+ REQUIRE(!sock);
		134	+
		135	+ int err = sock.last_error();
		136	+ REQUIRE(err != 0);
		137	+
		138	+ // last_error() is sticky, unlike `errno`
		139	+ REQUIRE(sock.last_error() == err);
		140	+
		141	+ // We can clear the error
		142	+ sock.clear();
		143	+ REQUIRE(sock.last_error() == 0);
		144	+
		145	+ // Test arbitrary clear value
		146	+ sock.clear(42);
		147	+ REQUIRE(sock.last_error() == 42);
		148	+ REQUIRE(!sock);
		149	+ }
		150	+
		151	+ SECTION("clear error") {
		152	+ auto sock = sockpp::socket::create(AF_INET, SOCK_STREAM);
		153	+ REQUIRE(sock);
		154	+
		155	+ sock.clear(42);
		156	+ REQUIRE(!sock);
		157	+
		158	+ sock.clear();
		159	+ REQUIRE(sock);
		160	+ }
		161	+}
		162	+
		163	+TEST_CASE("socket handles", "[socket]") {
		164	+
		165	+ constexpr auto HANDLE = socket_t(3);
		166	+
		167	+ SECTION("test release") {
		168	+ sockpp::socket sock(HANDLE);
		169	+
		170	+ REQUIRE(sock.handle() == HANDLE);
		171	+ REQUIRE(sock.release() == HANDLE);
		172	+
		173	+ // Make sure the handle was moved out of the sock
		174	+ REQUIRE(!sock);
		175	+ REQUIRE(sock.handle() == INVALID_SOCKET);
		176	+ }
		177	+
		178	+ SECTION("test reset") {
		179	+ sockpp::socket sock(HANDLE);
		180	+ REQUIRE(sock.handle() == HANDLE);
		181	+
		182	+ sock.reset(); // Default reset acts like release w/o return
		183	+
		184	+ // Make sure the handle was moved out of the sock
		185	+ REQUIRE(!sock);
		186	+ REQUIRE(sock.handle() == INVALID_SOCKET);
		187	+
		188	+ // Now reset with a "valid" handle
		189	+ sock.reset(HANDLE);
		190	+ REQUIRE(sock);
		191	+ REQUIRE(sock.handle() == HANDLE);
		192	+ }
		193	+}
		194	+
		195	+TEST_CASE("socket family", "[socket]") {
		196	+ SECTION("uninitialized socket") {
		197	+ // Uninitialized socket should have unspecified family
		198	+ sockpp::socket sock;
		199	+ REQUIRE(sock.family() == AF_UNSPEC);
		200	+ }
		201	+
		202	+ SECTION("unbound socket") {
		203	+ // Unbound socket should have creation family
		204	+ auto sock = socket::create(AF_INET, SOCK_STREAM);
		205	+
		206	+ // Windows and *nix behave differently
		207	+ #if defined(_WIN32)
		208	+ REQUIRE(sock.family() == AF_UNSPEC);
		209	+ #else
		210	+ REQUIRE(sock.family() == AF_INET);
		211	+ #endif
		212	+ }
		213	+
		214	+ SECTION("bound socket") {
		215	+ // Bound socket should have same family as
		216	+ // address to which it's bound
		217	+ auto sock = socket::create(AF_INET, SOCK_STREAM);
		218	+ inet_address addr(INET_TEST_PORT);
		219	+
		220	+ int reuse = 1;
		221	+ REQUIRE(sock.set_option(SOL_SOCKET, SO_REUSEADDR, reuse));
		222	+ REQUIRE(sock.bind(addr));
		223	+ REQUIRE(sock.family() == addr.family());
		224	+ }
		225	+}
		226	+
		227	+TEST_CASE("socket address", "[socket]") {
		228	+ SECTION("uninitialized socket") {
		229	+ // Uninitialized socket should have empty address
		230	+ sockpp::socket sock;
		231	+ REQUIRE(sock.address() == sock_address_any{});
		232	+ }
		233	+
		234	+ // The address has the specified family but all zeros
		235	+ SECTION("unbound socket") {
		236	+ auto sock = socket::create(AF_INET, SOCK_STREAM);
		237	+ auto addr = inet_address(sock.address());
		238	+
		239	+ // Windows and *nix behave differently for family
		240	+ #if defined(_WIN32)
		241	+ REQUIRE(sock.family() == AF_UNSPEC);
		242	+ #else
		243	+ REQUIRE(sock.family() == AF_INET);
		244	+ #endif
		245	+
		246	+ REQUIRE(addr.address() == 0);
		247	+ REQUIRE(addr.port() == 0);
		248	+ }
		249	+
		250	+ SECTION("bound socket") {
		251	+ // Bound socket should have same family as
		252	+ // address to which it's bound
		253	+ auto sock = socket::create(AF_INET, SOCK_STREAM);
		254	+ const inet_address ADDR(INET_TEST_PORT);
		255	+
		256	+ int reuse = 1;
		257	+ REQUIRE(sock.set_option(SOL_SOCKET, SO_REUSEADDR, reuse));
		258	+
		259	+ REQUIRE(sock.bind(ADDR));
		260	+ REQUIRE(sock.address() == ADDR);
		261	+ }
		262	+}
		263	+
		264	+// Socket pair shouldn't work for TCP sockets on any known platform.
		265	+// So this should fail, but fail gracefully and retain the error
		266	+// in both sockets.
		267	+TEST_CASE("failed socket pair", "[socket]") {
		268	+ sockpp::socket sock1, sock2;
		269	+ std::tie(sock1, sock2) = std::move(socket::pair(AF_INET, SOCK_STREAM));
		270	+
		271	+ REQUIRE(!sock1);
		272	+ REQUIRE(!sock2);
		273	+
		274	+ REQUIRE(sock1.last_error() != 0);
		275	+ REQUIRE(sock1.last_error() == sock2.last_error());
		276	+}
		277	+
		278	+// --------------------------------------------------------------------------
		279	+
		280	+// Test that the "last error" call to a socket gives the proper result
		281	+// for the current thread.
		282	+// Here we share a socket across two threads, force an error in one
		283	+// thread, and then check to make sure that the error did not propagate
		284	+// to the other thread.
		285	+//
		286	+#if 0
		287	+TEST_CASE("thread-safe last error", "[socket]") {
		288	+ sockpp::socket sock;
		289	+
		290	+ int state = 0;
		291	+ std::mutex m;
		292	+ std::condition_variable cv;
		293	+
		294	+ std::thread thr([&] {
		295	+ // Test #1
		296	+ REQUIRE(sock.last_error() == 0);
		297	+ {
		298	+ // Wait for Test #2
		299	+ std::unique_lock<std::mutex> lk(m);
		300	+ state = 1;
		301	+ cv.notify_one();
		302	+ cv.wait(lk, [&state]{return state >= 2;});
		303	+ }
		304	+
		305	+ // Test #3
		306	+ REQUIRE(sock.last_error() == 0);
		307	+ });
		308	+
		309	+ {
		310	+ // Wait for Test #1
		311	+ std::unique_lock<std::mutex> lk(m);
		312	+ cv.wait(lk, [&state]{return state >= 1;});
		313	+ }
		314	+
		315	+ // Test #2
		316	+ // Setting options on an un-opened socket should generate an error
		317	+ int reuse = 1;
		318	+ socklen_t len = sizeof(int);
		319	+ bool ok = sock.get_option(SOL_SOCKET, SO_REUSEADDR, &reuse, &len);
		320	+
		321	+ REQUIRE(!ok);
		322	+ REQUIRE(sock.last_error() != 0);
		323	+
		324	+ {
		325	+ std::unique_lock<std::mutex> lk(m);
		326	+ state = 2;
		327	+ cv.notify_one();
		328	+ }
		329	+ thr.join();
		330	+}
		331	+#endif
		332	+

tests/unit/test_stream_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_stream_socket.cpp
		1	+// test_stream_socket.cpp
		2	+//
		3	+// Unit tests for the `stream_socket` class(es).
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/stream_socket.h"
		42	+#include "sockpp/inet_address.h"
		43	+#include "catch2/catch.hpp"
		44	+#include <string>
		45	+
		46	+using namespace sockpp;
		47	+
		48	+TEST_CASE("stream_socket default constructor", "[stream_socket]") {
		49	+ stream_socket sock;
		50	+ REQUIRE(!sock);
		51	+ REQUIRE(!sock.is_open());
		52	+}
		53	+
		54	+TEST_CASE("stream_socket handle constructor", "[stream_socket]") {
		55	+ constexpr auto HANDLE = socket_t(3);
		56	+
		57	+ SECTION("valid handle") {
		58	+ stream_socket sock(HANDLE);
		59	+ REQUIRE(sock);
		60	+ REQUIRE(sock.is_open());
		61	+ }
		62	+
		63	+ SECTION("invalid handle") {
		64	+ stream_socket sock(INVALID_SOCKET);
		65	+ REQUIRE(!sock);
		66	+ REQUIRE(!sock.is_open());
		67	+ // TODO: Should this set an error?
		68	+ REQUIRE(sock.last_error() == 0);
		69	+ }
		70	+}
		71	+
		72	+#if 0
		73	+TEST_CASE("stream_socket address constructor", "[stream_socket]") {
		74	+ SECTION("valid address") {
		75	+ const auto ADDR = inet_address("localhost", 12345);
		76	+
		77	+ stream_socket sock(ADDR);
		78	+ REQUIRE(sock);
		79	+ REQUIRE(sock.is_open());
		80	+ REQUIRE(sock.last_error() == 0);
		81	+ REQUIRE(sock.address() == ADDR);
		82	+ }
		83	+
		84	+ SECTION("invalid address") {
		85	+ const auto ADDR = sock_address_any();
		86	+
		87	+ stream_socket sock(ADDR);
		88	+ REQUIRE(!sock);
		89	+ REQUIRE(!sock.is_open());
		90	+ REQUIRE(sock.last_error() == EAFNOSUPPORT);
		91	+ }
		92	+}
		93	+#endif
		94	+
		95	+// --------------------------------------------------------------------------
		96	+// Connected tests
		97	+
		98	+TEST_CASE("stream_socket readn, writen", "[stream_socket]") {
		99	+ //auto lsock = stream_socket::create(AF
		100	+}

tests/unit/test_tcp_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_tcp_socket.cpp
		1	+// test_tcp_socket.cpp
		2	+//
		3	+// Unit tests for the `tcp_socket` class(es).
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/tcp_socket.h"
		42	+#include "sockpp/tcp_connector.h"
		43	+#include "sockpp/tcp_acceptor.h"
		44	+#include "catch2/catch.hpp"
		45	+#include <string>
		46	+
		47	+using namespace sockpp;
		48	+
		49	+static const in_port_t TEST_PORT = 12345;
		50	+
		51	+TEST_CASE("tcp_socket default constructor", "[tcp_socket]") {
		52	+ tcp_socket sock;
		53	+ REQUIRE(!sock);
		54	+ REQUIRE(!sock.is_open());
		55	+
		56	+ //REQUIRE(sock.family() == AF_INET);
		57	+}
		58	+
		59	+TEST_CASE("tcp_socket handle constructor", "[tcp_socket]") {
		60	+ constexpr auto HANDLE = socket_t(3);
		61	+
		62	+ SECTION("valid handle") {
		63	+ tcp_socket sock(HANDLE);
		64	+ REQUIRE(sock);
		65	+ REQUIRE(sock.is_open());
		66	+
		67	+ //REQUIRE(sock.family() == AF_INET);
		68	+ }
		69	+
		70	+ SECTION("invalid handle") {
		71	+ tcp_socket sock(INVALID_SOCKET);
		72	+ REQUIRE(!sock);
		73	+ REQUIRE(!sock.is_open());
		74	+ // TODO: Should this set an error?
		75	+ REQUIRE(sock.last_error() == 0);
		76	+
		77	+ //REQUIRE(sock.family() == AF_INET);
		78	+ }
		79	+}
		80	+
		81	+// --------------------------------------------------------------------------
		82	+// Connected tests
		83	+
		84	+TEST_CASE("tcp_socket read/write", "[stream_socket]") {
		85	+ const std::string STR { "This is a test. This is only a test." };
		86	+ const size_t N = STR.length();
		87	+
		88	+ inet_address addr { "localhost", TEST_PORT };
		89	+ tcp_acceptor asock{ addr };
		90	+
		91	+ tcp_connector csock;
		92	+ csock.set_non_blocking();
		93	+
		94	+ REQUIRE(csock.connect(addr));
		95	+
		96	+ auto ssock = asock.accept();
		97	+ REQUIRE(ssock);
		98	+
		99	+ SECTION("read_n/write_n") {
		100	+ char buf[512]; // N
		101	+
		102	+ REQUIRE(csock.write_n(STR.data(), N) == N);
		103	+ REQUIRE(ssock.read_n(buf, N) == N);
		104	+
		105	+ std::string str { buf, buf+N };
		106	+ REQUIRE(str == STR);
		107	+
		108	+ char buf2[512]; // N
		109	+
		110	+ // string write is a write_n()
		111	+ REQUIRE(csock.write(STR) == N);
		112	+ REQUIRE(ssock.read_n(buf2, N) == N);
		113	+
		114	+ std::string str2 { buf2, buf2+N };
		115	+ REQUIRE(str2 == STR);
		116	+ }
		117	+
		118	+ SECTION("scatter/gather") {
		119	+ const std::string HEADER { "<start>" },
		120	+ FOOTER { "<end>" };
		121	+
		122	+ const size_t N_HEADER = HEADER.length(),
		123	+ N_FOOTER = FOOTER.length(),
		124	+ N_TOT = N_HEADER + N + N_FOOTER;
		125	+
		126	+ std::vector<iovec> outv {
		127	+ iovec { (void*) HEADER.data(), N_HEADER },
		128	+ iovec { (void*) STR.data(), N },
		129	+ iovec { (void*) FOOTER.data(), N_FOOTER }
		130	+ };
		131	+
		132	+ char hbuf[512], // N_HEADER
		133	+ buf[512], // N
		134	+ fbuf[512]; // N_FOOTER
		135	+
		136	+ std::vector<iovec> inv {
		137	+ iovec { (void*) hbuf, N_HEADER },
		138	+ iovec { (void*) buf, N },
		139	+ iovec { (void*) fbuf, N_FOOTER }
		140	+ };
		141	+
		142	+ REQUIRE(csock.write(outv) == N_TOT);
		143	+ REQUIRE(csock.write(outv) == N_TOT);
		144	+ REQUIRE(csock.write(outv) == N_TOT);
		145	+
		146	+ REQUIRE(ssock.read(inv) == N_TOT);
		147	+
		148	+ REQUIRE(std::string(hbuf, N_HEADER) == HEADER);
		149	+ REQUIRE(std::string(buf, N) == STR);
		150	+ REQUIRE(std::string(fbuf, N_FOOTER) == FOOTER);
		151	+ }
		152	+}
		153	+
		154	+

tests/unit/test_unix_address.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_unix_address.cpp
		1	+// test_unix_address.cpp
		2	+//
		3	+// Unit tests for the `unix_address` class.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2018 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/unix_address.h"
		42	+#include "catch2/catch.hpp"
		43	+#include <string>
		44	+
		45	+using namespace sockpp;
		46	+
		47	+std::string PATH { "/tmp/sock" };
		48	+
		49	+TEST_CASE("unix_address default constructor", "[address]") {
		50	+ unix_address addr;
		51	+
		52	+ REQUIRE(!addr.is_set());
		53	+ REQUIRE(addr.path().empty());
		54	+ REQUIRE(sizeof(sockaddr_un) == addr.size());
		55	+
		56	+ // TODO: Do we have a unix_address::create() method yet?
		57	+}
		58	+
		59	+TEST_CASE("unix_address path constructor", "[address]") {
		60	+ unix_address addr(PATH);
		61	+
		62	+ REQUIRE(addr.is_set());
		63	+ REQUIRE(PATH == addr.path());
		64	+ REQUIRE(sizeof(sockaddr_un) == addr.size());
		65	+
		66	+ // Check the low-level struct
		67	+ REQUIRE(AF_UNIX == addr.sockaddr_un_ptr()->sun_family);
		68	+ REQUIRE(0 == strcmp(PATH.c_str(),
		69	+ (const char*) &addr.sockaddr_un_ptr()->sun_path));
		70	+
		71	+ SECTION("copy constructor") {
		72	+ unix_address addr2(addr);
		73	+
		74	+ REQUIRE(addr2.is_set());
		75	+ REQUIRE(PATH == addr2.path());
		76	+ REQUIRE(sizeof(sockaddr_un) == addr2.size());
		77	+
		78	+ // Check the low-level struct
		79	+ REQUIRE(AF_UNIX == addr2.sockaddr_un_ptr()->sun_family);
		80	+ REQUIRE(0 == strcmp(PATH.c_str(),
		81	+ (const char*) &addr2.sockaddr_un_ptr()->sun_path));
		82	+ }
		83	+
		84	+ SECTION("sockaddr conversions") {
		85	+ auto sa = addr.sockaddr_ptr();
		86	+ unix_address addr2(*sa);
		87	+
		88	+ REQUIRE(addr2.is_set());
		89	+ REQUIRE(PATH == addr2.path());
		90	+ REQUIRE(sizeof(sockaddr_un) == addr2.size());
		91	+
		92	+ // Check the low-level struct
		93	+ REQUIRE(AF_UNIX == addr2.sockaddr_un_ptr()->sun_family);
		94	+ REQUIRE(0 == strcmp(PATH.c_str(),
		95	+ (const char*) &(addr2.sockaddr_un_ptr()->sun_path)));
		96	+ }
		97	+}
		98	+
		99	+TEST_CASE("unix_address sockaddr_un constructor", "[address]") {
		100	+ sockaddr_un unaddr;
		101	+ unaddr.sun_family = AF_UNIX;
		102	+ strcpy(unaddr.sun_path, PATH.c_str());
		103	+
		104	+ unix_address addr(unaddr);
		105	+
		106	+ REQUIRE(addr.is_set());
		107	+ REQUIRE(PATH == addr.path());
		108	+ REQUIRE(sizeof(sockaddr_un) == addr.size());
		109	+
		110	+ // Check the low-level struct
		111	+ REQUIRE(AF_UNIX == addr.sockaddr_un_ptr()->sun_family);
		112	+ REQUIRE(0 == strcmp(PATH.c_str(),
		113	+ (const char*) &addr.sockaddr_un_ptr()->sun_path));
		114	+
		115	+ // TODO: Restore this when all address checks in place
		116	+ /*
		117	+ SECTION("reject bad sockaddr_un") {
		118	+ unaddr.sun_family = AF_INET;
		119	+ REQUIRE_THROWS_AS([&] {
		120	+ unix_address addr2(unaddr);
		121	+ }(), std::invalid_argument);
		122	+ }
		123	+ */
		124	+}

tests/unit/test_unix_dgram_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_unix_dgram_socket.cpp
		1	+// test_unix_dgram_socket.cpp
		2	+//
		3	+// Unit tests for the `unix_dgram_socket` class.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/unix_dgram_socket.h"
		42	+#include "catch2/catch.hpp"
		43	+#include <string>
		44	+
		45	+using namespace sockpp;
		46	+
		47	+// Test that we can create a Unix-domain datagram socket pair and send data
		48	+// from one of the sockets to the other.
		49	+TEST_CASE("unix dgram socket pair", "[unix_dgram_socket]") {
		50	+ unix_dgram_socket sock1, sock2;
		51	+ std::tie(sock1, sock2) = std::move(unix_dgram_socket::pair());
		52	+
		53	+ REQUIRE(sock1);
		54	+ REQUIRE(sock2);
		55	+
		56	+ REQUIRE(sock1.is_open());
		57	+ REQUIRE(sock2.is_open());
		58	+
		59	+ const std::string MSG { "Hello there!" };
		60	+ const size_t N = MSG.length();
		61	+
		62	+ char buf[512];
		63	+
		64	+ REQUIRE(sock1.send(MSG) == N);
		65	+ REQUIRE(sock2.recv(buf, N) == N);
		66	+
		67	+ std::string msg { buf, buf+N };
		68	+ REQUIRE(msg == MSG);
		69	+}
		70	+
		71	+

tests/unit/test_unix_stream_socket.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/test_unix_stream_socket.cpp
		1	+// test_unix_stream_socket.cpp
		2	+//
		3	+// Unit tests for the `unix_stream_socket` class.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2019 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+#include "sockpp/unix_stream_socket.h"
		42	+#include "catch2/catch.hpp"
		43	+#include <string>
		44	+
		45	+using namespace sockpp;
		46	+
		47	+// Test that we can create a Unix-domain stream socket pair and send
		48	+// data from one of the sockets to the other.
		49	+TEST_CASE("unix stream socket pair", "[unix_stream_socket]") {
		50	+ unix_stream_socket sock1, sock2;
		51	+ std::tie(sock1, sock2) = std::move(unix_stream_socket::pair());
		52	+
		53	+ REQUIRE(sock1);
		54	+ REQUIRE(sock2);
		55	+
		56	+ REQUIRE(sock1.is_open());
		57	+ REQUIRE(sock2.is_open());
		58	+
		59	+ const std::string MSG { "Hello there!" };
		60	+ const size_t N = MSG.length();
		61	+
		62	+ char buf[512];
		63	+
		64	+ REQUIRE(sock1.write(MSG) == N);
		65	+ REQUIRE(sock2.read_n(buf, N) == N);
		66	+
		67	+ std::string msg { buf, buf+N };
		68	+ REQUIRE(msg == MSG);
		69	+}
		70	+
		71	+

tests/unit/unit_tests.cpp 0 → 100644

View file @48b4c72

		1	+++ a/tests/unit/unit_tests.cpp
		1	+// unit_tests.cpp
		2	+//
		3	+// Main for unit tests.
		4	+//
		5	+
		6	+// --------------------------------------------------------------------------
		7	+// This file is part of the "sockpp" C++ socket library.
		8	+//
		9	+// Copyright (c) 2018 Frank Pagliughi
		10	+// All rights reserved.
		11	+//
		12	+// Redistribution and use in source and binary forms, with or without
		13	+// modification, are permitted provided that the following conditions are
		14	+// met:
		15	+//
		16	+// 1. Redistributions of source code must retain the above copyright notice,
		17	+// this list of conditions and the following disclaimer.
		18	+//
		19	+// 2. Redistributions in binary form must reproduce the above copyright
		20	+// notice, this list of conditions and the following disclaimer in the
		21	+// documentation and/or other materials provided with the distribution.
		22	+//
		23	+// 3. Neither the name of the copyright holder nor the names of its
		24	+// contributors may be used to endorse or promote products derived from this
		25	+// software without specific prior written permission.
		26	+//
		27	+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
		28	+// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		29	+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		30	+// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
		31	+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
		32	+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
		33	+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
		34	+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
		35	+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
		36	+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
		37	+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		38	+// --------------------------------------------------------------------------
		39	+//
		40	+
		41	+// Normally, we would just tell Catch2 to define main() like this...
		42	+// This tells Catch to provide a main() - only do this in one cpp file
		43	+//#define CATCH_CONFIG_MAIN
		44	+
		45	+// ...but we need to run the sockpp global initialization before running
		46	+// any of the tests. Defining a main() is described here:
		47	+// https://github.com/catchorg/Catch2/blob/master/docs/own-main.md
		48	+//
		49	+
		50	+#include "sockpp/socket.h"
		51	+
		52	+// This seems to be required, at least for MSVS 2015 on Win7,
		53	+// using Catch2 v2.9.2
		54	+#if defined(_WIN32)
		55	+ #define CATCH_CONFIG_DISABLE_EXCEPTIONS
		56	+#endif
		57	+
		58	+#define CATCH_CONFIG_RUNNER
		59	+#include "catch2/catch.hpp"
		60	+
		61	+int main(int argc, char* argv[])
		62	+{
		63	+ // global setup...
		64	+ sockpp::socket_initializer sockInit;
		65	+
		66	+ int result = Catch::Session().run(argc, argv);
		67	+
		68	+ // global clean-up...
		69	+
		70	+ return result;
		71	+}