/// <summary>
/// The MAC input block includes a sequence number, packet length, and protocol (for TLS 1.0+) to detect
/// missing, altered, or extra messages.
/// </summary>
private static byte[] CreateMACInfoPad(ulong seqNum, byte recordType, EProtocol protocol, int length)
{
byte[] pad;
byte[] seqData = BitConverter.GetBytes(seqNum);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(seqData);
}
if (protocol == EProtocol.SSLv30)
{
// With SSL3 should not include version information
pad = new byte[11];
Buffer.BlockCopy(seqData, 0, pad, 0, 8);
pad[8] = (byte)(recordType);
pad[9] = (byte)(length >> 8);
pad[10] = (byte)(length);
}
else
{
// Normal TLS additional bytes to be used
pad = new byte[13];
Buffer.BlockCopy(seqData, 0, pad, 0, 8);
pad[8] = (byte)(recordType);
pad[9] = (byte)((int)(protocol) >> 8);
pad[10] = (byte)((int)(protocol));
pad[11] = (byte)(length >> 8);
pad[12] = (byte)(length);
}
return(pad);
}
private void onClientDataReceived(IAsyncResult asyncResult)
{
pipeServer.EndRead(asyncResult);
if (inBuffer.Length == 0)
{
return;
}
EProtocol protocol = (EProtocol)inBuffer[0];
switch (protocol)
{
case EProtocol.SetAttach:
EAttachPoint attachPoint = (EAttachPoint)inBuffer[1];
int x = inBuffer[2];
int y = inBuffer[3];
LogManager.Instance.Log(String.Format("Client Command: 修改挂点: {0}-{1},{2}", attachPoint.ToString(), x, y));
break;
}
try
{
if (pipeServer.IsConnected)
{
pipeServer.Flush();
pipeServer.BeginRead(inBuffer, 0, pipeServer.InBufferSize, onClientDataReceived, pipeServer);
}
}
catch (Exception e)
{
throw e;
}
}
public void AllowTraffic(List <string> ports, List <IPAddress> addresses)
{
if ((ports == null || ports.Count == 0) && (addresses == null || addresses.Count == 0))
{
defaultAction = EAction.Accept;
}
else
{
ports?.ForEach(port =>
{
EProtocol protocol = EProtocol.TCP;
if (port.Contains('/'))
{
string[] split = port.Split('/');
port = split[0];
protocol = Enum.Parse <EProtocol>(split[1].ToUpper());
}
FirewallRules.Add(nextPort++, new FirewallRule
{
action = EAction.Accept,
protocol = protocol,
destination = new PortTarget(UInt16.Parse(port))
});
});
addresses?.ForEach(address =>
{
FirewallRules.Add(nextPort++, new FirewallRule
{
action = EAction.Accept,
destination = new IPTarget(address)
});
});
}
}
public HttpsCmsgHello(PacketReader reader)
{
TlsVersion = (EProtocol)reader.ReadUShort();
ClientRandom = reader.ReadBytes(32); // first four bytes will be unix time gmt
byte sessionIdLength = reader.ReadByte();
if (sessionIdLength == 0)
{
SessionID = null;
}
else
{
SessionID = reader.ReadBytes(sessionIdLength);
}
ushort ciphersLength = reader.ReadUShort();
if (ciphersLength % 2 != 0)
{
throw new HttpsException($"unsupported cipher length {ciphersLength}", reader);
}
Ciphers = new ECipherSuite[ciphersLength / 2];
for (int i = 0; i < Ciphers.Length; i++)
{
Ciphers[i] = (ECipherSuite)reader.ReadUShort();
}
byte compressionsLength = reader.ReadByte();
Compressions = reader.ReadBytes(compressionsLength);
}
public string GetTimeString(
EElement pStart = EElement.eHours,
EElement pEnd = EElement.eResidual,
EMode pTimeMode = EMode.eDefaultMode,
EProtocol pTimeFormat = EProtocol.eDefaultProtocol)
{
return(GetTimeStringNoOptionalArgs(pStart, pEnd, pTimeMode, pTimeFormat));
}
public Msg(EProtocol p, ETopService ts, int ls, XmlDocument c)
{
protocol = p;
topService = ts;
lowService = ls;
content = c;
length = Encoding.UTF8.GetBytes(c.InnerXml).Length;
}
/// <summary>
/// Client joined event
/// </summary>
/// <param name="userID">User ID</param>
/// <param name="protocol">Protocol</param>
private void ClientJoinedEvent(int userID, EProtocol protocol)
{
if (Protocol == EProtocol.Unspecified)
{
Protocol = protocol;
SendLogInMessageAsync();
OnClientJoined?.Invoke(userID, protocol);
}
}
/// <summary>
/// Create listener (asynchronous)
/// </summary>
/// <param name="protocol">Protocol</param>
/// <param name="port">Port (if 0, default TetriNET port used)</param>
/// <param name="maxUsers">Maximal amount of users (if 0, default TetriNET maximum of users is used)</param>
/// <returns>Server connection task</returns>
internal static Task <ServerListener> CreateListenerAsync(EProtocol protocol, ushort port, uint maxUsers)
{
ushort p = ((port > 0) ? port : defaultPort);
uint max_users = ((maxUsers > 0) ? maxUsers : defaultMaxUsers);
Task <ServerListener> ret = new Task <ServerListener>(() => ServerListener.Create(protocol, p, max_users));
ret.Start();
return(ret);
}
/// <summary>
/// Creates a SSLv3 message authentification code for the passed buffer.
/// </summary>
private static byte[] CreateMAC(EProtocol protocol, KeyedHashAlgorithm hasher, ulong seqNum, ERecordType recordType, byte[] buffer, int offset)
{
int bufferLengthTransformed = buffer.Length - offset;
// hash seq_num, fragment type, fragment length
byte[] infoPad = CreateMACInfoPad(seqNum, (byte)recordType, protocol, bufferLengthTransformed);
// hash(MAC_write_secret + pad_2 + hash(MAC_write_secret + pad_1 + seq_num + record_type + length + content));
hasher.Initialize();
hasher.TransformBlock(infoPad, 0, infoPad.Length, infoPad, 0);
hasher.TransformFinalBlock(buffer, offset, bufferLengthTransformed);
return(hasher.Hash);
}
/// <summary>
/// Client joined event
/// </summary>
/// <param name="userID">User ID</param>
/// <param name="protocol">Protocol</param>
private void ClientJoinedEvent(int userID, EProtocol protocol)
{
if (user == null)
{
User user = new User(userID, clientConnection.Username);
if (users.Insert(user, userID))
{
this.user = user;
OnClientJoined?.Invoke(User);
}
}
}
public HttpsReader(HttpsSession session, byte[] buffer, int length)
: base(buffer, length)
{
IsDecrypted = false;
Session = session;
RecordType = (ERecordType)ReadByte();
RecordVersion = (EProtocol)ReadUShort();
RecordLength = ReadUShort();
VerifyLengthRemaining(this, LengthRemaining, "SSL record header");
if (Session?.IsClientEncrypting ?? false)
{
Decrypt();
}
}
public static T CreateServiceByUrl <T>(string url, EProtocol bing)
{
try
{
if (string.IsNullOrEmpty(url))
{
throw new NotSupportedException("This url is not Null or Empty!");
}
EndpointAddress address = new EndpointAddress(url);
Binding binding = CreateBinding(bing);
ChannelFactory <T> factory = new ChannelFactory <T>(binding, address);
return(factory.CreateChannel());
}
catch (Exception ex)
{
throw new Exception("创建服务工厂出现异常:" + ex.ToString());
}
}
/// <summary>
/// Create server listener
/// </summary>
/// <param name="protocol">Protocol</param>
/// <param name="port">Port</param>
/// <param name="maxUsers">Maximal amount of users</param>
/// <returns></returns>
public static ServerListener Create(EProtocol protocol, ushort port, uint maxUsers)
{
ServerListener ret = null;
TcpListener tcp_listener = TcpListener.Create(port);
tcp_listener.Start((int)maxUsers);
AddressFamily used_address_family = tcp_listener.LocalEndpoint.AddressFamily;
if (used_address_family == AddressFamily.InterNetwork)
{
ret = new ServerListener(protocol, tcp_listener);
}
else
{
tcp_listener.Stop();
throw new UnsupportedAddressFamilyException(used_address_family);
}
return(ret);
}
/// <summary>
/// Create server lobby
/// </summary>
/// <param name="protocol">Protocol</param>
/// <param name="port">Port</param>
/// <param name="maxUsers">Maximal amount of users</param>
/// <returns>Host lobby task</returns>
public static Task <IHostLobby> CreateServerLobby(EProtocol protocol, ushort port, uint maxUsers)
{
Task <IHostLobby> ret = Task.FromResult <IHostLobby>(null);
if (protocol != EProtocol.Unspecified)
{
ret = new Task <IHostLobby>(() =>
{
ServerLobby server_lobby = null;
ushort p = ((port > 0) ? port : Connector.defaultPort);
uint max_users = ((maxUsers > 0) ? maxUsers : Connector.defaultMaxUsers);
ServerListener server_listener = Connector.CreateListenerAsync(protocol, p, max_users).GetAwaiter().GetResult();
if (server_listener != null)
{
server_lobby = new ServerLobby(server_listener, max_users);
}
return(server_lobby);
});
ret.Start();
}
return(ret);
}
public TestTransport(EProtocol aTxProtocol, EProtocol aRxProtocol, string aLocalAddr, string aRemoteAddr, Logger aLog, ETest aTest)
: base(aLocalAddr, aLog, aTest)
{
if (aRemoteAddr == null)
{
iAbortMsg = "DS device undefined";
iAbortTest = true;
return;
}
try
{
if ((aTxProtocol == EProtocol.eTcp) && (aRxProtocol == EProtocol.eTcp))
{
iConx = new TcpConx(aLocalAddr, aRemoteAddr);
}
else if ((aTxProtocol == EProtocol.eUdp) && (aRxProtocol == EProtocol.eUdp))
{
iConx = new UdpConx(aLocalAddr, aRemoteAddr);
}
else if ((aTxProtocol == EProtocol.eUdp) && (aRxProtocol == EProtocol.eUdpMulti))
{
iConx = new UdpMultiRespondConx(aLocalAddr, aRemoteAddr);
}
else if ((aTxProtocol == EProtocol.eUdpMulti) && (aRxProtocol == EProtocol.eUdp))
{
iConx = new UdpMultiSenderConx(aLocalAddr, aRemoteAddr);
}
else
{
Assert.Check(false, "Invalid test configuration");
}
}
catch (Exception e)
{
iAbortMsg = e.ToString();
iAbortTest = true;
}
}
/// <summary>
/// 创建传输协议
/// </summary>
/// <param name="binding">传输协议名称</param>
/// <returns></returns>
private static Binding CreateBinding(EProtocol binding)
{
Binding bindinginstance = null;
if (binding == EProtocol.BasicHttpBinding)
{
BasicHttpBinding ws = new BasicHttpBinding();
ws.MaxBufferSize = 2147483647;
ws.MaxBufferPoolSize = 2147483647;
ws.MaxReceivedMessageSize = 2147483647;
ws.ReaderQuotas.MaxStringContentLength = 2147483647;
ws.CloseTimeout = new TimeSpan(0, 30, 0);
ws.OpenTimeout = new TimeSpan(0, 30, 0);
ws.ReceiveTimeout = new TimeSpan(0, 30, 0);
ws.SendTimeout = new TimeSpan(0, 30, 0);
ws.Security.Mode = BasicHttpSecurityMode.None;
bindinginstance = ws;
}
else if (binding == EProtocol.NetTcpbingding)
{
NetTcpBinding ws = new NetTcpBinding();
ws.MaxReceivedMessageSize = 65535000;
ws.Security.Mode = SecurityMode.None;
bindinginstance = ws;
}
else if (binding == EProtocol.WSHttpBinding)
{
WSHttpBinding ws = new WSHttpBinding(SecurityMode.None);
ws.MaxBufferPoolSize = 65535000;
ws.MaxReceivedMessageSize = 65535000;
ws.TextEncoding = Encoding.UTF8;
ws.Security.Message.ClientCredentialType = System.ServiceModel.MessageCredentialType.Windows;
ws.Security.Transport.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.Windows;
bindinginstance = ws;
}
return(bindinginstance);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="tcpClient">TCP client</param>
/// <param name="protocol">Protocol</param>
internal ServerConnection(TcpClient tcpClient, EProtocol protocol)
{
this.tcpClient = tcpClient;
messageParser = new MessageParser(protocol);
messageBuilder = new MessageBuilder(protocol);
tcpClientNetworkStream = tcpClient.GetStream();
Protocol = protocol;
messageParser.OnUserTeamNameChanged += OnUserTeamNameChanged;
messageParser.OnUserChatMessageReceived += OnUserChatMessageReceived;
messageParser.OnUserChatActionReceived += OnUserChatActionReceived;
messageParser.OnGameChatMessageReceived += OnGameChatMessageReceived;
messageParser.OnUserLevelUpdate += OnUserLevelUpdate;
messageParser.OnClassicModeAddLines += OnClassicModeAddLines;
messageParser.OnUserSpecialUsedForAll += OnUserSpecialUsedForAll;
messageParser.OnUserSpecialUsed += OnUserSpecialUsed;
messageParser.OnUserLost += OnUserLost;
messageParser.OnPauseGame += OnPauseGame;
messageParser.OnResumeGame += OnResumeGame;
messageParser.OnUserFullFieldUpdate += OnUserFullFieldUpdate;
messageParser.OnUserPartialFieldUpdate += OnUserPartialFieldUpdate;
messageParser.OnClientLogIn += OnClientLogIn;
messageParser.OnClientInformationReceived += OnClientInformationReceived;
messageParser.OnStartGame += OnStartGame;
messageParser.OnStopGame += OnStopGame;
listenerThread = new Thread((that) =>
{
if (that is ServerConnection)
{
ServerConnection server_connection = (ServerConnection)that;
using (MemoryStream buffer = new MemoryStream())
{
while (server_connection.CanReceive)
{
lock (server_connection.tcpClient)
{
int available = server_connection.tcpClient.Available;
if (available > 0)
{
byte[] available_data = new byte[available];
if (server_connection.tcpClientNetworkStream.Read(available_data, 0, available) == available)
{
foreach (byte b in available_data)
{
if (b == 0xFF)
{
byte[] data = new byte[buffer.Length];
if (buffer.Read(data, 0, data.Length) == data.Length)
{
messageParser.ParseMessage(Encoding.UTF8.GetString(data));
}
buffer.SetLength(0L);
}
}
}
}
}
}
}
}
});
listenerThread.Start(this);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="protocol">Protocol</param>
/// <param name="tcpListener">TCP listener</param>
private ServerListener(EProtocol protocol, TcpListener tcpListener)
{
Protocol = protocol;
TCPListener = tcpListener;
listenerThread = new Thread((that) =>
{
if (that is ServerListener)
{
ServerListener listener = (ServerListener)that;
while (listener.TCPListener != null)
{
lock (listener.TCPListener)
{
if (listener.TCPListener.Pending())
{
TcpClient tcp_client = listener.TCPListener.AcceptTcpClient();
if (tcp_client != null)
{
bool allow = (Whitelist.Count <= 0);
string address = ((IPEndPoint)(tcp_client.Client.RemoteEndPoint)).Address.ToString();
if (!allow)
{
allow = Whitelist.Contains(address);
}
if (allow)
{
allow = !(Bans.Contains(address));
}
if (allow)
{
ServerConnection server_connection = new ServerConnection(tcp_client, protocol);
lock (listener.serverConnections)
{
listener.serverConnections.Add(server_connection);
}
OnClientConnectionAccepted?.Invoke(server_connection);
}
else
{
OnClientConnectionDenied?.Invoke(tcp_client);
tcp_client.Dispose();
}
}
}
}
lock (listener.serverConnections)
{
List <Tuple <int, ServerConnection> > dispose_server_connections = null;
for (int i = 0; i < listener.serverConnections.Count; i++)
{
ServerConnection server_connection = listener.serverConnections[i];
if ((!(server_connection.CanReceive)) && (!(server_connection.CanSend)))
{
if (dispose_server_connections == null)
{
dispose_server_connections = new List <Tuple <int, ServerConnection> >();
}
dispose_server_connections.Add(new Tuple <int, ServerConnection>(i, server_connection));
}
}
dispose_server_connections.Reverse();
foreach (Tuple <int, ServerConnection> server_connection in dispose_server_connections)
{
listener.serverConnections.RemoveAt(server_connection.Item1);
}
}
Thread.Sleep(20);
}
}
});
listenerThread.Start(this);
}
public static FbxTime FromTimeString(string pTime, EMode pTimeMode = EMode.eDefaultMode, EProtocol pTimeFormat = EProtocol.eDefaultProtocol)
{
return(FbxTime.FromTimeStringNoOptionalArgs(pTime, pTimeMode, pTimeFormat));
}
public void process_user_operation(CPacket message)
{
EProtocol protocol_id = (EProtocol)message.pop_protocol_id();
switch (protocol_id)
{
#region receive from server
case EProtocol.CHAT_MSG_ACK:
{
string RoomName = message.pop_string();
string UserName = message.pop_string();
string Message = message.pop_string();
if (!ChatPage_Return_Callback.ContainsKey(RoomName))
{
break;
}
ChatPage_Return_Callback[RoomName](EChatItem.Chat, new ChatItem {
Name = UserName, Message = Message, SendTime = DateTime.UtcNow
});
}
break;
case EProtocol.SET_NAME_ACK:
{
if (LoginPage_Return_Callback == null)
{
break;
}
LoginPage_Return_Callback((short)protocol_id);
}
break;
case EProtocol.SET_NAME_ERROR_EXISTED:
{
if (LoginPage_Return_Callback == null)
{
break;
}
LoginPage_Return_Callback((short)protocol_id);
}
break;
case EProtocol.ASK_USER_LIST_ACK:
{
}
break;
case EProtocol.CREATE_CHAT_ROOM_ACK:
{
if (Create_Page_Callback == null)
{
break;
}
var UserList = message.pop_string_list();
var ServerName = message.pop_string();
var ServerInitial = message.pop_string();
Create_Page_Callback((short)protocol_id, UserList, ServerName, ServerInitial);
}
break;
case EProtocol.CREATE_CHAT_ROOM_ERROR:
{
if (Create_Page_Callback == null)
{
break;
}
Create_Page_Callback((short)protocol_id, null, null, null);
}
break;
case EProtocol.EXIT_THE_ROOM_USER:
{
string RoomName = message.pop_string();
string UserName = message.pop_string();
if (!ChatPage_Return_Callback.ContainsKey(RoomName))
{
break;
}
ChatPage_Return_Callback[RoomName](EChatItem.UserExit, UserName);
}
break;
case EProtocol.ADD_USER_IN_ROOM_ACK:
{
}
break;
case EProtocol.JOIN_THE_ROOM_ACK:
{
if (Create_Page_Callback == null)
{
break;
}
var UserList = message.pop_string_list();
var ServerName = message.pop_string();
var ServerInitial = message.pop_string();
Create_Page_Callback((short)protocol_id, UserList, ServerName, ServerInitial);
}
break;
case EProtocol.JOIN_THE_ROOM_ERROR:
{
if (Create_Page_Callback == null)
{
break;
}
Create_Page_Callback((short)protocol_id, null, null, null);
}
break;
case EProtocol.JOIN_THE_ROOM_NEW_USER:
{
string RoomName = message.pop_string();
string UserName = message.pop_string();
if (!ChatPage_Return_Callback.ContainsKey(RoomName))
{
break;
}
ChatPage_Return_Callback[RoomName](EChatItem.User, new User {
Name = UserName
});
}
break;
#endregion
}
}
/// <summary> /// Create server lobby /// </summary> /// <param name="protocol">Protocol</param> /// <param name="port">Port</param> /// <returns>Lobby task</returns> public static Task <IHostLobby> CreateServerLobby(EProtocol protocol, ushort port) => CreateServerLobby(protocol, port, 0U);
/// <summary> /// Create server lobby /// </summary> /// <param name="protocol">Protocol</param> /// <returns>Lobby task</returns> public static Task <IHostLobby> CreateServerLobby(EProtocol protocol) => CreateServerLobby(protocol, 0, 0U);
/// <summary>
/// Constructor
/// </summary>
/// <param name="protocol">Protocol</param>
internal MessageBuilder(EProtocol protocol)
{
Protocol = protocol;
}
private static extern int socket(EAddressFamily domain, ESocketType socketType, EProtocol protocol);
public GameEvent(string tag, EProtocol protocol = EProtocol.Delayed)
{
m_Tag = tag;
m_Protocol = protocol;
}
public HttpsSession(EProtocol protocol)
{
IsClientEncrypting = false;
IsServerEncrypting = false;
Protocol = protocol;
}
private void onSvrDataReceived(IAsyncResult asyncResult)
{
// 这里用不到asyncResult
pipeClient.EndRead(asyncResult);
EProtocol protocol = (EProtocol)inBuffer[0];
switch (protocol)
{
case EProtocol.PreloadAllSpine:
Debug.Log("ServerCommand: PreloadSpine");
int dirLen = inBuffer[1];
string dir = Encoding.UTF8.GetString(inBuffer, 2, dirLen);
Debug.Log("Preload Dir: " + dir);
ToolManager.Instance.NeedPreloadSpine = true;
ToolManager.Instance.SpineDir = dir;
break;
case EProtocol.LoadSpine:
Debug.Log("ServerCommand: LoadSpine");
int nameLen = inBuffer[1];
string name = Encoding.UTF8.GetString(inBuffer, 2, nameLen);
int zipLen = inBuffer[2 + nameLen];
string zipPath = Encoding.UTF8.GetString(inBuffer, 3 + nameLen, zipLen);
Debug.Log("Name: " + name);
Debug.Log("Zip: " + zipPath);
ToolManager.Instance.NeedLoadSpine = true;
ToolManager.Instance.SpineName = name;
ToolManager.Instance.SpineZipPath = zipPath;
// ToolManager.Instance.LoadSpine(name, zipPath);
break;
case EProtocol.SetAttach:
print("ServerCommand SetAttach");
EAttachPoint attachPoint = (EAttachPoint)inBuffer[1];
int x = inBuffer[2];
int y = inBuffer[3];
ToolManager.Instance.SetAttach(attachPoint, x, y);
break;
case EProtocol.PlayAnim:
print("ServerCommand PlayAnim");
ToolManager.Instance.NeedPlayAnim = true;
int animNameLen = inBuffer[1];
string animName = Encoding.UTF8.GetString(inBuffer, 2, animNameLen);
ToolManager.Instance.AnimName = animName;
break;
}
pipeClient.Flush();
pipeClient.BeginRead(inBuffer, 0, pipeClient.InBufferSize, onSvrDataReceived, pipeClient);
//string info = System.Text.Encoding.UTF8.GetString(inBuffer);
//int len = pipeClient.ReadByte() * 256;
//len += pipeClient.ReadByte();
//inBuffer = new byte[len];
//pipeClient.Read(inBuffer, 0, len);
//remoteInfo = Encoding.Unicode.GetString(inBuffer);
// asyncResult.AsyncState
}
