/// <summary>
/// 收到玩家加入房间的请求，玩家能否加入房间取决于客户端逻辑（比如房间是否已满）
/// </summary>
/// <param name="request"></param>
/// <param name="player"></param>
void reqJoinRoom(ConnectionRequest request, RoomPlayerData player)
{
log?.logTrace(request.RemoteEndPoint + $"({player.id}) 请求加入房间。");
RoomData roomData = null;
try
{
roomData = onJoinRoomReq?.Invoke(player);
}
catch (Exception e)
{
log?.log(request.RemoteEndPoint + "加入房间的请求被拒绝，原因：" + e);
request.Reject(createRPCResponseWriter(PacketType.joinResponse, e));
return;
}
//接受了加入请求，回复请求并广播房间更新信息。
NetPeer peer = request.Accept();
_playerInfoDict[player.id] = new LANPlayerInfo()
{
ip = request.RemoteEndPoint,
peer = peer
};
// invokeBroadcast(nameof(ntfRoomAddPlayer), roomData.ID, player);
// invokeBroadcast(nameof(ntfUpdateRoom), roomData);
}
private static void Postfix(CustomLiteNetLib4MirrorTransport __instance, ConnectionRequest request)
{
var allow = true;
var reason = "No Reason";
if (!request.Data.EndOfData)
{
return;
}
var userId = CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].UserId;
SynapseController.Server.Events.Server.InvokePreAuthenticationEvent(userId, ref allow, ref reason, request);
if (allow)
{
request.Accept();
return;
}
var data = new NetDataWriter();
data.Put((byte)10);
data.Put(reason);
request.RejectForce(data);
}
private void OnConnectionRequested(ConnectionRequest request)
{
if (_networker.PeersCount < MaxPlayers)
{
string pin = request.Data.GetString();
if (pin == Pin)
{
NetPeer peer = request.Accept();
string userName = request.Data.GetString();
peer.Tag = userName;
Players.Add(peer);
Log.Information("Connection request from {endPoint} with username {userName} accepted", request.RemoteEndPoint, userName);
}
else
{
request.Reject(NetConstants.GetKeyValue(NetKey.DisconnectInvalidPin));
Log.Information("Connection request from {endPoint} rejected due to invalid key", request.RemoteEndPoint);
}
}
else
{
request.Reject(NetConstants.GetKeyValue(NetKey.DisconnectServerFull));
Log.Information("Connection request from {endPoint} rejected as server full", request.RemoteEndPoint);
}
}
public void OnConnectionRequest(ConnectionRequest request)
{
if (NumClientsConnected >= NumMaxClients)
{
request.Reject();
return;
}
var reader = request.Data;
var span = new ReadOnlySpan <byte>(reader.RawData, reader.UserDataOffset, reader.UserDataSize);
var bs = new BitReader(span, memory);
var approvalResult = ApproveConnection.Invoke(bs);
if (!approvalResult.Approved)
{
Debug.Log($"[Server] Connection denied ({approvalResult.DenialReason})");
var deniedBs = new BitWriter();
deniedBs.WriteString(approvalResult.DenialReason);
request.Reject(deniedBs.DataWritten.ToArray(), 0, deniedBs.BytesWritten);
return;
}
Debug.Log("[Server] Connection approved");
request.Accept();
}
public void OnConnectionRequest(ConnectionRequest request)
{
request.Accept().name = request.Data.GetString();
Console.WriteLine(
"[Server] ConnectionRequest. Ep: {0}, Accepted: {1}",
request.RemoteEndPoint,
true);
}
public void OnConnectionRequest(ConnectionRequest request)
{
var key = System.Text.Encoding.UTF8.GetBytes("gamekey");
var acceptedPeer = request.Data.SequenceEqual(key) ? request.Accept() : null;
Console.WriteLine("[Server] ConnectionRequest. Ep: {0}, Accepted: {1}",
request.RemoteEndPoint,
acceptedPeer != null);
}
public void OnConnectionRequest(ConnectionRequest request)
{
var key = System.Text.Encoding.UTF8.GetBytes("key");
if (request.Data.SequenceEqual(key))
{
request.Accept();
}
}
private void TryAccept(ConnectionRequest request, string userId, string userName, bool isConnectionOwner)
{
if (this.isRelay && !this.hasConnectionOwner && !isConnectionOwner)
{
this._pendingRequests.Add(new LiteNetLibConnectionManager.NetPeerConnectionRequest(request, userId, userName, isConnectionOwner));
return;
}
this.CreatePendingConnection(request.Accept(), userId, userName, isConnectionOwner);
}
public bool InitServer(ConnectionRequest request, string receivedToken, List <string> addons)
{
ServerDirectory = Path.Combine("servers", $"{ServerAddress}_{ServerPort}");
LoadServerConfig();
UpdateName();
if (ServerConfig.InstalledAddons == null)
{
ServerConfig.InstalledAddons = new List <string>();
}
foreach (var addon in addons)
{
if (!ServerConfig.InstalledAddons.Contains(addon))
{
ServerConfig.InstalledAddons.Add(addon);
}
}
if (string.IsNullOrEmpty(ServerConfig.Token))
{
Peer = request.Accept();
PacketProcessor.Send <SendTokenPacket>(Peer,
new SendTokenPacket()
{
Token = GenNewToken()
}, DeliveryMethod.ReliableOrdered);
return(true);
}
if (receivedToken != ServerConfig.Token)
{
NPManager.Singleton.Logger.Error($"Received invalid token from server {FullAddress}.");
NetDataWriter writer = new NetDataWriter();
writer.Put((byte)RejectType.InvalidToken);
request.Reject(writer);
return(false);
}
Peer = request.Accept();
return(true);
}
public void OnConnectionRequest(ConnectionRequest req)
{
if (!arbiter && server.settings.maxPlayers > 0 && server.players.Count(p => !p.IsArbiter) >= server.settings.maxPlayers)
{
req.Reject(IConnection.GetDisconnectBytes(MpDisconnectReason.ServerFull));
return;
}
req.Accept();
}
void ConnectionRequestEvent(ConnectionRequest request)
{
if (connections.Count < GameConfig.maxClients)
{
request.Accept();
}
else
{
request.Reject();
}
}
private void OnConnectionRequest(ConnectionRequest request)
{
if (netManager.ConnectedPeerList.Count > config.Clients)
{
Console.WriteLine("Too many clients try to connect to the server");
request.Reject();
return;
}
request.Accept();
}
public void OnConnectionRequest(ConnectionRequest req)
{
if (!arbiter && server.settings.maxPlayers > 0 && server.players.Count(p => !p.IsArbiter) >= server.settings.maxPlayers)
{
var writer = new ByteWriter();
writer.WriteString("Server is full");
req.Reject(writer.GetArray());
return;
}
req.Accept();
}
public void OnConnectionRequest(ConnectionRequest request)
{
if (server.ConnectedPeersCount < MAX_CONNECTED_PEERS)
{
Debug.Log($"Incoming connection from {request.RemoteEndPoint.ToString()}");
request.Accept();
}
else
{
Debug.Log("Connection refused. Too many connections.");
}
}
public void OnConnectionRequest(ConnectionRequest req)
{
var result = server.playerManager.OnPreConnect(req.RemoteEndPoint.Address);
if (result != null)
{
req.Reject(ConnectionBase.GetDisconnectBytes(result.Value));
return;
}
req.Accept();
}
private static void Postfix(ConnectionRequest request)
{
try
{
var allow = true;
var reason = "No Reason";
if (!request.Data.EndOfData)
{
return;
}
var userId = "";
if (CustomLiteNetLib4MirrorTransport.UserIds.ContainsKey(request.RemoteEndPoint))
{
userId = CustomLiteNetLib4MirrorTransport.UserIds[request.RemoteEndPoint].UserId;
}
SynapseController.Server.Events.Server.InvokePreAuthenticationEvent(userId, ref allow, ref reason, request);
if (allow)
{
request.Accept();
return;
}
var data = new NetDataWriter();
data.Put((byte)10);
data.Put(reason);
request.RejectForce(data);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: PreAuthenticationFailed failed!!\n{e}");
//Just casually accept if Synapse messes up here.
request.Accept();
}
}
public void OnConnectionRequest(ConnectionRequest request)
{
var host = transport.GetHost(hostId, specialConnectionId);
if (host.PeersCount < maxConnections)
{
request.Accept();
}
else
{
request.Reject();
}
}
public void OnConnectionRequest(ConnectionRequest request)
{
//Forwarding event to app, let them decide to accept or not client
if (!appListener.OnConnectionRequest(request))
{
request.Reject();
return;
}
NetPeer peer = request.Accept();
players.Add(peer.Id, new ServerPlayer(peer));
}
protected internal virtual void ProcessConnectionRequest(ConnectionRequest request)
{
/* if (LiteNetLib4MirrorCore.Host.PeersCount >= maxConnections)
* {
* request.Reject();
* }
* else if (request.AcceptIfKey(LiteNetLib4MirrorServer.Code) == null)
* {
* Debug.LogWarning("Client tried to join with an invalid auth code! Current code:" + LiteNetLib4MirrorServer.Code);
* } */
request.Accept();
}
public void OnConnectionRequest(ConnectionRequest request)
{
if (!m_Server.CanPlayerJoin())
{
Logger.Info(
"Connection request from {request} rejected: server is full.",
request.ToFriendlyString());
request.Reject(new[] { Convert.ToByte(EDisconnectReason.ServerIsFull) });
return;
}
Logger.Info("Connection request from {request}.", request.ToFriendlyString());
request.Accept();
}
private void HandleConnectionRequest(ConnectionRequest request)
{
// Always accept local connections.
var addr = request.RemoteEndPoint.Address;
if (addr.Equals(IPAddress.IPv6Loopback) || addr.Equals(IPAddress.Loopback))
{
request.Accept();
return;
}
if (Host !.AcceptClients)
{
request.AcceptIfKey(Host.Password);
}
//============ INetEventListener methods ============//
/// <summary>
/// On peer connection requested
/// </summary>
/// <param name="request">Request information (EndPoint, internal id, additional data)</param>
public virtual void OnConnectionRequest(ConnectionRequest request)
{
NetDataReader dataReader = request.Data;
string key = dataReader.GetString();
if (key != TinyNetGameManager.instance.multiplayerConnectKey)
{
request.Reject();
}
NetPeer peer = request.Accept();
peer.Tag = dataReader.GetString();
}
public void OnConnectionRequest(ConnectionRequest request)
{
var dataReader = request.Data;
string key = dataReader.GetString();
if (key != "hashcode")
{
request.Reject();
}
var peer = request.Accept();
int hashcode = dataReader.GetInt();
string name = dataReader.GetString();
peer.Tag = hashcode;
Debug.Log("RECEIVED CONNECTINO REQUEST");
}
public void OnConnectionRequest(ConnectionRequest rq)
{
try
{
string name = rq.Data.GetString(rq.Data.GetInt());
Guid uid = new Guid(rq.Data.GetRemainingBytes());
//TODO Check validaty
NetPeer peer = rq.Accept();
players.Add(peer.Id, new NetPlayer(peer, name, uid));
} catch (Exception e)
{
rq.Reject(Packets.CreateProtocolError("Invalid connection request."));
}
}
public override void OnConnectionRequest(ConnectionRequest request)
{
base.OnConnectionRequest(request);
NetDataReader dataReader = request.Data;
string key = dataReader.GetString();
if (!TinyNetGameManager.instance.CheckConnectionKey(key))
{
request.Reject();
}
NetPeer peer = request.Accept();
peer.Tag = dataReader.GetString();
}
public void OnConnectionRequest(H3Server server, ConnectionRequest request, NetDataWriter rejectionContent)
{
var currentClients = server.ClientsCount;
var maxClients = server._config.PlayerLimit.Value;
if (currentClients >= maxClients)
{
server._log.LogWarning($"Rejecting join request from {request.RemoteEndPoint} because of full party ({currentClients} / {maxClients}).");
rejectionContent.Put(JoinError.Full);
request.Reject(rejectionContent);
return;
}
var reader = request.Data;
if (!reader.TryGet <ConnectionRequestMessage>(out var message))
{
server._log.LogWarning($"Join request from {request.RemoteEndPoint} had a malformed request.");
rejectionContent.Put(JoinError.MalformedMessage);
request.Reject(rejectionContent);
return;
}
if (message.AccessKey != server.Secret.Key)
{
server._log.LogWarning($"Join request {request.RemoteEndPoint} had an incorrect key.");
rejectionContent.Put(JoinError.MismatchedKey);
request.Reject(rejectionContent);
return;
}
var peer = request.Accept();
if (message.HostKey == server.HostKey)
{
server._selfID = peer.Id;
}
using (WriterPool.Instance.Borrow(out var writer))
{
_pong.Send(peer, writer, Timestamped <PingMessage> .Now(new PingMessage(message.ClientTime)));
}
}
public override void OnConnectionRequest(ConnectionRequest request)
{
WriteLine($"Connection Request from '{request.RemoteEndPoint.Address}:{request.RemoteEndPoint.Port}'", ConsoleColor.Cyan);
if (NetManager.ConnectedPeersCount >= MaximumConnections)
{
request.Reject(NetDataWriter.FromString("Server Full"));
WriteLine($"Refused Connection from '{request.RemoteEndPoint.Address}:{request.RemoteEndPoint.Port}'. Reason: Server Full", ConsoleColor.DarkRed);
return;
}
if (!String.IsNullOrWhiteSpace(ServerKey))
{
request.AcceptIfKey(ServerKey);
}
else
{
request.Accept();
}
}
public void OnConnectionRequest(ConnectionRequest request)
{
var key = request.Data.GetString();
if (connectedPeers < connectedPeerLimit &&
key == $"rgbfighters:{Application.version}")
{
request.Accept();
}
else if (connectedPeers >= connectedPeerLimit)
{
request.Reject(Encoding.ASCII.GetBytes("SServerFull"));
}
else if (key != $"rgbfighters:{Application.version}")
{
request.Reject(Encoding.ASCII.GetBytes("SServerClientMismatch"));
}
}
public void OnConnectionRequest(ConnectionRequest request)
{
var connectPaket = new VoicePaketConnectServer();
connectPaket.Deserialize(request.Data);
if (connectPaket.Secret != _secret)
{
Logger.Warn("Unauthorized connect from {0} : Wrong secret", request.RemoteEndPoint);
request.Reject();
return;
}
if (connectPaket.Version < _requiredClientVersion)
{
Logger.Warn("Unauthorized connect from {0} : Wrong Version {1}", request.RemoteEndPoint, connectPaket.Version);
request.Reject();
VoiceClientOutdated?.Invoke(connectPaket.ClientGUID, connectPaket.Version, _requiredClientVersion);
return;
}
Logger.Debug("Connection accepted {0}", request.RemoteEndPoint);
request.Accept();
}
private void OnConnectionRequestEvent(ConnectionRequest request)
{
// PlayerSessionId を接続時に受け取って GameLift に問い合わせる
var pid = request.Data.GetString();
_logger.InfoFormat("playerSessionId: {0}", pid);
var res = GameLiftServerAPI.AcceptPlayerSession(pid);
if (!res.Success)
{
request.Reject();
return;
}
if (!_playerEndPoints.Add(request.RemoteEndPoint, pid))
{
request.Reject();
return;
}
request.Accept();
}
