replace sockaddr_in -> sockaddr_storage to support IPv6

2025-12-21 05:25:40 +08:00 · 2019-10-23 12:04:06 +09:00
parent 47bc9c5bcd
commit 249bae1e7b
6 changed files with 122 additions and 108 deletions
--- a/DMRNetwork.cpp
+++ b/DMRNetwork.cpp
@@ -33,7 +33,7 @@ const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 55U;

 CDMRNetwork::CDMRNetwork(const std::string& address, unsigned int port, unsigned int local, unsigned int id, const std::string& password, const std::string& name, const char* version, bool debug) :
 m_address(),
-m_port(port),
+m_addrlen(),
 m_id(NULL),
 m_password(password),
 m_name(name),
@@ -57,7 +57,7 @@ m_beacon(false)
 	assert(!password.empty());
 	assert(version != NULL);

-	m_address = CUDPSocket::lookup(address);
+	CUDPSocket::lookup(address, port, m_address, m_addrlen);

 	m_buffer   = new unsigned char[BUFFER_LENGTH];
 	m_salt     = new unsigned char[sizeof(uint32_t)];
@@ -319,9 +319,9 @@ void CDMRNetwork::clock(unsigned int ms)
 		return;
 	}

-	in_addr address;
-	unsigned int port;
-	int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port);
+	sockaddr_storage address;
+	unsigned int addrlen;
+	int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, addrlen);
 	if (length < 0) {
 		LogError("%s, Socket has failed, retrying connection to the master", m_name.c_str());
 		close();
@@ -332,7 +332,28 @@ void CDMRNetwork::clock(unsigned int ms)
 	// if (m_debug && length > 0)
 	//	CUtils::dump(1U, "Network Received", m_buffer, length);

-	if (length > 0 && m_address.s_addr == address.s_addr && m_port == port) {
+	int valid_addr;
+	switch (address.ss_family) {
+	case AF_INET:
+		struct sockaddr_in *pi4, *pm4;
+		pi4 = (struct sockaddr_in *)&address;
+		pm4 = (struct sockaddr_in *)&m_address;
+		valid_addr = ((pi4->sin_addr.s_addr == pm4->sin_addr.s_addr) &&
+			      (pi4->sin_port == pm4->sin_port));
+		break;
+	case AF_INET6:
+		struct sockaddr_in6 *pi6, *pm6;
+		pi6 = (struct sockaddr_in6 *)&address;
+		pm6 = (struct sockaddr_in6 *)&m_address;
+		valid_addr = (!::memcmp(pi6->sin6_addr.s6_addr, pm6->sin6_addr.s6_addr, sizeof(in6_addr)) &&
+			      (pi6->sin6_port == pm6->sin6_port));
+		break;
+	default:
+		valid_addr = 0;
+		break;
+	}
+
+	if (length > 0 && valid_addr) {
 		if (::memcmp(m_buffer, "DMRD", 4U) == 0) {
 			if (m_debug)
 				CUtils::dump(1U, "Network Received", m_buffer, length);
@@ -527,7 +548,7 @@ bool CDMRNetwork::write(const unsigned char* data, unsigned int length)
 	// if (m_debug)
 	//	CUtils::dump(1U, "Network Transmitted", data, length);

-	bool ret = m_socket.write(data, length, m_address, m_port);
+	bool ret = m_socket.write(data, length, m_address, m_addrlen);
 	if (!ret) {
 		LogError("%s, Socket has failed when writing data to the master, retrying connection", m_name.c_str());
 		m_socket.close();
--- a/DMRNetwork.h
+++ b/DMRNetwork.h
@@ -58,8 +58,8 @@ public:
 	void close();

 private: 
-	in_addr      m_address;
-	unsigned int m_port;
+	sockaddr_storage m_address;
+	unsigned int     m_addrlen;
 	uint8_t*         m_id;
 	std::string      m_password;
 	std::string      m_name;
--- a/MMDVMNetwork.cpp
+++ b/MMDVMNetwork.cpp
@@ -33,7 +33,7 @@ const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 55U;

 CMMDVMNetwork::CMMDVMNetwork(const std::string& rptAddress, unsigned int rptPort, const std::string& localAddress, unsigned int localPort, bool debug) :
 m_rptAddress(),
-m_rptPort(rptPort),
+m_rptAddrLen(),
 m_id(0U),
 m_netId(NULL),
 m_debug(debug),
@@ -53,7 +53,7 @@ m_homePositionLen(0U)
 	assert(!rptAddress.empty());
 	assert(rptPort > 0U);

-	m_rptAddress = CUDPSocket::lookup(rptAddress);
+	CUDPSocket::lookup(rptAddress, rptPort, m_rptAddress, m_rptAddrLen);

 	m_buffer = new unsigned char[BUFFER_LENGTH];
 	m_netId  = new unsigned char[4U];
@@ -217,7 +217,7 @@ bool CMMDVMNetwork::write(const CDMRData& data)
 	if (m_debug)
 		CUtils::dump(1U, "Network Transmitted", buffer, HOMEBREW_DATA_PACKET_LENGTH);

-	m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptPort);
+	m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptAddrLen);

 	return true;
 }
@@ -267,7 +267,7 @@ bool CMMDVMNetwork::writeBeacon()
 	::memcpy(buffer + 0U, "RPTSBKN", 7U);
 	::memcpy(buffer + 7U, m_netId, 4U);

-	return m_socket.write(buffer, 11U, m_rptAddress, m_rptPort);
+	return m_socket.write(buffer, 11U, m_rptAddress, m_rptAddrLen);
 }

 void CMMDVMNetwork::close()
@@ -280,15 +280,15 @@ void CMMDVMNetwork::close()
 	::memcpy(buffer + 0U, "MSTCL", 5U);
 	::memcpy(buffer + 5U, m_netId, 4U);

-	m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptPort);
+	m_socket.write(buffer, HOMEBREW_DATA_PACKET_LENGTH, m_rptAddress, m_rptAddrLen);
 	m_socket.close();
 }

 void CMMDVMNetwork::clock(unsigned int ms)
 {
-	in_addr address;
-	unsigned int port;
-	int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port);
+	sockaddr_storage address;
+	unsigned int addrlen;
+	int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, addrlen);
 	if (length < 0) {
 		LogError("MMDVM Network, Socket has failed, reopening");
 		close();
@@ -299,7 +299,28 @@ void CMMDVMNetwork::clock(unsigned int ms)
 	// if (m_debug && length > 0)
 	//	CUtils::dump(1U, "Network Received", m_buffer, length);

-	if (length > 0 && m_rptAddress.s_addr == address.s_addr && m_rptPort == port) {
+	int valid_addr;
+	switch (address.ss_family) {
+	case AF_INET:
+		struct sockaddr_in *pi4, *pm4;
+		pi4 = (struct sockaddr_in *)&address;
+		pm4 = (struct sockaddr_in *)&m_rptAddress;
+		valid_addr = ((pi4->sin_addr.s_addr == pm4->sin_addr.s_addr) &&
+			      (pi4->sin_port == pm4->sin_port));
+		break;
+	case AF_INET6:
+		struct sockaddr_in6 *pi6, *pm6;
+		pi6 = (struct sockaddr_in6 *)&address;
+		pm6 = (struct sockaddr_in6 *)&m_rptAddress;
+		valid_addr = (!::memcmp(pi6->sin6_addr.s6_addr, pm6->sin6_addr.s6_addr, sizeof(in6_addr)) &&
+			      (pi6->sin6_port == pm6->sin6_port));
+		break;
+	default:
+		valid_addr = 0;
+		break;
+	}
+
+	if (length > 0 && valid_addr) {
 		if (::memcmp(m_buffer, "DMRD", 4U) == 0) {
 			if (m_debug)
 				CUtils::dump(1U, "Network Received", m_buffer, length);
@@ -326,12 +347,12 @@ void CMMDVMNetwork::clock(unsigned int ms)
 			uint32_t salt = 1U;
 			::memcpy(ack + 6U, &salt, sizeof(uint32_t));

-			m_socket.write(ack, 10U, m_rptAddress, m_rptPort);
+			m_socket.write(ack, 10U, m_rptAddress, m_rptAddrLen);
 		} else if (::memcmp(m_buffer, "RPTK", 4U) == 0) {
 			unsigned char ack[10U];
 			::memcpy(ack + 0U, "RPTACK", 6U);
 			::memcpy(ack + 6U, m_netId, 4U);
-			m_socket.write(ack, 10U, m_rptAddress, m_rptPort);
+			m_socket.write(ack, 10U, m_rptAddress, m_rptAddrLen);
 		} else if (::memcmp(m_buffer, "RPTCL", 5U) == 0) {
 			::LogMessage("MMDVM Network, The connected MMDVM is closing down");
 		} else if (::memcmp(m_buffer, "RPTC", 4U) == 0) {
@@ -342,19 +363,19 @@ void CMMDVMNetwork::clock(unsigned int ms)
 			unsigned char ack[10U];
 			::memcpy(ack + 0U, "RPTACK", 6U);
 			::memcpy(ack + 6U, m_netId, 4U);
-			m_socket.write(ack, 10U, m_rptAddress, m_rptPort);
+			m_socket.write(ack, 10U, m_rptAddress, m_rptAddrLen);
 		} else if (::memcmp(m_buffer, "RPTO", 4U) == 0) {
 			m_options = std::string((char*)(m_buffer + 8U), length - 8U);

 			unsigned char ack[10U];
 			::memcpy(ack + 0U, "RPTACK", 6U);
 			::memcpy(ack + 6U, m_netId, 4U);
-			m_socket.write(ack, 10U, m_rptAddress, m_rptPort);
+			m_socket.write(ack, 10U, m_rptAddress, m_rptAddrLen);
 		} else if (::memcmp(m_buffer, "RPTPING", 7U) == 0) {
 			unsigned char pong[11U];
 			::memcpy(pong + 0U, "MSTPONG", 7U);
 			::memcpy(pong + 7U, m_netId, 4U);
-			m_socket.write(pong, 11U, m_rptAddress, m_rptPort);
+			m_socket.write(pong, 11U, m_rptAddress, m_rptAddrLen);
 		} else {
 			CUtils::dump("Unknown packet from the master", m_buffer, length);
 		}
--- a/MMDVMNetwork.h
+++ b/MMDVMNetwork.h
@@ -59,8 +59,8 @@ public:
 	virtual void close();

 private: 
-	in_addr                    m_rptAddress;
-	unsigned int               m_rptPort;
+	sockaddr_storage           m_rptAddress;
+	unsigned int               m_rptAddrLen;
 	unsigned int               m_id;
 	unsigned char*             m_netId;
 	bool                       m_debug;
--- a/UDPSocket.cpp
+++ b/UDPSocket.cpp
@@ -62,49 +62,46 @@ CUDPSocket::~CUDPSocket()
 #endif
 }

-in_addr CUDPSocket::lookup(const std::string& hostname)
+int CUDPSocket::lookup(const std::string& hostname, unsigned int port, sockaddr_storage &addr, unsigned int &address_length)
 {
-	in_addr addr;
-#if defined(_WIN32) || defined(_WIN64)
-	unsigned long address = ::inet_addr(hostname.c_str());
-	if (address != INADDR_NONE && address != INADDR_ANY) {
-		addr.s_addr = address;
-		return addr;
-	}
+	int err;
+	std::string portstr = std::to_string(port);
+	struct addrinfo hints, *res;

-	struct hostent* hp = ::gethostbyname(hostname.c_str());
-	if (hp != NULL) {
-		::memcpy(&addr, hp->h_addr_list[0], sizeof(struct in_addr));
-		return addr;
-	}
+	::memset(&hints, 0, sizeof(struct addrinfo));
+	hints.ai_flags = AI_NUMERICSERV;

+	err = getaddrinfo(hostname.c_str(), portstr.c_str(), &hints, &res);
+	if (err) {
+		sockaddr_in *paddr = (sockaddr_in *)&addr;
+		::memset(paddr, 0, address_length = sizeof(sockaddr_in));
+		paddr->sin_family = AF_INET;
+		paddr->sin_port = htons(port);
+		paddr->sin_addr.s_addr = htonl(INADDR_NONE);
 		LogError("Cannot find address for host %s", hostname.c_str());
-
-	addr.s_addr = INADDR_NONE;
-	return addr;
-#else
-	in_addr_t address = ::inet_addr(hostname.c_str());
-	if (address != in_addr_t(-1)) {
-		addr.s_addr = address;
-		return addr;
+		return err;
 	}

-	struct hostent* hp = ::gethostbyname(hostname.c_str());
-	if (hp != NULL) {
-		::memcpy(&addr, hp->h_addr_list[0], sizeof(struct in_addr));
-		return addr;
-	}
+	::memcpy(&addr, res->ai_addr, address_length = res->ai_addrlen);

-	LogError("Cannot find address for host %s", hostname.c_str());
-
-	addr.s_addr = INADDR_NONE;
-	return addr;
-#endif
+	freeaddrinfo(res);
+	return 0;
 }

 bool CUDPSocket::open()
 {
-	m_fd = ::socket(PF_INET, SOCK_DGRAM, 0);
+	int err;
+	sockaddr_storage addr;
+	unsigned int addrlen;
+
+	/* to determine protocol family, call lookup() first. */
+	err = lookup(m_address.empty() ? "0.0.0.0" : m_address.c_str(), m_port, addr, addrlen);
+	if (err) {
+		LogError("The local address is invalid - %s", m_address.c_str());
+		return false;
+	}
+
+	m_fd = ::socket(addr.ss_family, SOCK_DGRAM, 0);
 	if (m_fd < 0) {
 #if defined(_WIN32) || defined(_WIN64)
 		LogError("Cannot create the UDP socket, err: %lu", ::GetLastError());
@@ -115,24 +112,6 @@ bool CUDPSocket::open()
 	}

 	if (m_port > 0U) {
-		sockaddr_in addr;
-		::memset(&addr, 0x00, sizeof(sockaddr_in));
-		addr.sin_family      = AF_INET;
-		addr.sin_port        = htons(m_port);
-		addr.sin_addr.s_addr = htonl(INADDR_ANY);
-
-		if (!m_address.empty()) {
-#if defined(_WIN32) || defined(_WIN64)
-			addr.sin_addr.s_addr = ::inet_addr(m_address.c_str());
-#else
-			addr.sin_addr.s_addr = ::inet_addr(m_address.c_str());
-#endif
-			if (addr.sin_addr.s_addr == INADDR_NONE) {
-				LogError("The local address is invalid - %s", m_address.c_str());
-				return false;
-			}
-		}
-
 		int reuse = 1;
 		if (::setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(reuse)) == -1) {
 #if defined(_WIN32) || defined(_WIN64)
@@ -143,7 +122,7 @@ bool CUDPSocket::open()
 			return false;
 		}

-		if (::bind(m_fd, (sockaddr*)&addr, sizeof(sockaddr_in)) == -1) {
+		if (::bind(m_fd, (sockaddr*)&addr, addrlen) == -1) {
 #if defined(_WIN32) || defined(_WIN64)
 			LogError("Cannot bind the UDP address, err: %lu", ::GetLastError());
 #else
@@ -151,12 +130,14 @@ bool CUDPSocket::open()
 #endif
 			return false;
 		}
+
+		LogInfo("Opening UDP port on %u", m_port);
 	}

 	return true;
 }

-int CUDPSocket::read(unsigned char* buffer, unsigned int length, in_addr& address, unsigned int& port)
+int CUDPSocket::read(unsigned char* buffer, unsigned int length, sockaddr_storage& address, unsigned int &address_length)
 {
 	assert(buffer != NULL);
 	assert(length > 0U);
@@ -188,17 +169,16 @@ int CUDPSocket::read(unsigned char* buffer, unsigned int length, in_addr& addres
 	if (ret == 0)
 		return 0;

-	sockaddr_in addr;
 #if defined(_WIN32) || defined(_WIN64)
-	int size = sizeof(sockaddr_in);
+	int size = sizeof(sockaddr_storage);
 #else
-	socklen_t size = sizeof(sockaddr_in);
+	socklen_t size = sizeof(sockaddr_storage);
 #endif

 #if defined(_WIN32) || defined(_WIN64)
-	int len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&addr, &size);
+	int len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&address, &size);
 #else
-	ssize_t len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&addr, &size);
+	ssize_t len = ::recvfrom(m_fd, (char*)buffer, length, 0, (sockaddr *)&address, &size);
 #endif
 	if (len <= 0) {
 #if defined(_WIN32) || defined(_WIN64)
@@ -209,28 +189,19 @@ int CUDPSocket::read(unsigned char* buffer, unsigned int length, in_addr& addres
 		return -1;
 	}

-	address = addr.sin_addr;
-	port    = ntohs(addr.sin_port);
-
+	address_length = size;
 	return len;
 }

-bool CUDPSocket::write(const unsigned char* buffer, unsigned int length, const in_addr& address, unsigned int port)
+bool CUDPSocket::write(const unsigned char* buffer, unsigned int length, const sockaddr_storage& address, unsigned int address_length)
 {
 	assert(buffer != NULL);
 	assert(length > 0U);

-	sockaddr_in addr;
-	::memset(&addr, 0x00, sizeof(sockaddr_in));
-
-	addr.sin_family = AF_INET;
-	addr.sin_addr   = address;
-	addr.sin_port   = htons(port);
-
 #if defined(_WIN32) || defined(_WIN64)
-	int ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&addr, sizeof(sockaddr_in));
+	int ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&address, address_length);
 #else
-	ssize_t ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&addr, sizeof(sockaddr_in));
+	ssize_t ret = ::sendto(m_fd, (char *)buffer, length, 0, (sockaddr *)&address, address_length);
 #endif
 	if (ret < 0) {
 #if defined(_WIN32) || defined(_WIN64)
--- a/UDPSocket.h
+++ b/UDPSocket.h
@@ -31,7 +31,8 @@
 #include <arpa/inet.h>
 #include <errno.h>
 #else
-#include <winsock.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
 #endif

 class CUDPSocket {
@@ -42,12 +43,12 @@ public:

 	bool open();

-	int  read(unsigned char* buffer, unsigned int length, in_addr& address, unsigned int& port);
-	bool write(const unsigned char* buffer, unsigned int length, const in_addr& address, unsigned int port);
+	int  read(unsigned char* buffer, unsigned int length, sockaddr_storage& address, unsigned int &address_length);
+	bool write(const unsigned char* buffer, unsigned int length, const sockaddr_storage& address, unsigned int address_length);

 	void close();

-	static in_addr lookup(const std::string& hostName);
+	static int lookup(const std::string& hostName, unsigned int port, sockaddr_storage &address, unsigned int &address_length);

 private:
 	std::string    m_address;