mirrors/mcpe
1
0
Fork 0
mirror of https://github.com/ReMinecraftPE/mcpe.git synced 2025-01-22 09:11:56 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

* Revert RakNetSocket2 implementation.

Browse source 
It breaks Windows XP compatibility by depending on inet_ntop. Please fix!
This commit is contained in:
iProgramInCpp 2024-01-22 19:02:38 +02:00
parent 047fd3120f
commit b24a230058
3 changed files with 79 additions and 202 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
thirdparty/raknet/RakNetSocket2.cpp vendored
View file

@ -74,7 +74,7 @@ RakNetSocket2* RakNetSocket2Allocator::AllocRNS2(void)
s2 = RakNet::OP_NEW<RNS2_WindowsStore8>(_FILE_AND_LINE_);
s2->SetSocketType(RNS2T_WINDOWS_STORE_8);

100
thirdparty/raknet/RakNetSocket2_Berkley_NativeClient.cpp vendored
View file

@ -1,16 +1,11 @@
/*
* Original work: Copyright (c) 2014, Oculus VR, Inc.
* Copyright (c) 2014, Oculus VR, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* RakNet License.txt file in the licenses directory of this source tree. An additional grant
* of patent rights can be found in the RakNet Patents.txt file in the same directory.
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*
* Modified work: Copyright (c) 2016-2020, SLikeSoft UG (haftungsbeschränkt)
*
* This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
* license found in the license.txt file in the root directory of this source tree.
*/
#include "EmptyHeader.h"
@ -20,102 +15,87 @@
#ifndef RAKNETSOCKET2_BERKLEY_NATIVE_CLIENT_CPP
#define RAKNETSOCKET2_BERKLEY_NATIVE_CLIENT_CPP
// Every platform except windows store 8 and native client supports Berkley sockets
// Every platform except windows store 8 and native client supports Berkley sockets
#if !defined(WINDOWS_STORE_RT)
#include "Itoa.h"
#include "WSAStartupSingleton.h" // used for WSAStartupSingleton
#if (defined(__GNUC__) || defined(__GCCXML__)) && !defined(__WIN32__)
#include <netdb.h>
#endif
// Shared on most platforms, but excluded from the listed
// #low - maybe change to char (&ip)[65] - then we can also use sizeof again
void DomainNameToIP_Berkley_IPV4And6( const char *domainName, char ip[65] )
void DomainNameToIP_Berkley_IPV4And6(const char* domainName, char ip[65])
{
#if RAKNET_SUPPORT_IPV6==1
struct addrinfo hints, *res, *p;
struct addrinfo hints, * res, * p;
int status;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC; // AF_INET or AF_INET6 to force version
hints.ai_socktype = SOCK_DGRAM;
if ((status = getaddrinfo(domainName, nullptr, &hints, &res)) != 0) {
// #high - review/update callers - some unnecessarily initialize ip unnecessarily
ip[0] = '\0';
if ((status = getaddrinfo(domainName, NULL, &hints, &res)) != 0) {
memset(ip, 0, sizeof(ip));
return;
}
p=res;
// for(p = res;p != nullptr; p = p->ai_next) {
void *addr;
p = res;
// for(p = res;p != NULL; p = p->ai_next) {
void* addr;
// char *ipver;
// get the pointer to the address itself,
// different fields in IPv4 and IPv6:
// get the pointer to the address itself,
// different fields in IPv4 and IPv6:
if (p->ai_family == AF_INET)
{
struct sockaddr_in *ipv4 = (struct sockaddr_in *)p->ai_addr;
struct sockaddr_in* ipv4 = (struct sockaddr_in*)p->ai_addr;
addr = &(ipv4->sin_addr);
inet_ntop(AF_INET, &ipv4->sin_addr, ip, 65);
strcpy(ip, inet_ntoa(ipv4->sin_addr));
}
else
{
// TODO - test
struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)p->ai_addr;
struct sockaddr_in6* ipv6 = (struct sockaddr_in6*)p->ai_addr;
addr = &(ipv6->sin6_addr);
// inet_ntop function does not exist on windows
// http://www.mail-archive.com/users@ipv6.org/msg02107.html
getnameinfo((struct sockaddr *)ipv6, sizeof(struct sockaddr_in6), ip, sizeof(ip), nullptr, 0, NI_NUMERICHOST);
getnameinfo((struct sockaddr*)ipv6, sizeof(struct sockaddr_in6), ip, 1, NULL, 0, NI_NUMERICHOST);
}
freeaddrinfo(res); // free the linked list
// }
#else
(void) domainName;
(void) ip;
(void)domainName;
(void)ip;
#endif // #if RAKNET_SUPPORT_IPV6==1
}
void DomainNameToIP_Berkley_IPV4( const char *domainName, char ip[65] )
void DomainNameToIP_Berkley_IPV4(const char* domainName, char ip[65])
{
static struct in_addr addr;
memset(&addr, 0, sizeof(in_addr));
// Use inet_addr instead? What is the difference?
struct addrinfo *addressinfo = nullptr;
// needed for getaddrinfo
WSAStartupSingleton::AddRef();
int error = getaddrinfo(domainName, nullptr, nullptr, &addressinfo);
WSAStartupSingleton::Deref();
if ( error != 0 || addressinfo == 0 )
struct hostent* phe = gethostbyname(domainName);
if (phe == 0 || phe->h_addr_list[0] == 0)
{
//cerr << "Yow! Bad host lookup." << endl;
// #high - review/update callers - some unnecessarily initialize ip unnecessarily
ip[0] = '\0';
memset(ip, 0, 65 * sizeof(char));
return;
}
// get the (first) IPv4 address
while (addressinfo != nullptr) {
if (addressinfo->ai_family == AF_INET) {
break; // found an IPv4 address
}
addressinfo = addressinfo->ai_next;
}
if (addressinfo == nullptr) {
if (phe->h_addr_list[0] == 0)
{
memset(ip, 0, 65 * sizeof(char));
return;
}
struct sockaddr_in *sockaddr_ipv4 = (struct sockaddr_in *) addressinfo->ai_addr;
inet_ntop(AF_INET, &sockaddr_ipv4->sin_addr, ip, 65);
memcpy(&addr, phe->h_addr_list[0], sizeof(struct in_addr));
strcpy(ip, inet_ntoa(addr));
}
void DomainNameToIP_Berkley( const char *domainName, char ip[65] )
void DomainNameToIP_Berkley(const char* domainName, char ip[65])
{
#if RAKNET_SUPPORT_IPV6==1
return DomainNameToIP_Berkley_IPV4And6(domainName, ip);
@ -131,4 +111,4 @@ void DomainNameToIP_Berkley( const char *domainName, char ip[65] )
#endif // file header
#endif // #ifdef RAKNET_SOCKET_2_INLINE_FUNCTIONS
#endif // #ifdef RAKNET_SOCKET_2_INLINE_FUNCTIONS

179
thirdparty/raknet/RakNetSocket2_Windows_Linux.cpp vendored
View file

@ -3,13 +3,12 @@
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "EmptyHeader.h"
#include "../../compat/PlatformDefinitions.h"
#ifdef RAKNET_SOCKET_2_INLINE_FUNCTIONS
@ -18,138 +17,47 @@
#if !defined(WINDOWS_STORE_RT) && !defined(__native_client__)
#if MC_TARGET_OS_IOS
// Lifed from SLikeNet because *just* iOS 6 was bitching and moaning 25% of the time
// iOS 6 SDK makes phones hate this for some reason
// gethostbyname didn't return NULL on iPhone 5 running iOS 6.1.4 on iOS 5 SDK,
// but did return NULL when running on the same hardware on iOS 6.1 SDK
#ifndef _WIN32
#include <sys/types.h> // used for getifaddrs()
#include <ifaddrs.h> // used for getifaddrs()
#endif // _WIN32
#include <string> // used for std::string
// based on https://stackoverflow.com/questions/212528/get-the-ip-address-of-the-machine#265978
void GetMyIP_Linux(SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS], const bool includeIPv6)
{
struct ifaddrs* pAddresses = nullptr;
// #med - add error check to getifaddrs()-call
getifaddrs(&pAddresses);
struct ifaddrs* pCurAdapter = pAddresses;
size_t outAddressIndex = 0;
while ((pCurAdapter != nullptr) && (outAddressIndex < MAXIMUM_NUMBER_OF_INTERNAL_IDS)) {
// skip interfaces which don't have any address assigned (according to the manual, this would only apply for BSD, but still we'd check for null here just in case)
if (pCurAdapter->ifa_addr != nullptr) {
// skip loopback adapters
if ((pCurAdapter->ifa_flags & IFF_LOOPBACK) == 0) {
if (pCurAdapter->ifa_addr->sa_family == AF_INET) {
const sockaddr_in* const curSocketAddress = reinterpret_cast<const sockaddr_in*>(pCurAdapter->ifa_addr);
char buffer[INET_ADDRSTRLEN] = { 0 };
// #med - add return value check
inet_ntop(AF_INET, &(curSocketAddress->sin_addr), buffer, INET_ADDRSTRLEN);
const std::string ipv4String(buffer);
// #med - review, is this really necessary?
// skip source only addresses (aka: 0.0.0.0/8 - see RFC1700 p.4)
if (ipv4String.find("0.") != 0) {
// store the adapter's address
addresses[outAddressIndex++].address.addr4 = *curSocketAddress;
}
}
#if RAKNET_SUPPORT_IPV6 == 1
else if (includeIPv6 && pCurAdapter->ifa_addr->sa_family == AF_INET6) {
const sockaddr_in6* const curSocketAddress = reinterpret_cast<const sockaddr_in6*>(pCurAdapter->ifa_addr);
char buffer[INET6_ADDRSTRLEN] = { 0 };
// #med - add return value check
inet_ntop(AF_INET6, &(curSocketAddress->sin6_addr), buffer, INET6_ADDRSTRLEN);
const std::string ipv6String(buffer);
// detect and skip non-external addresses
bool isLocal = false;
bool isSpecial = false;
if (ipv6String.find("fe") == 0) {
const char c = ipv6String[2];
if (c == '8' || c == '9' || c == 'a' || c == 'b') {
isLocal = true;
}
}
else if (ipv6String.find("2001:0:") == 0) {
isSpecial = true;
}
if (!(isLocal || isSpecial)) {
// store the adapter's address
addresses[outAddressIndex++].address.addr6 = *curSocketAddress;
}
}
#endif // RAKNET_SUPPORT_IPV6 == 1
// else skip the address (neither IPv4 nor IPv6 address)
}
}
pCurAdapter = pCurAdapter->ifa_next;
}
if (pAddresses != nullptr)
freeifaddrs(pAddresses);
while (outAddressIndex < MAXIMUM_NUMBER_OF_INTERNAL_IDS) {
addresses[outAddressIndex++] = UNASSIGNED_SYSTEM_ADDRESS;
}
}
#else // !MC_TARGET_OS_IOS
#if RAKNET_SUPPORT_IPV6==1
void PrepareAddrInfoHints2(addrinfo *hints)
void PrepareAddrInfoHints2(addrinfo* hints)
{
memset(hints, 0, sizeof (addrinfo)); // make sure the struct is empty
memset(hints, 0, sizeof(addrinfo)); // make sure the struct is empty
hints->ai_socktype = SOCK_DGRAM; // UDP sockets
hints->ai_flags = AI_PASSIVE; // fill in my IP for me
}
void GetMyIP_Windows_Linux_IPV4And6( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS] )
void GetMyIP_Windows_Linux_IPV4And6(SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS])
{
int idx=0;
char ac[ 80 ];
int err = gethostname( ac, sizeof( ac ) );
int idx = 0;
char ac[80];
int err = gethostname(ac, sizeof(ac));
RakAssert(err != -1);
struct addrinfo hints;
struct addrinfo *servinfo=0, *aip; // will point to the results
struct addrinfo* servinfo = 0, * aip; // will point to the results
PrepareAddrInfoHints2(&hints);
getaddrinfo(ac, "", &hints, &servinfo);
for (idx=0, aip = servinfo; aip != NULL && idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS; aip = aip->ai_next, idx++)
for (idx = 0, aip = servinfo; aip != NULL && idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS; aip = aip->ai_next, idx++)
{
if (aip->ai_family == AF_INET)
{
struct sockaddr_in *ipv4 = (struct sockaddr_in *)aip->ai_addr;
memcpy(&addresses[idx].address.addr4,ipv4,sizeof(sockaddr_in));
struct sockaddr_in* ipv4 = (struct sockaddr_in*)aip->ai_addr;
memcpy(&addresses[idx].address.addr4, ipv4, sizeof(sockaddr_in));
}
else
{
struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)aip->ai_addr;
memcpy(&addresses[idx].address.addr4,ipv6,sizeof(sockaddr_in6));
struct sockaddr_in6* ipv6 = (struct sockaddr_in6*)aip->ai_addr;
memcpy(&addresses[idx].address.addr4, ipv6, sizeof(sockaddr_in6));
}
}
freeaddrinfo(servinfo); // free the linked-list
while (idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS)
{
addresses[idx]=UNASSIGNED_SYSTEM_ADDRESS;
addresses[idx] = UNASSIGNED_SYSTEM_ADDRESS;
idx++;
}
}
@ -159,36 +67,35 @@ void GetMyIP_Windows_Linux_IPV4And6( SystemAddress addresses[MAXIMUM_NUMBER_OF_I
#if (defined(__GNUC__) || defined(__GCCXML__)) && !defined(__WIN32__)
#include <netdb.h>
#endif
void GetMyIP_Windows_Linux_IPV4( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS] )
void GetMyIP_Windows_Linux_IPV4(SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS])
{
int idx=0;
char ac[ 80 ];
int err = gethostname( ac, sizeof( ac ) );
(void) err;
int idx = 0;
char ac[80];
int err = gethostname(ac, sizeof(ac));
(void)err;
RakAssert(err != -1);
struct hostent *phe = gethostbyname( ac );
if ( phe == 0 )
struct hostent* phe = gethostbyname(ac);
if (phe == 0)
{
printf("gethostbyname hostname: %s, errno: %d\n", ac, h_errno);
RakAssert(phe!=0);
return ;
RakAssert(phe != 0);
return;
}
for ( idx = 0; idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS; ++idx )
for (idx = 0; idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS; ++idx)
{
if (phe->h_addr_list[ idx ] == 0)
if (phe->h_addr_list[idx] == 0)
break;
memcpy(&addresses[idx].address.addr4.sin_addr,phe->h_addr_list[ idx ],sizeof(struct in_addr));
memcpy(&addresses[idx].address.addr4.sin_addr, phe->h_addr_list[idx], sizeof(struct in_addr));
}
while (idx < MAXIMUM_NUMBER_OF_INTERNAL_IDS)
{
addresses[idx]=UNASSIGNED_SYSTEM_ADDRESS;
addresses[idx] = UNASSIGNED_SYSTEM_ADDRESS;
idx++;
}
@ -196,24 +103,14 @@ void GetMyIP_Windows_Linux_IPV4( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTER
#endif // RAKNET_SUPPORT_IPV6==1
#endif // MC_TARGET_OS_IOS
void GetMyIP_Windows_Linux( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS] )
void GetMyIP_Windows_Linux(SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS])
{
#if RAKNET_SUPPORT_IPV6==1
#if MC_TARGET_OS_IOS
GetMyIP_Linux(addresses, true);
#else
GetMyIP_Windows_Linux_IPV4And6(addresses);
#endif
#else
#if MC_TARGET_OS_IOS
GetMyIP_Linux(addresses, false);
#else
GetMyIP_Windows_Linux_IPV4(addresses);
#endif
#endif
#if RAKNET_SUPPORT_IPV6==1
GetMyIP_Windows_Linux_IPV4And6(addresses);
#else
GetMyIP_Windows_Linux_IPV4(addresses);
#endif
}
@ -221,4 +118,4 @@ void GetMyIP_Windows_Linux( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_I
#endif // file header
#endif // #ifdef RAKNET_SOCKET_2_INLINE_FUNCTIONS
#endif // #ifdef RAKNET_SOCKET_2_INLINE_FUNCTIONS