PHP Code:
public class SocketClient
{
public SocketClient(Socket socket)
{
Socket = socket;
}
public Socket Socket;
public string IP
{
get
{
try
{
return (Socket.RemoteEndPoint as IPEndPoint).Address.ToString();
}
catch { return ""; }
}
}
public void Disconnect(bool reUse)
{
try
{
Socket.Close();
Socket.Disconnect(reUse);
}
catch (Exception e)
{
Server.ErrorHandler.Handle(e);
}
}
public byte[] Buffer;
public object Owner;
public string AuthAccount;
public string AuthPassword;
public void EndAccept(Socket socket, IAsyncResult result)
{
Socket = socket.EndAccept(result);
}
public bool Connected
{
get { return Socket.Connected; }
}
public int EndReceive(IAsyncResult result, out SocketError SE)
{
return Socket.EndReceive(result, out SE);
}
public ConquerCryption Cryption;
public unsafe void Send(byte[] Packet)
{
try
{
if (Socket.Connected)
{
byte[] Data = new byte[Packet.Length];
fixed (byte* src = Packet, dest = Data)
NativeImports.MSVCRT.MEMCPY(dest, src, Data.Length);
Cryption.Encrypt(Data);
Socket.Send(Data);
}
}
catch (Exception e)
{
Server.ErrorHandler.Handle(e);
}
}
}
PHP Code:
public unsafe class ConquerSockets
{
Socket socket;
int port;
IPEndPoint IPE;
SocketInvoke InvokeHandler;
public ConquerSockets(int Port, SocketInvoke _InvokeHandler)
{
port = Port;
InvokeHandler = _InvokeHandler;
}
public void Listen()
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPE = new IPEndPoint(IPAddress.Parse(Kernel.ServerIP), port);
socket.Bind(IPE);
socket.Listen(100);
}
public void Accept()
{
socket.BeginAccept(new AsyncCallback(Accept), new SocketClient(null));
}
void Accept(IAsyncResult result)
{
try
{
SocketClient Client = result.AsyncState as SocketClient;
Client.Buffer = new byte[1024];
if (!Accepted(Client, result))
Accept();
InvokeHandler.Invoke(Client, ConquerServerProject.Enums.SocketInvokeType.Connection, null);
Accept();
Receive(Client);
}
catch { }
}
public void Receive(SocketClient Client)
{
Client.Socket.BeginReceive(Client.Buffer, 0, 1024, SocketFlags.None, new AsyncCallback(Receive), Client);
}
void Receive(IAsyncResult result)
{
try
{
SocketClient Client = result.AsyncState as SocketClient;
try
{
switch (Client.Connected)
{
case true:
{
SocketError error;
int Len = Client.EndReceive(result, out error);
switch (error)
{
case SocketError.Success:
{
switch (Len)
{
case 0:
InvokeHandler.Invoke(Client, Enums.SocketInvokeType.Disconnection, null);
break;
default:
{
if (Len > 0)//Avoid negative.
{
byte[] Received = new byte[Len];
MEMCPY(Received, Client.Buffer, Len);
InvokeHandler.Invoke(Client, Enums.SocketInvokeType.Receive, Received);
Receive(Client);
}
break;
}
}
break;
}
}
break;
}
case false:
{
InvokeHandler.Invoke(Client, Enums.SocketInvokeType.Disconnection, null);
break;
}
}
}
catch
{
InvokeHandler.Invoke(Client, Enums.SocketInvokeType.Disconnection, null);
}
}
catch (Exception e) { Server.ErrorHandler.Handle(e); }
}
bool Accepted(SocketClient Client, IAsyncResult result)
{
try
{
Client.EndAccept(socket, result);
return true;
}
catch
{
return false;
}
}
void MEMCPY(byte[] Received, byte[] Buffer, int Len)
{
fixed (byte* pointer = Received, buffer = Buffer)
MSVCRT.MEMCPY(pointer, buffer, Len);
}
}
PHP Code:
public delegate void Connection(SocketClient Client);
public delegate void ReceivePacket(SocketClient Client, byte[] Packet);
public delegate void Disconnection(SocketClient Client);
public class SocketInvoke
{
Connection con;
ReceivePacket rec;
Disconnection disc;
public SocketInvoke(Connection connection, ReceivePacket receive, Disconnection disconnection)
{
con = connection;
rec = receive;
disc = disconnection;
}
/// <summary>
/// Invoking socket events.
/// </summary>
/// <param name="Client">The socket client.</param>
/// <param name="invoke">The socket event invoke type.</param>
/// <param name="Packet">The packet to invoke for receive. Can be null for connection & disconnection</param>
public void Invoke(SocketClient Client, Enums.SocketInvokeType invoke, byte[] Packet)
{
switch (invoke)
{
case ConquerServerProject.Enums.SocketInvokeType.Connection:
{
if (con != null)
con.Invoke(Client);
break;
}
case ConquerServerProject.Enums.SocketInvokeType.Receive:
{
if (rec != null)
rec.Invoke(Client, Packet);
break;
}
case ConquerServerProject.Enums.SocketInvokeType.Disconnection:
{
if (disc != null)
disc.Invoke(Client);
break;
}
}
}
}
PHP Code:
public class NetworkProcess_Auth
{
public static void ProcessConnection(SocketClient Client)
{
}
public static void ProcessPacket(SocketClient Client, byte[] Packet)
{
}
public static void ProcessDisconnection(SocketClient Client)
{
}
}
public class NetworkProcess_Game
{
public static void ProcessConnection(SocketClient Client)
{
}
public static void ProcessPacket(SocketClient Client, byte[] Packet)
{
}
public static void ProcessDisconnection(SocketClient Client)
{
}
}
PHP Code:
#region Sockets
ConquerSockets authsocket = new ConquerSockets(Kernel.AuthServerPort, new SocketInvoke(
new Connection(Network.NetworkProcess_Auth.ProcessConnection),
new ReceivePacket(Network.NetworkProcess_Auth.ProcessPacket),
new Disconnection(Network.NetworkProcess_Auth.ProcessDisconnection)));
authsocket.Listen();
authsocket.Accept();
ConquerSockets gamesocket = new ConquerSockets(Kernel.GameServerPort, new SocketInvoke(
new Connection(Network.NetworkProcess_Game.ProcessConnection),
new ReceivePacket(Network.NetworkProcess_Game.ProcessPacket),
new Disconnection(Network.NetworkProcess_Game.ProcessDisconnection)));
gamesocket.Listen();
gamesocket.Accept();
#endregion
PHP Code:
public unsafe class MSVCRT
{
[DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl, SetLastError = false)]
public static extern unsafe void* MEMCPY(void* dest, void* src, int size);
}
PHP Code:
public enum SocketInvokeType
{
Connection,
Receive,
Disconnection
}
Help:
but you could at least point to what's wrong etc.
