public AesStream(Socket socket, EnhancedStream stream, byte[] key)
: base(socket)
{
BaseStream = stream;
_enc = new CryptoStream(stream, GenerateAES(key).CreateEncryptor(), CryptoStreamMode.Write);
_dec = new CryptoStream(stream, GenerateAES(key).CreateDecryptor(), CryptoStreamMode.Read);
}
/// <summary>
/// Initialises a new instance of the <see cref="LiveSocketMessageStream"/> class.
/// </summary>
/// <param name="socket">The stream socket.</param>
/// <exception cref="System.ArgumentNullException">
/// Thrown when <paramref name="socket"/> is <see langword="null"/>.
/// </exception>
public LiveSocketMessageStream(Socket socket)
{
Guard.NotNull(socket, "socket");
Socket = socket;
Socket.NoDelay = true;
}
public WebSocketConnection(Socket socket, WebSocketWrapper websocket, SubProtocolModelFactoryWrapper modelfactory)
{
Sender = new Sender(socket, websocket);
Receiver = new Receiver(socket, websocket, modelfactory);
Sender.Connection = this;
Receiver.Connection = this;
}
public void reConnect()
{
serviceSocket.Close();
serviceSocket = null;
sendBuffer = new byte[1024];//Send buffer //c# automatic assigesd to 0
try
{
serviceSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
System.Threading.Thread tt = new System.Threading.Thread(delegate()
{
try
{
serviceSocket.Connect(ip, port);
}
catch (Exception ee)
{
//MessageBox.Show(ee.Message + "\r\n From:" + this);
}
});
tt.Start();
}
catch (Exception e)
{
//MessageBox.Show(e.Message + "\r\n From:" + this);
}
}
public ClientConnection(Socket socket)
: base(socket)
{
DisconnectedEvent += ClientConnection_DisconnectedEvent;
m_LittleEndian = true;
Logger.Trace("Client {0}: Connected", this);
}
public ProcessQueue(int _cardNo, Player _user, Socket _userSocket, Player _target)
{
cardNo = _cardNo;
user = _user;
target = _target;
userSocket = _userSocket;
}
public WebSocketConnection(Socket socket, WebSocketWrapper websocket)
{
Sender = new Sender(socket, websocket);
Receiver = new Receiver(socket, websocket);
Sender.Connection = this;
Receiver.Connection = this;
}
internal Connection(Socket ClientSocket, NetworkStream ClientStream)
{
this.ClientSocket = ClientSocket;
this.ClientStream = ClientStream;
this.Reader = new WebSocketFrameReader(ClientStream);
}
public bool initializeConnection()
{
try
{
m_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
m_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
m_socket.SendTimeout = 5000;
m_socket.ReceiveTimeout = 5000;
m_frm.Print("Connecting to " + ECCServerIP + " at port " + ECCServerPort + " ...");
m_socket.Connect(ECCServerIP, Convert.ToInt32(ECCServerPort));
}
catch (Exception ex)
{
m_frm.Print("Error!Failed to connect to ECC server!" + ex.Message);
return false;
}
if (!Authenticate())
return false;
return true;
}
public ClientProcessor(Socket skt)
{
this.skt = skt;
ReceiveKey =
new RC4(new byte[] {0x31, 0x1f, 0x80, 0x69, 0x14, 0x51, 0xc7, 0x1b, 0x09, 0xa1, 0x3a, 0x2a, 0x6e});
SendKey = new RC4(new byte[] {0x72, 0xc5, 0x58, 0x3c, 0xaf, 0xb6, 0x81, 0x89, 0x95, 0xcb, 0xd7, 0x4b, 0x80});
}
public AbstractSession(Socket sck)
{
this.Actived = false;
this.Socket = sck;
this.Handle = sck.Handle.ToInt32();
this.RemoteEndpoint = sck.RemoteEndPoint.ToString();
}
/// <summary>
/// Accepts incoming npc service connection.
/// </summary>
/// <param name="s">Accepted <see cref="Socket"/> object.</param>
internal static void AcceptConnection( Socket s )
{
if ( s == null || !s.Connected )
return;
if ( !Active )
{
NetworkHelper.RemoteServiceInfo info = NetworkHelper.GetServiceInfo(s);
if ( info.ServiceType == ServiceType.NpcService )
{
m_NpcServerConnection = new InnerNetworkClient(info.ServiceId, info.ServiceType, s);
NpcServiceRequestsHandlers nsrh = new NpcServiceRequestsHandlers(ref m_NpcServerConnection);
//m_NpcServerConnection.OnDisconnected += new OnDisconnectedEventHandler(NpcServerConnection_OnDisconnected);
m_NpcServerConnection.HandleDelegate = nsrh.Handle;
m_NpcServerConnection.Send(new InitializeResponse(Settings.Default.ServiceUniqueID, ( byte )ServiceType.GameService, InitializeResponse.Accepted).ToPacket());
Active = true;
Logger.WriteLine(Source.InnerNetwork, "Connection accepted for {0} (0x{1})", info.ServiceType, info.ServiceId.ToString("x2"));
}
}
}
public OnlineUser(Socket socket, String username, String token, String publicKey)
{
WorkSocket = socket;
Username = username;
this.token = token;
PublicKey = publicKey;
}
/// <summary>
/// Checks the connection.
/// </summary>
/// <param name="sock">The sock.</param>
/// <param name="maxIpConnectionCount">The maximum ip connection count.</param>
/// <param name="antiDDosStatus">if set to <c>true</c> [anti d dos status].</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
internal static bool CheckConnection(Socket sock, int maxIpConnectionCount, bool antiDDosStatus)
{
if (!antiDDosStatus)
return true;
string iP = sock.RemoteEndPoint.ToString().Split(':')[0];
if (iP == _mLastIpBlocked)
return false;
if (GetConnectionAmount(iP) > maxIpConnectionCount)
{
Writer.WriteLine(iP + " was banned by Anti-DDoS system.", "Yupi.Security", ConsoleColor.Blue);
_mLastIpBlocked = iP;
return false;
}
int freeConnectionId = GetFreeConnectionId();
if (freeConnectionId < 0)
return false;
_mConnectionStorage[freeConnectionId] = iP;
return true;
}
public AuthChallenge(Socket conn)
{
int soFar = 0;
byte[] buffer = new byte[MESSAGE_SIZE];
while (soFar < MESSAGE_SIZE)
{
//read the header and challenge phrase
int rcvd = conn.Receive(buffer, (int)MESSAGE_SIZE - soFar, SocketFlags.None);
if (rcvd == 0) throw new AuthException("Disconnect during authentication");
if (soFar == 0 && buffer[0] != PACKET_IDENTIFIER) throw new AuthException("Invalid challenge packet header");
//skip the first byte
if (soFar == 0)
{
if (rcvd > 1) _challenge.Append(buffer, 1, rcvd - 1);
}
else
{
_challenge.Append(buffer, 0, rcvd);
}
soFar += rcvd;
}
}
public Client(Socket pSocket, byte pWorld, byte pChannel, string pType)
: base(pSocket, pSocket.RemoteEndPoint.ToString())
{
this.World = pWorld;
this.Channel = pChannel;
this.Type = pType;
}
// public Socket(AddressFamily af, SocketType st, ProtocolType pt)
// {
// this.sock = new Sock(af, st, pt);
// this.sock.Connect();
// }
public Socket(string host, int port)
{
IPEndPoint ep = new IPEndPoint(Dns.GetHostByName(host).AddressList[0], port);
this.sock = new Sock(ep.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
this.sock.Connect(ep);
}
public void Start()
{
_layerFactory = new OwinHandlerFactory(_parameters.OwinApp, _parameters.OwinCapabilities);
_ipIsLocalChecker = new IpIsLocalChecker();
_connectionAllocationStrategy = _parameters.ConnectionAllocationStrategy;
var isSsl = _parameters.Certificate != null;
_layerFactory = new Transport2HttpFactory(_parameters.BufferSize, isSsl, _parameters.ServerHeader, _ipIsLocalChecker, _layerFactory);
if (isSsl)
{
_layerFactory = new SslTransportFactory(_parameters, _layerFactory);
}
ListenSocket = new Socket(_parameters.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
var start = DateTime.UtcNow;
while (true)
{
try
{
ListenSocket.Bind(_parameters.EndPoint);
break;
}
catch when(start + _parameters.RetrySocketBindingTime > DateTime.UtcNow)
{
}
Thread.Sleep(50);
}
ListenSocket.Listen(100);
var initialConnectionCount = _connectionAllocationStrategy.CalculateNewConnectionCount(0, 0);
AllocatedConnections = initialConnectionCount;
_blocks.Add(new ConnectionBlock(this, _layerFactory, initialConnectionCount));
}
//处理服务器收到的信息数据,返回gameuser信息
public static GameUser InfoDataDeal(MySQLCtrl mySQLCtrl, Socket socket, string infoStr)
{
string[] strTemp = DataCtrl.SegmentData(infoStr);
GameUser gameuser = new GameUser();
switch (strTemp[0])
{
//收到注册数据
case "0":
string[] infos = DataCtrl.SegmentData(infoStr.Substring(2));
if (mySQLCtrl.IsExistInDb(infos[0]))
{ gameuser.Status = "0|0|0|注册邮箱已存在|"; return gameuser; }
if (mySQLCtrl.IsNickNameExistInDb(infos[1]))
{ gameuser.Status = "0|0|0|注册昵称已存在|"; return gameuser; }
RegisterDeal(mySQLCtrl, socket, infos, out gameuser);
return gameuser;
//收到登陆数据
case "1":
string[] loadInfo = DataCtrl.SegmentData(infoStr.Substring(2));
if (!mySQLCtrl.IsExistInDb(loadInfo[0]))
{ gameuser.Status = "0|1|0|登录邮箱未注册|"; return gameuser; }
SignDeal(mySQLCtrl, socket, loadInfo, out gameuser);
return gameuser;
default: return null;
}
}
/// <summary>
/// 创建房间数据处理
/// </summary>
/// <param name="roomSeatSockets">要操作的socket字典</param>
/// <param name="roomNum">要操作的房间号</param>
/// <param name="socket">对应的客户端socket</param>
/// <param name="roomStr">对应的接收到的房间数据</param>
/// <returns>成功返回true，否则返回false</returns>
public static string RoomDataDeal(GameDataCenter gameDataCenter, Socket socket, string roomStr)
{
string[] strTemp = DataCtrl.SegmentData(roomStr);
switch (strTemp[0])
{
//创建房间的信息，房间号++，建立socket的list，加入当前socket，将当前list加入dic，如果对应的房间号的list包含此socket,加入对应的playerdata，返回true，否则，返回false。
case "0":
int roomNum = 1;
while(gameDataCenter.RoomDataDic.Keys.Contains(roomNum))
{
roomNum++;
}
gameDataCenter.RoomNum= roomNum;
List<Socket> l = new List<Socket>();
l.Add(socket);
gameDataCenter.RoomSeatSockets.Add(gameDataCenter.RoomNum, l);
if (gameDataCenter.RoomSeatSockets[gameDataCenter.RoomNum].Contains(socket))
{
GameRoomData gameRoomData = new GameRoomData();
PlayerData playerData = new PlayerData(1, gameDataCenter.MailNickDic[strTemp[1]],strTemp[1],socket);
playerData.IsKing = true;
gameRoomData.PlayerDataDic.Add(1,playerData);
gameDataCenter.RoomDataDic.Add(gameDataCenter.RoomNum, gameRoomData);
//更新所有的在大厅中的人的信息，同时更新特定房间的人的信息
RoomDataPushAll(gameDataCenter);
RoomDataPush(gameDataCenter, roomNum);
return "1|0|1|" + gameDataCenter.RoomNum.ToString() + "|" + gameDataCenter.RoomSeatSockets[gameDataCenter.RoomNum].Count.ToString() + "|";
}
else
{
gameDataCenter.RoomNum--;
return "1|0|0|创建失败|";
}
//加入房间的信息，先取得房间号i,判断房间号i存在否，存在则将此socket加入list，如果此list含此socket，返回true。
case "1":
int i;
int.TryParse(strTemp[1], out i);
if (!gameDataCenter.RoomSeatSockets.Keys.Contains(i)) { return "1|1|0|加入失败|"; }
gameDataCenter.RoomSeatSockets[i].Add(socket);
if (gameDataCenter.RoomSeatSockets[i].Contains(socket))
{
PlayerData playerData = new PlayerData(gameDataCenter.RoomSeatSockets[i].Count, gameDataCenter.MailNickDic[strTemp[1]], strTemp[1],socket);
gameDataCenter.RoomDataDic[i].PlayerDataDic.Add(gameDataCenter.RoomDataDic[i].PlayerDataDic.Count+1, playerData);
//更新所有的在大厅中的人的信息，同时更新特定房间的人的信息
RoomDataPushAll(gameDataCenter);
RoomDataPush(gameDataCenter, i);
return "1|1|1|" + i + "|" + gameDataCenter.RoomSeatSockets[i].Count.ToString() + "|"; }
else
{ return "1|1|0|加入失败|"; }
//更新房间信息
case "2":
string strRoomDataUpdate = RoomDataUpdate(gameDataCenter, socket, strTemp);
return strRoomDataUpdate;
default: return "未知错误";
}
}
public void Dispose()
{
Socket.Disconnect(false);
Socket.Shutdown(SocketShutdown.Both);
Socket.Close();
Socket = null;
}
// The read socket that creates this object sends a copy of its "parent" accept socket in as a reference
// We also take in a max buffer size for the data to be read off of the read socket
public OSUserToken(Socket readSocket, Int32 bufferSize, IEFMagLinkRepository repository)
{
_repository = repository;
ownersocket = readSocket;
stringbuilder = new StringBuilder(bufferSize);
}
public AsyncSocketSession(Socket client, SocketAsyncEventArgsProxy socketAsyncProxy, bool isReset)
: base(client)
{
SocketAsyncProxy = socketAsyncProxy;
m_OrigOffset = socketAsyncProxy.SocketEventArgs.Offset;
m_IsReset = isReset;
}
public Client(Socket s)
{
clientSocket = s;
//启动一个线程处理客户端的数据接收
t = new Thread(ReceiveMessage);
t.Start();
}
/// <summary>
/// 启动监听
/// </summary>
/// <param name="config">服务器配置</param>
/// <returns></returns>
public override bool Start(IServerConfig config)
{
m_ListenSocket = new System.Net.Sockets.Socket(this.Info.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
//关联终结地
m_ListenSocket.Bind(this.Info.EndPoint);
//设置监听最大连接数
m_ListenSocket.Listen(m_ListenBackLog);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
//初始化套接字操作
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
m_AcceptSAE = acceptEventArg;
//定义一个连接完成事件
acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(acceptEventArg_Completed);
if (!m_ListenSocket.AcceptAsync(acceptEventArg))
{
ProcessAccept(acceptEventArg);
}
return true;
}
catch (Exception e)
{
OnError(e);
return false;
}
}
public WorkerProxy(NagCoordinator coordinator, Socket socket)
{
Worker = new TCPConnection(socket, false, ProcesLine, null);
NagCoordinator = coordinator;
State = ConnectionState.Negotiating;
Negotiate();
}
public static void CheckDualModeReceiveSupport(Socket socket)
{
if (!SupportsDualModeIPv4PacketInfo && socket.AddressFamily == AddressFamily.InterNetworkV6 && socket.DualMode)
{
throw new PlatformNotSupportedException(SR.net_sockets_dualmode_receivefrom_notsupported);
}
}
public static int DestorySocket(Socket socket)
{
int r = -1;
try
{
//if (_socket.Connected)
//{
// _socket.Disconnect(false);
//}
if (socket != null)
{
socket.Shutdown(SocketShutdown.Both);
socket.DisconnectAsync(null);
socket.Close();
socket.Dispose();
socket = null;
}
r = 0;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
r = -1;
}
return r;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerContext"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="serverSocket">The server socket.</param>
internal ServerContext(StandardServer server, IServerConfiguration configuration, Socket serverSocket)
{
this.ListeningSocket = serverSocket;
this.Server = server;
this.windowsServer = server;
this.Configuration = configuration;
}
protected SocketConnectionServerDispatcher(System.Net.Sockets.Socket connect) : base(connect)
{
}
/// <summary>
/// Sends the specified number of bytes of data to a connected <see cref="Socket" />, starting at the specified offset, and using the specified <see cref="SocketFlags" />.
/// </summary>
/// <param name="data">An string of type <see cref="string" /> that contains the data to be sent.</param>
/// <param name="socketFlags">A bitwise combination of the <see cref="SocketFlags" /> values.</param>
/// <param name="socketError">A <see cref="SocketError" /> object that stores the socket error.</param>
/// <param name="encoding">The <see cref="Encoding"/> for data.</param>
/// <returns>The number of bytes sent to the <see cref="Socket"/>.</returns>
public static int Send(this System.Net.Sockets.Socket socket, string data, SocketFlags socketFlags, out SocketError socketError, Encoding encoding)
{
byte[] buffers = encoding.GetBytes(data);
return(socket.Send(buffers, 0, buffers.Length, socketFlags, out socketError));
}
/// <inheritdoc/> protected abstract IoSession NewSession(IoProcessor <SocketSession> processor, System.Net.Sockets.Socket socket);
public Socket(Sock sock)
{
this.sock = sock;
}
public UdpListener(IPEndPoint endPoint)
{
_endPoint = endPoint;
_socket = new System.Net.Sockets.Socket(_endPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
_socket.Bind(_endPoint);
}
/// <summary>
/// Determine whether data is ready to be read
/// </summary>
public static bool IsDataAvailable(this System.Net.Sockets.Socket s)
{
return(s.Poll(1000, SelectMode.SelectRead) && (s.Available > 0));
}
/// <inheritdoc/>
protected override IoSession NewSession(IoProcessor <SocketSession> processor, System.Net.Sockets.Socket socket)
{
SocketAsyncEventArgsBuffer readBuffer = _readWritePool.Pop();
SocketAsyncEventArgsBuffer writeBuffer = _readWritePool.Pop();
if (readBuffer == null)
{
readBuffer = (SocketAsyncEventArgsBuffer)
SocketAsyncEventArgsBufferAllocator.Instance.Allocate(SessionConfig.ReadBufferSize);
readBuffer.SocketAsyncEventArgs.Completed += readWriteEventArg_Completed;
}
if (writeBuffer == null)
{
writeBuffer = (SocketAsyncEventArgsBuffer)
SocketAsyncEventArgsBufferAllocator.Instance.Allocate(SessionConfig.ReadBufferSize);
writeBuffer.SocketAsyncEventArgs.Completed += readWriteEventArg_Completed;
}
return(new AsyncSocketSession(this, processor, socket, readBuffer, writeBuffer, ReuseBuffer));
}
public Peer(System.Net.Sockets.Socket socket)
{
_SocketErrorEvent += (e) => { };
Socket = socket;
}
public SendingContext(System.Net.Sockets.Socket s, Core.File.IFileRegion f)
{
socket = s;
buffer = null;
file = f;
}
/// <summary>
/// Sends data to a connected <see cref="Socket" /> using the specified <see cref="SocketFlags" />.
/// </summary>
/// <param name="data">An string of type <see cref="string" /> that contains the data to be sent.</param>
/// <param name="socketFlags">A bitwise combination of the <see cref="SocketFlags" /> values.</param>
/// <param name="encoding">The <see cref="Encoding"/> for data.</param>
/// <returns>The number of bytes sent to the <see cref="Socket"/>.</returns>
public static int Send(this System.Net.Sockets.Socket socket, string data, SocketFlags socketFlags, Encoding encoding)
{
byte[] buffers = encoding.GetBytes(data);
return(socket.Send(buffers, socketFlags));
}
public AsyncSocketSession(IoService service, IoProcessor <SocketSession> processor,
System.Net.Sockets.Socket socket, Boolean reuseBuffer)
: base(service, processor, new SessionConfigImpl(socket), socket, socket.LocalEndPoint, socket.RemoteEndPoint, reuseBuffer)
{
_readBuffer = new Byte[service.SessionConfig.ReadBufferSize];
}
public SendingContext(System.Net.Sockets.Socket s, IoBuffer b)
{
socket = s;
buffer = b;
file = null;
}
public void WaitAccess()
{
m_clientSocket = m_serverSocket.Accept();
}
public AsyncUserToken(System.Net.Sockets.Socket socket)
{
this.Socket = socket;
this.Buffer = new List <byte>();
}
/// <summary>
/// Create a new instance of the server context type.
/// </summary>
/// <param name="clientSocket">The current state, contains a socket client.</param>
private void CreateServerContext(System.Net.Sockets.Socket clientSocket)
{
ServerContext socketServerContext = null;
try
{
// Clear last error.
ClearLastError();
// Create a new instance of the server context type
socketServerContext = (ServerContext)Nequeo.Reflection.TypeAccessor.CreateInstance(_serverContext);
// Assign the accepted socket.
socketServerContext.Socket = clientSocket;
socketServerContext.UseSslConnection = _useSslConnection;
socketServerContext.X509Certificate = _sslCertificate;
socketServerContext.Name = _serverName;
socketServerContext.SslProtocols = _sslProtocols;
socketServerContext.SocketType = _socketType;
socketServerContext.ProtocolType = _protocolType;
socketServerContext.ReceiveSocketFlags = _receiveSocketFlags;
socketServerContext.SendSocketFlags = _sendSocketFlags;
socketServerContext.SendToServerHandler = _sendToServerHandler;
socketServerContext.SendToServerInfoHandler = _sendToServerInfoHandler;
socketServerContext.BeginSslAuthenticate = _beginSslAuthentication;
socketServerContext.ReadBufferSize = READ_BUFFER_SIZE;
socketServerContext.WriteBufferSize = WRITE_BUFFER_SIZE;
socketServerContext.Server = this;
// if a time out has been set.
if (_timeOut > 0)
{
socketServerContext.TimeOut = _timeOut;
}
// Create a new client data receive handler, this event
// handles commands from the current client.
socketServerContext.OnCommandSend +=
new ServerContextHandler(SocketServer_OnCommandSend);
// Increment the count.
IncrementCount();
// Initialise the connection.
socketServerContext.InitialiseThread();
try
{
// Send the new connection to the caller.
if (OnClientConnected != null)
{
OnClientConnected(this, socketServerContext);
}
}
catch { }
}
catch (Exception ex)
{
// Clean-up if error.
if (socketServerContext != null)
{
socketServerContext.Dispose();
}
socketServerContext = null;
SetLastError(ex);
}
}
public void CreateSocketAndStandBy()
{
m_serverSocket = new System.Net.Sockets.Socket(m_ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
m_serverSocket.Bind(m_localEndPoint);
m_serverSocket.Listen(10);
}
private static void Socket_OnReceivingEvent(System.Net.Sockets.Socket S, byte[] Packet)
{
int packetNumber = BitConverter.ToUInt16(Packet, 2);
switch (packetNumber)
{
case 1000:
Connect connectPacket = new Connect(Packet);
Character c = new Character(connectPacket.Character, S);
c.CharacterID = (byte)charactersPool.Count;
connectPacket.CharacterID = c.CharacterID;
c.CharacterType = connectPacket.Character;
socket.Send(S, connectPacket.Packet());
charactersPool.Add(c);
if (charactersPool.Count == 2)
{
GroundedObject GO = new GroundedObject();
GO.CharacterType = 0;
for (int i = 0; i < Constants.enemiesCount; i++)
{
GO.Buffer[i + 6] = (byte)(ran.Next(0, 3));
}
for (int i = 0; i < Constants.enemiesCount; i++)
{
int idx = i * 4 + 50;
int v = ran.Next(-1100, -800);
Console.WriteLine("r: " + v);
byte[] Val = BitConverter.GetBytes(v);
Buffer.BlockCopy(Val, 0, GO.Buffer, idx, Val.Length);
}
socket.Send(charactersPool[0].socket, GO.Packet());
//Thread.Sleep(500);
socket.Send(charactersPool[1].socket, GO.Packet());
//Thread.Sleep(500);
GO.CharacterType = 1;
for (int i = 0; i < Constants.ringsCount; i++)
{
GO.Buffer[i + 6] = (byte)(ran.Next(0, 3));
}
for (int i = 0; i < Constants.ringsCount; i++)
{
int idx = i * 4 + 50;
byte[] Val = BitConverter.GetBytes(ran.Next(-1100, -800));
Buffer.BlockCopy(Val, 0, GO.Buffer, idx, Val.Length);
}
socket.Send(charactersPool[0].socket, GO.Packet());
//Thread.Sleep(500);
socket.Send(charactersPool[1].socket, GO.Packet());
//Thread.Sleep(500);
socket.Send(charactersPool[0].socket, new GO()
{
SecondCharacter = (byte)charactersPool[1].CharacterType
}.Buffer);
socket.Send(charactersPool[1].socket, new GO()
{
SecondCharacter = (byte)charactersPool[0].CharacterType
}.Buffer);
}
break;
case 1006:
Movement m = new Movement(Packet);
socket.Send(charactersPool[m.ID].socket, m.Buffer);
break;
case 1008:
Respawn r = new Respawn(Packet);
if (r.Change == 1)
{
r.lane = (byte)(ran.Next(0, 3));
}
socket.Send(charactersPool[0].socket, r.Buffer);
break;
}
}
private static void Connect()
{
Task getPrimeNums = new Task(RSA.getPrimeNums);
getPrimeNums.Start();
while (localPort == -1 || remotePort == -1 || remoteIpAddress == "-1")
{
;
}
try
{
listeningSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
Task listeningTask = new Task(Listen);
listeningTask.Start();
byte[] data;
EndPoint remotePoint = new IPEndPoint(IPAddress.Parse(remoteIpAddress), remotePort);
if (!Handshake || !wasGettedKey || !wasGettedN || !wasGettedMainKey)
{
InfoMessage("Waiting for handshacke...");
do
{
Thread.Sleep(1000);
data = Encoding.Unicode.GetBytes("0");
listeningSocket.SendTo(data, remotePoint);
Thread.Sleep(10);
} while (!Handshake);
MyKeys = RSA.getKeys();
InfoMessage("Sending keys...");
do
{
data = Encoding.Unicode.GetBytes(Convert.ToString(MyKeys[0])); //Отправляем N
listeningSocket.SendTo(data, remotePoint);
Thread.Sleep(1000);
} while (!wasGettedN);
do
{
data = Encoding.Unicode.GetBytes(Convert.ToString(MyKeys[1])); //Отправляем e
listeningSocket.SendTo(data, remotePoint);
Thread.Sleep(1000);
} while (!wasGettedKey);
InfoMessage("Connecting...");
do
{
data = Encoding.Unicode.GetBytes(Convert.ToString(PrimeTest.quickMod(
MyMainKey, HerOpenKey[1], HerOpenKey[0])));
listeningSocket.SendTo(data, remotePoint);
Thread.Sleep(1000);
} while(!wasGettedMainKey);
Thread.Sleep(3000);
}
}
catch (Exception ex)
{
InfoMessage(Convert.ToString(ex));
}
InfoMessage("Connected!");
}
public clientInformation(System.Net.Sockets.Socket c, Gtk.TreeIter ti)
{
client = c;
treeIter = ti;
}
private static void Socket_OnNewConnEvent(System.Net.Sockets.Socket S)
{
Console.WriteLine("A new player has joined");
}
/// <summary>
/// 初始一个Socket
/// </summary>
/// <param name="localEP">监听地址</param>
/// <param name="callback">当前接受到新消息时回调</param>
public SocketClient(IPAddress address, int port)
{
this.IsDisposable = false;
IPE = new IPEndPoint(address, port);
Socket = new System.Net.Sockets.Socket(IPE.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
}
TcpSocket(Context context, AddressFamily addressFamily, System.Net.Sockets.Socket socket)
: base(context, addressFamily, socket)
{
}
/// <summary>
/// Instantiates.
/// </summary>
/// <param name="socket">the associated socket</param>
public ListenerContext(System.Net.Sockets.Socket socket)
{
_socket = socket;
}
/// <summary>
/// Instantiates.
/// </summary>
/// <param name="socket">the associated socket</param>
/// <param name="remoteEP">the remote endpoint</param>
/// <param name="sessionInitializer">the funciton to initialize session</param>
public ConnectorContext(System.Net.Sockets.Socket socket, EndPoint remoteEP, Action <IoSession, IConnectFuture> sessionInitializer)
{
_socket = socket;
_remoteEP = remoteEP;
_sessionInitializer = sessionInitializer;
}
/// <summary>
/// Processes incoming requests
/// </summary>
protected void ProcessRequest()
{
// accept an incoming connection request and once we have one, spawn a new thread to accept more
bool newThread = false;
System.Net.Sockets.Socket clientSocket = null;
Responder responder = null;
while (IsRunning && !newThread)
{
try
{
// process incoming request
clientSocket = LocalServer.Accept();
clientSocket.ReceiveTimeout = Timeout;
clientSocket.SendTimeout = Timeout;
// parse message an create an object containing parsed data
responder = new Responder();
responder.ClientEndpoint = clientSocket.RemoteEndPoint.ToString();
responder.ClientSocket = clientSocket;
Thread t = new Thread(new ThreadStart(ProcessRequest));
t.Start();
newThread = true;
}
catch
{
if (clientSocket != null)
{
try
{
clientSocket.Close();
}
catch { }
}
}
}
// now process the request
try
{
bool finishedParsing = false;
TimeSpan parseStart = Timer.GetMachineTime();
while (!finishedParsing)
{
if (Timer.GetMachineTime() - parseStart > MaxProcessingTime)
{
return;
}
// receiving data, add to an array to process later
byte[] buffer = new byte[clientSocket.Available];
clientSocket.Receive(buffer);
finishedParsing = responder.parse(buffer);
}
// trigger event to get response
WebEvent webevent = null;
if (responder.Path != null)
{
webevent = serverManager.GetWebEventById(responder.Path);
}
if (webevent == null)
{
webevent = serverManager.DefaultEvent;
}
responder.webEvent = webevent;
webevent.OnWebEventReceived(responder.Path, responder.HttpMethod, responder);
}
catch
{
}
}
private void Wudp_weaveUpdateSocketListEvent(System.Net.Sockets.Socket soc)
{
SetServerReceiveText("有人加入了");
AllConnectedClient.Add(soc);
}
protected virtual void Initialize(NativeSocket socket)
{
_delegate = socket;
}
// 建構函式
public FTPSession(Socket serverSocket)
{
this.serverSocket = serverSocket;
currentPath = rootPath;
}
public ClientThread(System.Net.Sockets.Socket c, Action <byte[]> callback)
{
client = c;
this.callback = callback;
}
private void Wudp_weaveDeleteSocketListEvent(System.Net.Sockets.Socket soc)
{
SetServerReceiveText("有人退出了");
AllConnectedClient.Remove(soc);
}
public Connection(GameServer server, Socket socket)
{
_socket = socket;
_server = server;
_socket.BeginReceive(buffer, 0, 256, SocketFlags.None, new AsyncCallback(ReceiveData), _socket);
_socket.BeginDisconnect(false, new AsyncCallback(Disconnect), null);
}