/// <summary>
/// Create a message receiver server which can accept connection from many clients
/// </summary>
/// <param name="port"></param>
/// <param name="protocol"></param>
public MessageReceiver(int port, NetworkProtocolType protocol)
{
if (port <= 0)
{
throw new ArgumentException("port must be > 0");
}
if (protocol != NetworkProtocolType.TCP)
{
throw new NotSupportedException(String.Format("This protocol {0} is currently not supported", protocol));
}
Port = port;
using (Barrier untilStartedListening = new Barrier(2))
{
Listener = new TcpListener(IPAddress.Any, Port);
CancelSource = new CancellationTokenSource();
CancelToken = CancelSource.Token;
ConnectionAcceptor = Task.Factory.StartNew(() => StartAcceptingConnections(untilStartedListening), CancelToken, TaskCreationOptions.LongRunning, TaskScheduler.Default);
if (untilStartedListening.SignalAndWait(5000) == false)
{
throw new InvalidOperationException($"Could not start network receiver on port {Port}. LastStartException: {LastStartException}");
}
}
}
public string GetEndPoint(NetworkProtocolType networkProtocolType, int port, bool isIPv6 = false, bool useHostnames = false)
{
switch (networkProtocolType)
{
default:
throw new NotSupportedException("No Master server endpoint configured for network protocol " + networkProtocolType);
case NetworkProtocolType.Udp:
return(useHostnames ? this.UdpHostname : (isIPv6 ? this.UdpIPv6EndPoint : this.UdpEndPoint));
case NetworkProtocolType.Tcp:
return(useHostnames ? this.TcpHostname : (isIPv6 ? this.TcpIPv6EndPoint : this.TcpEndPoint));
case NetworkProtocolType.WebSocket:
return(isIPv6 ? this.WebSocketIPv6EndPoint : this.WebSocketEndPoint);
case NetworkProtocolType.SecureWebSocket:
return(isIPv6 ? this.SecureWebSocketIPv6EndPoint : this.SecureWebSocketEndPoint);
case NetworkProtocolType.Http:
if (port == 443)
{
return(isIPv6 ? this.SecureHttpIPv6EndPoint : this.SecureHttpEndPoint);
}
return(isIPv6 ? this.HttpIPv6EndPoint : this.HttpEndPoint);
case NetworkProtocolType.WebRTC:
//TODO
// return "192.168.78.204:7071";
return(this.WebRTCEndPoint);
}
}
private static NetworkProtocol CreateNetworkProtocol(NetworkProtocolType protocolType, string ports, bool enabled)
{
return new NetworkProtocol() {
name = protocolType,
port = ports == null ? null : ports.Split(new[] { ';', ' ', ',' }, StringSplitOptions.RemoveEmptyEntries).Select(p => Int32.Parse(p)).ToArray(),
enabled = enabled
};
}
public bool SupportsProtocol(NetworkProtocolType networkProtocol)
{
if (this.gameServerContext == null)
{
return(false);
}
if (this.gameServerContext.SupportedProtocols == null)
{
return(true);
}
return(this.gameServerContext.SupportedProtocols.Contains((byte)networkProtocol));
}
/// <summary>
/// Create a connection to a remove machine to send data to it.
/// </summary>
/// <param name="host">Hostname</param>
/// <param name="port">Port</param>
/// <param name="protocol">Protocol. Currently only TCP is supported</param>
/// <exception cref="ArgumentException">When host is null or empty or the port number is 0 or negative.</exception>
/// <exception cref="NotSupportedException">When another protocol than TCP is used.</exception>
/// <exception cref="SocketException">Server does not exist or it refused the connection because no server is running on that port.</exception>
public MessageSender(string host, int port, NetworkProtocolType protocol)
{
if (String.IsNullOrEmpty(host))
{
throw new ArgumentException("host is null or empty");
}
if (port <= 0)
{
throw new ArgumentException("port must be > 0");
}
if (protocol != NetworkProtocolType.TCP)
{
throw new NotSupportedException(String.Format("This protocol {0} is currently not supported", protocol));
}
Host = host;
Port = port;
Protocol = protocol;
RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, port);
if (protocol == NetworkProtocolType.TCP)
{
const int Retries = 2;
// Try to connect to server with 2 retries and a short sleep in between
for (int i = 0; i < Retries; i++)
{
try
{
Client = new TcpClient(Host, Port);
ConfigureSocket(Client.Client);
this.NetworkSend = Client.GetStream();
break;
}
catch (SocketException)
{
if (i == Retries - 1)
{
throw;
}
Thread.Sleep(10);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
/// </summary>
/// <param name="networkProtocolType">The protocol.</param>
/// <param name="privateIP">The private ip.</param>
/// <param name="privatePort">The private port.</param>
/// <param name="publicPort">The public port.</param>
/// <param name="lifetime">The lifetime.</param>
/// <param name="description">The description.</param>
public Mapping(NetworkProtocolType networkProtocolType, IPAddress privateIP, int privatePort, int publicPort, int lifetime, string description)
{
Guard.IsInRange(privatePort, 0, ushort.MaxValue, "privatePort");
Guard.IsInRange(publicPort, 0, ushort.MaxValue, "publicPort");
Guard.IsInRange(lifetime, 0, int.MaxValue, "lifetime");
Guard.IsTrue(networkProtocolType == NetworkProtocolType.Tcp || networkProtocolType == NetworkProtocolType.Udp, "protocol");
Guard.IsNotNull(privateIP, "privateIP");
NetworkProtocolType = networkProtocolType;
PrivateIP = privateIP;
PrivatePort = privatePort;
PublicIP = IPAddress.None;
PublicPort = publicPort;
Lifetime = lifetime;
Description = description;
}
public override async Task <Mapping> GetSpecificMappingAsync(NetworkProtocolType networkProtocolType, int publicPort)
{
Guard.IsTrue(networkProtocolType == NetworkProtocolType.Tcp || networkProtocolType == NetworkProtocolType.Udp, "protocol");
Guard.IsInRange(publicPort, 0, ushort.MaxValue, "port");
NatDiscoverer.TraceSource.LogInfo("GetSpecificMappingAsync - Getting mapping for protocol: {0} port: {1}", Enum.GetName(typeof(NetworkProtocolType), networkProtocolType), publicPort);
try
{
var message = new GetSpecificPortMappingEntryRequestMessage(networkProtocolType, publicPort);
var responseData = await _soapClient
.InvokeAsync("GetSpecificPortMappingEntry", message.ToXml())
.TimeoutAfter(TimeSpan.FromSeconds(4));
var messageResponse = new GetPortMappingEntryResponseMessage(responseData, DeviceInfo.ServiceType, false);
if (messageResponse.NetworkProtocolType != networkProtocolType)
{
NatDiscoverer.TraceSource.LogWarn("Router responded to a protocol {0} query with a protocol {1} answer, work around applied.", networkProtocolType, messageResponse.NetworkProtocolType);
}
return(new Mapping(networkProtocolType
, IPAddress.Parse(messageResponse.InternalClient)
, messageResponse.InternalPort
, publicPort // messageResponse.ExternalPort is short.MaxValue
, messageResponse.LeaseDuration
, messageResponse.PortMappingDescription));
}
catch (MappingException e)
{
// there are no more mappings
if (e.ErrorCode == UpnpConstants.SpecifiedArrayIndexInvalid ||
e.ErrorCode == UpnpConstants.NoSuchEntryInArray
// DD-WRT Linux base router (and others probably) fails with 402-InvalidArgument when index is out of range
|| e.ErrorCode == UpnpConstants.InvalidArguments
// LINKSYS WRT1900AC AC1900 it returns errocode 501-PAL_UPNP_SOAP_E_ACTION_FAILED
|| e.ErrorCode == UpnpConstants.ActionFailed)
{
NatDiscoverer.TraceSource.LogWarn("Router failed with {0}-{1}. No more mappings is assumed.", e.ErrorCode, e.ErrorText);
return(null);
}
throw;
}
}
/// <summary>
/// 与远程建立连接；
/// 当前只有udp
/// </summary>
/// <param name="ip">ip地址</param>
/// <param name="port">端口号</param>
/// <param name="protocolType">协议类型</param>
public void Connect(ushort port, NetworkProtocolType protocolType = NetworkProtocolType.KCP)
{
OnUnPause();
currentNetworkProtocolType = protocolType;
switch (protocolType)
{
case NetworkProtocolType.KCP:
{
var kcpServer = new KcpServerService();
kcpServerService = kcpServer;
KCPLog.Info = (s) => Utility.Debug.LogInfo(s);
KCPLog.Warning = (s) => Utility.Debug.LogWarning(s);
KCPLog.Error = (s) => Utility.Debug.LogError(s);
kcpServerService.Port = (ushort)port;
kcpServerService.ServiceSetup();
kcpServerService.ServiceUnpause();
kcpServerService.OnServerDataReceived += OnKCPReceiveDataHandler;
kcpServerService.OnServerDisconnected += OnDisconnectedHandler;
kcpServerService.OnServerConnected += OnConnectedHandler;
kcpServerService.ServiceConnect();
}
break;
case NetworkProtocolType.TCP:
{
}
break;
case NetworkProtocolType.UDP:
{
//service = new UdpServerService();
//UdpServerService udp = service as UdpServerService;
//udp.OnReceiveData += OnReceiveDataHandler;
//udp.OnConnected+= OnConnectedHandler;
//udp.OnDisconnected+= OnDisconnectedHandler;
//udp.Port = port;
//service.OnInitialization();
}
break;
}
}
public bool TryGetRegions(GetRegionListRequest regionListRequest, NetworkProtocolType networkProtocol,
int port, bool isIPv6, bool useHostnames,
out List <string> regions, out List <string> endPoints, out string message)
{
regions = new List <string>();
endPoints = new List <string>();
message = string.Empty;
foreach (var server in this.servers)
{
var endpoint = server.GetEndPoint(networkProtocol, port, isIPv6, useHostnames);
if (endpoint == null)
{
continue;
}
regions.Add(server.Region);
endPoints.Add(endpoint);
}
return(true);
}
protected virtual OperationResponse HandleAuthenticateRequest(AuthenticateRequest authenticateRequest,
SendParameters sendParameters, NetworkProtocolType endpointProtocol)
{
if (authenticateRequest.IsValid == false)
{
this.HandleInvalidOperation(authenticateRequest, sendParameters);
return(null);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Got Auth Request:appId={0};version={1};region={2};type={3};userId={4}",
authenticateRequest.ApplicationId,
authenticateRequest.ApplicationVersion,
authenticateRequest.Region,
authenticateRequest.ClientAuthenticationType,
authenticateRequest.UserId);
}
if (!string.IsNullOrEmpty(this.authenticatedApplicationId))
{
if (log.IsDebugEnabled)
{
log.DebugFormat(
"Authenticate called twice: already authenticated with appId={5}. Will handle new AuthRequest: appId={0};version={1};region={2};type={3};userId={4}",
authenticateRequest.ApplicationId,
authenticateRequest.ApplicationVersion,
authenticateRequest.Region,
authenticateRequest.ClientAuthenticationType,
authenticateRequest.UserId,
this.authenticatedApplicationId);
}
}
/////
if (this.Connected == false)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("OnGetApplicationAccount: Client disconnected. Ignore response.");
}
return(null);
}
var operationRequest = authenticateRequest.OperationRequest;
if (log.IsDebugEnabled)
{
log.DebugFormat(
"HandleAuthenticateRequest for App ID {0}",
authenticateRequest.ApplicationId);
}
// store for debugging purposes.
this.authenticatedApplicationId = authenticateRequest.ApplicationId;
// try to get the master server instance for the specified application id
PhotonEndpointInfo masterServer;
string message;
if (!this.application.ServerCache.TryGetPhotonEndpoint(authenticateRequest.Region, out masterServer, out message))
{
if (log.IsWarnEnabled)
{
log.WarnFormat("MasterServer not found for: {0}. AppId: {1}", message, authenticateRequest.ApplicationId);
}
//CHECK why only invalid region err?
this.SendOperationResponse(new OperationResponse(operationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.InvalidRegion,
//DebugMessage =
// string.Format("Cloud {0} / Region {1} is not available.", applicationAccount.PrivateCloud, authenticateRequest.Region)
}, sendParameters);
return(null);
}
//TODO change
string masterEndPoint;
try
{
masterEndPoint = masterServer.GetEndPoint(endpointProtocol, this.LocalPort,
isIPv6: this.LocalIPAddressIsIPv6, useHostnames: this.IsIPv6ToIPv4Bridged);
}
catch (Exception e)
{
//webrtc
masterEndPoint = masterServer.GetEndPoint(endpointProtocol, 0);
var str = string.Format(
"Handle Auth: Exception during GetEndPoint call. EndPoint protocol:{0}, LocalPort:{1}, isIpV6:{2}, useHostNames:{3}",
endpointProtocol, this.LocalPort, this.LocalIPAddressIsIPv6, this.IsIPv6ToIPv4Bridged);
log.Warn(exceptionGuard, str, e);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Endpoint found 1 - Hostname {0}, UDP: {1}, HTTP: {2}", masterServer.UdpHostname, masterServer.UdpEndPoint, masterServer.HttpEndPoint);
}
if (masterEndPoint == null)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("Master server endpoint for protocol {0} not found on master server {1}.", this.NetworkProtocol, masterServer);
}
this.SendOperationResponse(new OperationResponse(operationRequest.OperationCode)
{
ReturnCode = (short)AuthErrorCode.ProtocolNotSupported,
DebugMessage = ErrorMessages.ProtocolNotSupported
}, sendParameters);
return(null);
}
///
// check if custom client authentication is required
if (this.application.CustomAuthHandler.IsClientAuthenticationEnabled)
{
if (this.application.TokenCreator == null)
{
log.WarnFormat("No custom authentication supported: AuthTokenKey not specified in config.");
var resp = new OperationResponse(authenticateRequest.OperationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.InvalidAuthentication,
DebugMessage = ErrorMessages.AuthTokenTypeNotSupported
};
this.SendOperationResponse(resp, sendParameters);
return(null);
}
var authSettings = new AuthSettings
{
IsAnonymousAccessAllowed = this.application.CustomAuthHandler.IsAnonymousAccessAllowed,
};
this.application.CustomAuthHandler.AuthenticateClient(this, authenticateRequest, authSettings, sendParameters, authSettings);
return(null);
}
var response = this.HandleDefaultAuthenticateRequest(authenticateRequest, masterEndPoint, new AuthSettings()); //TODO Check
this.SendOperationResponse(response, sendParameters);
//authenticate application id
return(null);
}
#pragma warning restore 4014
private static async Task ForwardPortInternalAsync(ushort port, int milisecondsDelay, NetworkProtocolType networkProtocolType = NetworkProtocolType.Udp)
{
try
{
if (LastForwardedPort == port || UpnpFailed)
{
return;
}
if (LastForwardedPort != 0)
{
NatDiscoverer.ReleaseAll();
}
NatDiscoverer discoverer = new NatDiscoverer();
NatDevice device;
using (CancellationTokenSource cts = new CancellationTokenSource(milisecondsDelay))
{
device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp | PortMapper.Pmp, cts).ConfigureAwait(false);
}
ExternalIp = await device.GetExternalIPAsync();
await device.CreatePortMapAsync(new Mapping(networkProtocolType, IPAddress.None, port, port, 0, ApplicationName)).ConfigureAwait(false);
LastForwardedPort = port;
Debug.Log($"Port {port.ToString()} forwarded successfully!");
}
catch (Exception ex)
{
//Debug.LogWarning($"UPnP failed!\n{ex.Message}\n{ex.StackTrace}");
UpnpFailed = true;
}
}
public override Task <Mapping> GetSpecificMappingAsync(NetworkProtocolType networkProtocolType, int port)
{
throw new NotSupportedException("NAT-PMP does not specify a way to get a specific port map");
}
private bool isCast(NetworkProtocolType type)
{
if (type == NetworkProtocolType.multicast || type == NetworkProtocolType.unicast || type == NetworkProtocolType.tcpBroadcast)
{
return true;
}
else
{
return false;
}
}
protected override OperationResponse HandleAuthenticateRequest(AuthenticateRequest authenticateRequest,
SendParameters sendParameters, NetworkProtocolType endpointProtocol)
{
if (!authenticateRequest.IsValid)
{
this.HandleInvalidOperation(authenticateRequest, sendParameters);
return(null);
}
if (log.IsDebugEnabled)
{
log.DebugFormat("Got Auth Request:appId={0};version={1};region={2};type={3};userId={4}",
authenticateRequest.ApplicationId,
authenticateRequest.ApplicationVersion,
authenticateRequest.Region,
authenticateRequest.ClientAuthenticationType,
authenticateRequest.UserId);
}
if (!string.IsNullOrEmpty(this.authenticatedApplicationId))
{
if (log.IsDebugEnabled)
{
log.DebugFormat(
"Authenticate called twice: already authenticated with appId={5}. Will handle new AuthRequest: appId={0};version={1};region={2};type={3};userId={4}",
authenticateRequest.ApplicationId,
authenticateRequest.ApplicationVersion,
authenticateRequest.Region,
authenticateRequest.ClientAuthenticationType,
authenticateRequest.UserId,
this.authenticatedApplicationId);
}
}
// checking appId correctness
Guid guid;
if (!Guid.TryParse(authenticateRequest.ApplicationId, out guid))
{
if (log.IsInfoEnabled)
{
var appId = authenticateRequest.ApplicationId ?? string.Empty;
log.InfoFormat("Authentication of client failed: Wrong applicationId, AppId={0}",
appId.Length > 50 ? appId.Substring(0, 50) + "..." : appId);
}
this.SendOperationResponse(new OperationResponse(authenticateRequest.OperationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.InvalidAuthentication,
DebugMessage = ErrorMessages.InvalidAppId
}, sendParameters);
this.ScheduleDisconnect(this.GetDisconnectTime());
return(null);
}
this.InitExecutor(authenticateRequest.ApplicationId, authenticateRequest.ApplicationVersion);
((PhotonCloudApp)this.application).AuthenticationCache.GetAccount(authenticateRequest.ApplicationId, this.RequestFiber,
account => this.OnGetApplicationAccount(account, authenticateRequest, sendParameters, endpointProtocol));
// authenticate application id
return(null);
}
public static void ForwardPort(ushort port, NetworkProtocolType networkProtocolType = NetworkProtocolType.Udp, int milisecondsDelay = 10000)
{
ForwardPortInternalAsync(port, milisecondsDelay, networkProtocolType);
}
public void setNetworkProtocolType(NetworkProtocolType type)
{
int typeNumber = 0; ;
switch (type)
{
case NetworkProtocolType.multicast: typeNumber=19;break;
case NetworkProtocolType.tcp: typeNumber=17;break;
case NetworkProtocolType.unicast: typeNumber=18;break;
case NetworkProtocolType.tcpBroadcast: typeNumber=31;break;
}
Push(PlanckDBConstants.DISTRIBUTION_TYPE, PlanckDBConstants.INTEGER, typeNumber);
}
public bool GetRegionList(GetRegionListRequest request, ApplicationAccount appAccount, NetworkProtocolType networkProtocol, int port, bool isIPv6, bool useHostnames,
out List <string> regions, out List <string> endPoints, out string message)
{
regions = new List <string>();
endPoints = new List <string>();
message = null;
// check submitted ID:
Guid appId;
if (!Guid.TryParse(request.ApplicationId, out appId))
{
message = string.Format("Invalid Application ID format: {0}", request.ApplicationId);
if (log.IsDebugEnabled)
{
log.Debug(message);
return(false);
}
}
if (string.IsNullOrEmpty(appAccount.PrivateCloud))
{
message = string.Format("No private cloud set for applicaton ID {0} - can not get Master", request.ApplicationId);
log.Error(message);
return(false);
}
var privateCloud = appAccount.PrivateCloud;
if (log.IsDebugEnabled)
{
log.DebugFormat("PrivateCloud: {0}", privateCloud);
var infos = appAccount.RegionClusterInfos;
if (infos == null)
{
log.DebugFormat("RegionClusterInfos == null!");
}
else
{
log.DebugFormat("RegionClusterInfos:");
foreach (var info in infos)
{
log.DebugFormat(info.Key);
foreach (var clusterInfo in info.Value)
{
log.DebugFormat("\t{0}", clusterInfo);
}
}
}
}
var allPhotonEndpoints = this.GetAllPhotonEndpoints(privateCloud, appAccount.ServiceType, appAccount);
//tmp for whitelist
var allRegions = new List <string>();
var allEndPoints = new List <string>();
foreach (var server in allPhotonEndpoints)
{
var endpoint = server.GetEndPoint(networkProtocol, port, isIPv6, useHostnames);
if (endpoint == null)
{
continue;
}
string regionCluster = FormatRegionCultureString(server, allPhotonEndpoints);
//use regionwhite list
if (!string.IsNullOrEmpty(appAccount.GetRegionsFilter))
{
//store all in case whitelist leaves no result
allRegions.Add(regionCluster);
allEndPoints.Add(endpoint);
if (!IsRegionClusterWhitelisted(appAccount.GetRegionsFilter, server.Region, server.Cluster))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Whitelist does not contain regionCluster '{0}', skipping", regionCluster);
}
continue;
}
}
regions.Add(regionCluster);
endPoints.Add(endpoint);
if (log.IsDebugEnabled)
{
log.DebugFormat("RegionCluster: {0} -> Endpoint: {1}", regionCluster, endpoint);
}
}
if (!string.IsNullOrEmpty(appAccount.GetRegionsFilter) && regions.Count == 0)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Whitelist left no entries, ignoring whitelist, returning all {0} entries", allRegions.Count);
}
regions.AddRange(allRegions);
endPoints.AddRange(allEndPoints);
}
if (isIPv6 && regions.Count == 0)
{
message = string.Format("No IPv6 capable Master found for applicaton ID {0}", request.ApplicationId);
log.Error(message);
return(false);
}
return(true);
}
private void CreatePortMapListen(UdpClient udpClient, Mapping mapping)
{
IPEndPoint endPoint = new IPEndPoint(LocalAddress, PmpConstants.ServerPort);
while (true)
{
byte[] data = udpClient.Receive(ref endPoint);
if (data.Length < 16)
{
continue;
}
if (data[0] != PmpConstants.Version)
{
continue;
}
byte opCode = (byte)(data[1] & 127);
NetworkProtocolType protocol = NetworkProtocolType.Tcp;
if (opCode == PmpConstants.OperationCodeUdp)
{
protocol = NetworkProtocolType.Udp;
}
short resultCode = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2));
int epoch = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, 4));
short privatePort = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 8));
short publicPort = IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 10));
uint lifetime = (uint)IPAddress.NetworkToHostOrder(BitConverter.ToInt32(data, 12));
if (privatePort < 0 || publicPort < 0 || resultCode != PmpConstants.ResultCodeSuccess)
{
string[] errors = new[]
{
"Success",
"Unsupported Version",
"Not Authorized/Refused (e.g. box supports mapping, but user has turned feature off)"
,
"Network Failure (e.g. NAT box itself has not obtained a DHCP lease)",
"Out of resources (NAT box cannot create any more mappings at this time)",
"Unsupported opcode"
};
throw new MappingException(resultCode, errors[resultCode]);
}
if (lifetime == 0)
{
return; //mapping was deleted
}
//mapping was created
//TODO: verify that the private port+protocol are a match
mapping.PublicPort = publicPort;
mapping.NetworkProtocolType = protocol;
mapping.Expiration = DateTime.Now.AddSeconds(lifetime);
return;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
/// </summary>
/// <param name="networkProtocolType">The protocol.</param>
/// <param name="privatePort">The private port.</param>
/// <param name="publicPort">The public port.</param>
/// <param name="lifetime">The lifetime.</param>
/// <param name="description">The description.</param>
public Mapping(NetworkProtocolType networkProtocolType, int privatePort, int publicPort, int lifetime, string description)
: this(networkProtocolType, IPAddress.None, privatePort, publicPort, lifetime, description)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Mapping"/> class.
/// </summary>
/// <param name="networkProtocolType">The protocol.</param>
/// <param name="privatePort">The private port.</param>
/// <param name="publicPort">The public port.</param>
/// <remarks>
/// This constructor initializes a Permanent mapping. The description by deafult is "Open.NAT"
/// </remarks>
public Mapping(NetworkProtocolType networkProtocolType, int privatePort, int publicPort)
: this(networkProtocolType, IPAddress.None, privatePort, publicPort, 0, "Open.NAT")
{
}
protected virtual bool TryCreateGame(JoinGameRequest operation, NetworkProtocolType expectedProtocol, bool createIfNotExists,
out bool gameCreated, out GameState gameState, out OperationResponse errorResponse, Dictionary <string, object> authCookie)
{
var gameId = operation.GameId;
var properties = operation.GameProperties;
gameState = null;
gameCreated = false;
Func <GameServerContext, bool> filter = ctx =>
{
if (ctx.SupportedProtocols == null)
{
return(true);
}
return(ctx.SupportedProtocols.Contains((byte)expectedProtocol));
};
// try to get a game server instance from the load balancer
GameServerContext gameServerContext;
if (!this.Application.LoadBalancer.TryGetServer(out gameServerContext, filter))
{
errorResponse = new OperationResponse(operation.OperationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.ServerFull,
DebugMessage = LBErrorMessages.FailedToGetServerInstance,
};
return(false);
}
ErrorCode errorCode;
string errorMsg;
// try to create or get game state
if (createIfNotExists)
{
gameCreated = this.Application.GetOrCreateGame(gameId, this, (byte)this.MaxPlayersDefault, gameServerContext, out gameState, out errorCode, out errorMsg);
if (errorCode != ErrorCode.Ok)
{
errorResponse = new OperationResponse(operation.OperationRequest.OperationCode)
{
ReturnCode = (short)errorCode,
DebugMessage = errorMsg,
};
return(false);
}
}
else
{
if (!this.Application.TryCreateGame(gameId, this, (byte)this.MaxPlayersDefault, gameServerContext, out gameState, out errorCode, out errorMsg))
{
errorResponse = new OperationResponse(operation.OperationRequest.OperationCode)
{
ReturnCode = (short)errorCode,
DebugMessage = errorMsg,
};
return(false);
}
gameCreated = true;
}
if (gameCreated)
{
gameState.CreateRequest = operation;
}
if (properties != null)
{
bool changed;
string debugMessage;
if (!gameState.TrySetProperties(properties, out changed, out debugMessage))
{
if (gameCreated)
{
this.Application.RemoveGameByName(gameId);
}
errorResponse = new OperationResponse(operation.OperationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.OperationInvalid,
DebugMessage = debugMessage
};
return(false);
}
}
try
{
this.GameList.AddGameState(gameState, authCookie);
}
catch (Exception)
{
log.ErrorFormat("New game state:{0}", gameState.ToString());
log.ErrorFormat("Request Params for new state:{0}", Newtonsoft.Json.JsonConvert.SerializeObject(operation, serializeSettings));
log.ErrorFormat("CreateIfNotExists: {0}, GameCreated: {1}, Game Properties:{2}",
createIfNotExists, gameCreated, Newtonsoft.Json.JsonConvert.SerializeObject(properties, serializeSettings));
GameState gameInApp;
if (this.Application.TryGetGame(gameId, out gameInApp))
{
log.ErrorFormat("Game state in app:{0}", gameInApp.ToString());
log.ErrorFormat("Request Params for Game in App:{0}",
Newtonsoft.Json.JsonConvert.SerializeObject(gameInApp.CreateRequest, serializeSettings));
}
this.Application.RemoveGameByName(gameState.Id);
gameCreated = false;
GameState gameStateInList;
if (this.GameList.TryGetGame(gameState.Id, out gameStateInList))
{
log.ErrorFormat("Game state in list:{0}", gameStateInList.ToString());
log.ErrorFormat("Request Params for Game in list:{0}",
Newtonsoft.Json.JsonConvert.SerializeObject(gameStateInList.CreateRequest, serializeSettings));
}
else
{
log.ErrorFormat("Game state {0} not found in list", gameState.Id);
}
throw;
}
this.SchedulePublishGameChanges();
errorResponse = null;
return(true);
}
private static NetworkProtocol CreateNetworkProtocol(NetworkProtocolType protocolType, string ports, bool enabled) {
return new NetworkProtocol() {
name = protocolType,
port = ports == null ? null : ports.Split(new[] { ';', ' ', ',' }, StringSplitOptions.RemoveEmptyEntries).Select(p => Int32.Parse(p)).ToArray(),
enabled = enabled
};
}
#pragma warning disable 4014
public static void ForwardPort(NetworkProtocolType networkProtocolType = NetworkProtocolType.Udp, int milisecondsDelay = 10000)
{
ForwardPortInternalAsync(LiteNetLib4MirrorTransport.Singleton.port, milisecondsDelay, networkProtocolType);
}
/// <summary> /// Gets the specified mapping asynchronous. /// </summary> /// <param name="networkProtocolType">The protocol.</param> /// <param name="port">The port.</param> /// <returns> /// The matching mapping /// </returns> public abstract Task <Mapping> GetSpecificMappingAsync(NetworkProtocolType networkProtocolType, int port);
#pragma warning restore 4014
private static async Task ForwardPortInternalAsync(ushort port, int milisecondsDelay, NetworkProtocolType networkProtocolType = NetworkProtocolType.Udp)
{
try
{
if (LastForwardedPort == port || UpnpFailed)
{
return;
}
if (LastForwardedPort != 0)
{
NatDiscoverer.ReleaseAll();
}
NatDiscoverer discoverer = new NatDiscoverer();
NatDevice device;
using (CancellationTokenSource cts = new CancellationTokenSource(milisecondsDelay))
{
device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp | PortMapper.Pmp, cts).ConfigureAwait(false);
}
await device.CreatePortMapAsync(new Mapping(networkProtocolType, port, port, "LiteNetLib4Mirror UPnP")).ConfigureAwait(false);
LastForwardedPort = port;
Debug.Log("Port forwarded successfully!");
}
catch
{
Debug.LogWarning("UPnP failed!");
UpnpFailed = true;
}
}
public GetSpecificPortMappingEntryRequestMessage(NetworkProtocolType networkProtocolType, int externalPort)
{
_networkProtocolType = networkProtocolType;
_externalPort = externalPort;
}
private void OnGetApplicationAccount(ApplicationAccount account, AuthenticateRequest request, SendParameters sendParameters, NetworkProtocolType endpointProtocol)
{
if (!this.Connected)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("OnGetApplicationAccount: Client disconnected. Ignore response.");
}
return;
}
if (!ConnectionRequirementsChecker.Check(this, account.RequireSecureConnection, account.ApplicationId, this.authOnceUsed))
{
log.Warn(secureConnectionLogGuard,
$"Client used non secure connection type when it is required. appId:{account.ApplicationId}, Connection: {this.NetworkProtocol}. AuthOnce {this.authOnceUsed}");
return;
}
if (log.IsDebugEnabled)
{
log.DebugFormat("OnGetApplicationAccount app:{0}, result:{1}, msg:{2}", account.ApplicationId,
account.AccountServiceResult, account.DebugMessage);
}
var operationRequest = request.OperationRequest;
if (!account.IsAuthenticated)
{
if (log.IsInfoEnabled)
{
log.InfoFormat("Authentication of client failed: Msg={0}, AppId={1}", account.DebugMessage, request.ApplicationId);
}
this.SendOperationResponse(new OperationResponse(operationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.InvalidAuthentication,
DebugMessage =
string.IsNullOrEmpty(account.DebugMessage) ? ErrorMessages.InvalidAppId : account.DebugMessage
}, sendParameters);
this.ScheduleDisconnect(this.GetDisconnectTime());
return;
}
if (log.IsDebugEnabled)
{
log.DebugFormat(
"HandleAuthenticateRequest for App ID {0}, Private Cloud {1}, Service Type {2}, Region {3}",
request.ApplicationId,
account.PrivateCloud,
account.ServiceType,
request.Region);
}
// store for debugging purposes.
this.authenticatedApplicationId = request.ApplicationId;
// try to get the master server instance for the specified application id
CloudPhotonEndpointInfo masterServer;
string message;
if (!((PhotonCloudApp)this.application).CloudCache.TryGetPhotonEndpoint(request, account, out masterServer, out message))
{
if (string.Equals(request.Region, "none", StringComparison.CurrentCultureIgnoreCase))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("MasterServer not found for region '{0}' on cloud '{1}' / service type '{2}': '{3}'. AppId: {4}/{5}",
request.Region, account.PrivateCloud, account.ServiceType, message,
request.ApplicationId, request.ApplicationVersion);
}
}
else
{
if (log.IsWarnEnabled)
{
log.WarnFormat(masterNotFoundGuard, "MasterServer not found for region '{0}' on cloud '{1}' / service type '{2}': '{3}'. AppId: {4}/{5}",
request.Region, account.PrivateCloud, account.ServiceType, message,
request.ApplicationId, request.ApplicationVersion);
}
}
this.SendOperationResponse(new OperationResponse(operationRequest.OperationCode)
{
ReturnCode = (short)ErrorCode.InvalidRegion,
DebugMessage = string.Format("Cloud {0} / Region {1} is not available.", account.PrivateCloud, request.Region)
}, sendParameters);
this.ScheduleDisconnect(this.GetDisconnectTime());
return;
}
var masterEndPoint = masterServer.GetEndPoint(endpointProtocol, this.LocalPort,
isIPv6: this.LocalIPAddressIsIPv6, useHostnames: this.IsIPv6ToIPv4Bridged);
if (masterEndPoint == null)
{
if (log.IsWarnEnabled)
{
log.WarnFormat(masterNotFoundForProtocolGuard,
"Master server endpoint for protocol {0} not found on master server {1}. appId:{2}",
this.NetworkProtocol, masterServer, account.ApplicationId);
}
this.SendOperationResponse(new OperationResponse(operationRequest.OperationCode)
{
ReturnCode = (short)AuthErrorCode.ProtocolNotSupported,
DebugMessage = ErrorMessages.ProtocolNotSupported
}, sendParameters);
this.ScheduleDisconnect(this.GetDisconnectTime());
return;
}
// check for custom authentication
if (account.IsClientAuthenticationEnabled)
{
var customAuthHandler = this.GetCustomAuthHandler(account);
customAuthHandler.AuthenticateClient(this, request, account, sendParameters, account);
return; // custom authentication is handled async
}
var response = this.HandleDefaultAuthenticateRequest(request, account, masterEndPoint, masterServer);
this.SendOperationResponse(response, sendParameters);
this.ScheduleDisconnect(this.MaxDisconnectTime);
}
private static Tuple<bool, string> GetProtocolPorts(NetworkProtocol[] protocols, NetworkProtocolType protocolType)
{
if (protocols == null) {
return Tuple.Create(false, "");
}
var enabled = false;
var ports = new List<int>();
foreach (var protocol in protocols.Where(p => p != null && p.name == protocolType)) {
if (protocol.enabled && !enabled) {
enabled = true;
ports.Clear();
}
if (protocol.port != null) {
ports.AddRange(protocol.port);
}
}
return Tuple.Create(enabled, String.Join("; ", ports.Select(p => p.ToString())));
}
private static Tuple<bool, string> GetProtocolPorts(NetworkProtocol[] protocols, NetworkProtocolType protocolType) {
if (protocols == null) {
return Tuple.Create(false, "");
}
var enabled = false;
var ports = new List<int>();
foreach (var protocol in protocols.Where(p => p != null && p.name == protocolType)) {
if (protocol.enabled && !enabled) {
enabled = true;
ports.Clear();
}
if (protocol.port != null) {
ports.AddRange(protocol.port);
}
}
return Tuple.Create(enabled, String.Join("; ", ports.Select(p => p.ToString())));
}
internal Mapping(NetworkProtocolType networkProtocolType, IPAddress privateIP, int privatePort, int publicPort)
: this(networkProtocolType, privateIP, privatePort, publicPort, 0, "LiteNetLib4Mirror.Open.Nat")
{
}
