celisej567/mcpe
1
0
Fork 0
mirror of https://github.com/celisej567/mcpe.git synced 2026-09-17 20:10:23 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

* Initial commit.

Browse Source 
:)
This commit is contained in:
iProgramInCpp
2023-07-30 22:22:02 +03:00
commit 9642818a88
613 changed files with 151754 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
thirdparty/raknet/NatTypeDetectionCommon.cpp vendored Normal file
View File

@@ -0,0 +1,209 @@
/*
* Copyright (c) 2014, Oculus VR, Inc.
* 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
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "NatTypeDetectionCommon.h"
#if _RAKNET_SUPPORT_NatTypeDetectionServer==1 || _RAKNET_SUPPORT_NatTypeDetectionClient==1
#include "SocketLayer.h"
#include "SocketIncludes.h"
#include "SocketDefines.h"
using namespace RakNet;
bool RakNet::CanConnect(NATTypeDetectionResult type1, NATTypeDetectionResult type2)
{
/// If one system is NAT_TYPE_SYMMETRIC, the other must be NAT_TYPE_ADDRESS_RESTRICTED or less
/// If one system is NAT_TYPE_PORT_RESTRICTED, the other must be NAT_TYPE_PORT_RESTRICTED or less
bool connectionGraph[NAT_TYPE_COUNT][NAT_TYPE_COUNT] =
{
// None, Full Cone, Address Restricted, Port Restricted, Symmetric, Unknown, InProgress, Supports_UPNP
{true, true, true, true, true, false, false, true}, // None
{true, true, true, true, true, false, false, true}, // Full Cone
{true, true, true, true, true, false, false, true}, // Address restricted
{true, true, true, true, false, false, false, true}, // Port restricted
{true, true, true, false, false, false, false, true}, // Symmetric
{false, false, false, false, false, false, false, false}, // Unknown
{false, false, false, false, false, false, false, false}, // InProgress
{true, true, true, true, true, false, false, true} // Supports_UPNP
};
return connectionGraph[(int) type1][(int) type2];
}
const char *RakNet::NATTypeDetectionResultToString(NATTypeDetectionResult type)
{
switch (type)
{
case NAT_TYPE_NONE:
return "None";
case NAT_TYPE_FULL_CONE:
return "Full cone";
case NAT_TYPE_ADDRESS_RESTRICTED:
return "Address restricted";
case NAT_TYPE_PORT_RESTRICTED:
return "Port restricted";
case NAT_TYPE_SYMMETRIC:
return "Symmetric";
case NAT_TYPE_UNKNOWN:
return "Unknown";
case NAT_TYPE_DETECTION_IN_PROGRESS:
return "In Progress";
case NAT_TYPE_SUPPORTS_UPNP:
return "Supports UPNP";
case NAT_TYPE_COUNT:
return "NAT_TYPE_COUNT";
}
return "Error, unknown enum in NATTypeDetectionResult";
}
// None and relaxed can connect to anything
// Moderate can connect to moderate or less
// Strict can connect to relaxed or less
const char *RakNet::NATTypeDetectionResultToStringFriendly(NATTypeDetectionResult type)
{
switch (type)
{
case NAT_TYPE_NONE:
return "Open";
case NAT_TYPE_FULL_CONE:
return "Relaxed";
case NAT_TYPE_ADDRESS_RESTRICTED:
return "Relaxed";
case NAT_TYPE_PORT_RESTRICTED:
return "Moderate";
case NAT_TYPE_SYMMETRIC:
return "Strict";
case NAT_TYPE_UNKNOWN:
return "Unknown";
case NAT_TYPE_DETECTION_IN_PROGRESS:
return "In Progress";
case NAT_TYPE_SUPPORTS_UPNP:
return "Supports UPNP";
case NAT_TYPE_COUNT:
return "NAT_TYPE_COUNT";
}
return "Error, unknown enum in NATTypeDetectionResult";
}
RakNetSocket2* RakNet::CreateNonblockingBoundSocket(const char *bindAddr
#ifdef __native_client__
,_PP_Instance_ chromeInstance
#endif
, RNS2EventHandler *eventHandler
)
{
RakNetSocket2 *r2 = RakNetSocket2Allocator::AllocRNS2();
#if defined(__native_client__)
NativeClientBindParameters ncbp;
RNS2_NativeClient * nativeClientSocket = (RNS2_NativeClient*) r2;
ncbp.eventHandler=eventHandler;
ncbp.forceHostAddress=(char*) bindAddr;
ncbp.is_ipv6=false;
ncbp.nativeClientInstance=chromeInstance;
ncbp.port=0;
nativeClientSocket->Bind(&ncbp, _FILE_AND_LINE_);
#elif defined(WINDOWS_STORE_RT)
RakAssert("TODO" && 0);
#else
if (r2->IsBerkleySocket())
{
RNS2_BerkleyBindParameters bbp;
bbp.port=0;
bbp.hostAddress=(char*)bindAddr;
bbp.addressFamily=AF_INET;
bbp.type=SOCK_DGRAM;
bbp.protocol=0;
bbp.nonBlockingSocket=true;
bbp.setBroadcast=true;
bbp.setIPHdrIncl=false;
bbp.doNotFragment=false;
bbp.pollingThreadPriority=0;
bbp.eventHandler=eventHandler;
bbp.remotePortRakNetWasStartedOn_PS3_PS4_PSP2=0;
RNS2BindResult br = ((RNS2_Berkley*) r2)->Bind(&bbp, _FILE_AND_LINE_);
if (br==BR_FAILED_TO_BIND_SOCKET)
{
RakNetSocket2Allocator::DeallocRNS2(r2);
return 0;
}
else if (br==BR_FAILED_SEND_TEST)
{
RakNetSocket2Allocator::DeallocRNS2(r2);
return 0;
}
else
{
RakAssert(br==BR_SUCCESS);
}
((RNS2_Berkley*) r2)->CreateRecvPollingThread(0);
}
else
{
RakAssert("TODO" && 0);
}
#endif
return r2;
/*
#ifdef __native_client__
RakNetSocket2 *s = SocketLayer::CreateBoundSocket( 0, 0, false, bindAddr, true, 0, AF_INET, chromeInstance );
#else
RakNetSocket2 *s = SocketLayer::CreateBoundSocket( 0, 0, false, bindAddr, true, 0, AF_INET, 0 );
#endif
#ifdef _WIN32
unsigned long nonblocking = 1;
s->IOCTLSocket( FIONBIO, &nonblocking );
#elif defined(_PS3) || defined(__PS3__) || defined(SN_TARGET_PS3) || defined(_PS4) || defined(SN_TARGET_PSP2)
int sock_opt=1;
s->SetSockOpt(SOL_SOCKET, SO_NBIO, ( char * ) & sock_opt, sizeof ( sock_opt ) );
#elif defined(__native_client__)
// Nop
#else
s->Fcntl( F_SETFL, O_NONBLOCK );
#endif
return s;
*/
}
/*
int RakNet::NatTypeRecvFrom(char *data, RakNetSocket2* socket, SystemAddress &sender, RNS2EventHandler *eventHandler)
{
#if defined(__native_client__)
RakAssert("TODO" && 0);
#elif defined(WINDOWS_STORE_RT)
RakAssert("TODO" && 0);
#else
if (socket->IsBerkleySocket())
{
RNS2RecvStruct *recvFromStruct;
recvFromStruct=AllocRNS2RecvStruct(_FILE_AND_LINE_);
if (recvFromStruct != NULL)
{
recvFromStruct->socket=this;
socket->RecvFromBlocking(recvFromStruct);
}
if (recvFromStruct->bytesRead>0)
{
sender = recvFromStruct->systemAddress;
}
return recvFromStruct->bytesRead;
}
return 0;
#endif
}
*/
#endif // #if _RAKNET_SUPPORT_NatTypeDetectionServer==1 || _RAKNET_SUPPORT_NatTypeDetectionClient==1