public void TryReadMessageTestOneLongMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite.Header.Write(state.buffer, 0);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = SocketStateObject.BufferSize;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = SocketStateObject.BufferSize;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
byteRead = messageToWrite.Header.HeaderLength;
actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
private void ReceiveCallback(IAsyncResult ar)
{
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
Socket socketFd = state.m_SocketFd;
/* read data */
int size = socketFd.EndReceive(ar);
if (size > 0)
{
state.m_StringBuilder.Append(Encoding.ASCII.GetString(state.m_DataBuf, 0, size));
/* get the rest of the data */
socketFd.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0,
new AsyncCallback(ReceiveCallback), state);
}
else
{
/* all the data has arrived */
if (state.m_StringBuilder.Length > 1)
{
string result = state.m_StringBuilder.ToString();
result = result.Replace(",", " ");
result = result.Replace("\n", "\r\n");
setThreadedTextBox(result);
/* shutdown and close socket */
socketFd.Shutdown(SocketShutdown.Both);
socketFd.Close();
}
}
}
private void Listener_AcceptSocketCallback(IAsyncResult ar)
{
Socket soc = null;
try
{
soc = listener.EndAcceptSocket(ar);
if (socketList.Count > ClientListenerMaxOpenSockets)
{
ISLogger.Write("Declining connection from {0}: Max open client sockets reached", soc.RemoteEndPoint);
soc.Dispose();
return;
}
}catch (ObjectDisposedException)
{
//ISLogger.Write("AcceptSocketCallback attempted to access disposed TcpListener");
return;
}
//ISLogger.Write("Accepting connection from {0}", soc.RemoteEndPoint);
socketList.Add(soc);
Timer socTimer = new Timer(SocketTimeoutTimerElapsed, soc, ClientListenerSocketTimeout, Timeout.Infinite);
SocketStateObject syncObj = new SocketStateObject(new byte[ClientListenerSocketBufferSize], soc, socTimer, (IPEndPoint)soc.RemoteEndPoint);
soc.BeginReceive(syncObj.Buff, 0, 4, 0, SocketReceiveCallback, syncObj);
listener.BeginAcceptSocket(Listener_AcceptSocketCallback, null);
}
public override void Connect()
{
try {
// Debugger.Log ("socket2 begin connect");
ReadyState = Connecting;
var state = new SocketStateObject {
udpClient = _udpClient, endPoint = _endPoint
};
_udpClient.Connect(this._url, this._port);
if (_udpClient.Connected())
{
_kcp = new Kcp.Kcp(123, this);
_kcp.SetOutput(OutputKcp);
// fast mode
_kcp.NoDelay(1, 10, 2, 1);
_kcp.WndSize(1024, 1024);
Timer.SetTimer(() => StartKcpUpdate(), Config.K);
this.StartReceive();
ReadyState = Open;
base.onOpen();
}
} catch (Exception e) {
Debugger.Log(e.ToString());
PushError(e);
}
}
private void SendCallback(IAsyncResult ar)
{
try {
setThreadedColor();
/* retrieve the socket from the ar object */
//Socket socketFd = (Socket)ar.AsyncState;
/* end pending asynchronous send */
int bytesSent = socketFd.EndSend(ar);
//MessageBox.Show("Wysłano " + bytesSent.ToString() + " bajtów");
/* create the SocketStateObject */
SocketStateObject state = new SocketStateObject();
state.m_SocketFd = socketFd;
//Console.WriteLine("\t\tSent {0} bytes to the client\n\tEND connection", bytesSent);
socketFd.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(ReceiveCallback), state);
/* shutdown and close socket */
//socketFd.Shutdown(SocketShutdown.Both);
//socketFd.Close();
} catch (Exception exc) {
//Console.WriteLine(exc.Message.ToString());
}
}
//Sprawdza stan przeslanej wiadomosc do serwera, jesli odebrana cala wiadomosc, to czyta odpowiedz serwera
private void SendCallback(IAsyncResult ar)
{
try
{
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
Socket socketFd = state.m_SocketFd;
/* read data */
socket.bytessended = socketFd.EndReceive(ar);
if (socket.bytessended < 15)
{
/* send the rest of the data */
socketFd.BeginSend(state.m_DataBuf, socket.bytessended, SocketStateObject.BUF_SIZE - socket.bytessended, 0, new AsyncCallback(SendCallback), state);
}
else
{
/* all the data sended */
Recive();
}
}
catch (Exception exc)
{
client.NewInfoWidnow("Serwer został rozłączony!\n");
Application.Exit();
}
}
public void TryReadMessageTestTwoCompleteMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[10];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
// Prepare the received buffer
SocketStateObject state = new SocketStateObject();
int offset = messageToWrite1.Header.Write(state.buffer, 0);
offset += fakeBody.Length;
fakeBody = new byte[15];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
offset = messageToWrite2.Header.Write(state.buffer, offset);
offset += fakeBody.Length;
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = offset;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
actual = AbstractMessage.TryReadMessage(message, state, 0);
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
private void StartReceivingThread(SocketStateObject state)
{
new Thread(() =>
{
while (state.Socket.Connected)
{
Receive(state).Wait();
}
}).Start();
}
private void StartReceive()
{
try {
var state = new SocketStateObject {
udpClient = this._udpClient, endPoint = this._endPoint
};
_udpClient.BeginReceive(new AsyncCallback(ReceiveCallback), state);
} catch (Exception e) {
Debugger.Log(e.ToString());
}
}
public async Task <bool> StartListening(int port)
{
return(await Task.Run(async() =>
{
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
m_ListeningSocket = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
m_ListeningSocket.Bind(localEndPoint);
m_ListeningSocket.Listen(100);
Console.WriteLine($"[{Name}] Server online...");
while (m_Run)
{
var socket = m_ListeningSocket.Accept();
Console.WriteLine($"[{Name}] Client connected: " + socket.RemoteEndPoint.ToString());
var state = new SocketStateObject {
Socket = socket
};
// Need to receive proper name. First message should always be the name
await Receive(state);
state.Name = state.LastMessage;
// Add socket state object to the dcitionary or override the old one
if (m_ConnectedSockets.ContainsKey(state.Name))
{
m_ConnectedSockets[state.Name].Socket.Shutdown(SocketShutdown.Both);
m_ConnectedSockets[state.Name].Socket.Close();
m_ConnectedSockets[state.Name] = state;
}
else
{
m_ConnectedSockets.Add(state.Name, state);
}
StartReceivingThread(state);
}
return true;
}
catch (Exception e)
{
Console.WriteLine($"[{Name}][Error] Listening soccket failed to begin accept: " + e.ToString());
return false;
}
}));
}
private void SocketReceiveCallback(IAsyncResult ar)
{
SocketStateObject state = (SocketStateObject)ar.AsyncState;
try
{
Socket soc = state.Soc;
int bytesIn = soc.EndReceive(ar);
int pSize = BitConverter.ToInt32(state.Buff, 0);
if (pSize == 0 | bytesIn == 0)
{
ISLogger.Write("Client {0} lost connection ", soc.RemoteEndPoint);
socketList.Remove(soc);
soc.Dispose();
state.TimeoutTimer.Dispose();
return;
}
int dRem = pSize;
int bPos = 4;
do
{
int bIn = state.Soc.Receive(state.Buff, bPos, dRem, 0);
bPos += bIn;
dRem = pSize - bPos + 4;
} while (dRem > 0);
state.TimeoutTimer.Dispose();
MessageType cmd = (MessageType)state.Buff[4];
if (cmd == MessageType.ClientLoginInfo)
{
//ISLogger.Write("{0} sent login info", soc.RemoteEndPoint);
ClientLoginMessage msg = ClientLoginMessage.FromBytes(state.Buff);
socketList.Remove(soc);
ClientConnected?.Invoke(this, new ClientConnectedArgs(soc, msg.ClientName, msg.ClientGuid));
}
else
{
ISLogger.Write("{0} sent invalid data", soc.RemoteEndPoint);
}
}
catch (ObjectDisposedException) //This is fine, it just means that the socket was disposed by the timeout timer
{
//ISLogger.Write("ClientListener attempted to access disposed socket");
}catch (SocketException)
{
//TODO
}
}
//Odczytuje przeslana wiadomosc od serwera, jesli jakas wiadomosc czeka w kolejce do wyslania to wysyla ja
private void ReceiveCallback(IAsyncResult ar)
{
try
{
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
Socket socketFd = state.m_SocketFd;
/* read data */
int size = socketFd.EndSend(ar);
socket.bytessrecived += size;
if (socket.bytessrecived < 15)
{
/* get the rest of the data */
socketFd.BeginReceive(state.m_DataBuf, socket.bytessended, SocketStateObject.BUF_SIZE - socket.bytessended, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
/* all the data has arrived */
state.m_StringBuilder.Append(Encoding.ASCII.GetString(state.m_DataBuf, 0, size));
servermessage.Enqueue(state.m_StringBuilder.ToString());
if (clientmessage.Count == 0)
{
nowriting = true;
}
else
{
socket.bytessended = 0;
string mess = clientmessage.Dequeue();
socket.m_DataBuf = Encoding.ASCII.GetBytes(mess);
/* begin sending the data */
socket.m_SocketFd.BeginSend(socket.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(SendCallback), socket);
}
if (!unpacking)
{
UnpackMessage();
}
}
}
catch (Exception exc)
{
client.NewInfoWidnow("Serwer został rozłączony!\n");
Application.Exit();
}
}
private void AcceptCallback(IAsyncResult ar)
{
// Signal the main thread to continue.
_acceptCallbackDone.Set();
// Get the socket that handles the client request.
var listener = (Socket)ar.AsyncState;
try
{
var handler = listener.EndAccept(ar);
SignalConnected(handler);
var state = new SocketStateObject(handler);
handler.BeginReceive(state.Buffer, 0, state.Buffer.Length, 0, ReadCallback, state);
}
catch (ObjectDisposedException)
{
// when the socket is closed, an ObjectDisposedException is thrown
// by Socket.EndAccept(IAsyncResult)
}
}
/// <summary>
/// Try to read a message from the buffer.
/// </summary>
/// <param name="message">The destination message</param>
/// <param name="state">The state object</param>
/// <param name="byteRead">The umber of bytes in the input buffer</param>
/// <returns>The message read, otherwise false.</returns>
internal static AbstractMessage TryReadMessage(AbstractMessage message, SocketStateObject state, int byteRead)
{
AbstractMessage messageRead = null;
int moreMessage = 0;
byte[] buffer = state.buffer; // Get buffer
if (state.pendingBuffer != null) //Check for pending data and merge it
{
buffer = new byte[byteRead + state.pendingBuffer.Length];
Array.Copy(state.pendingBuffer, 0, buffer, 0, state.pendingBuffer.Length);
Array.Copy(state.buffer, 0, buffer, state.pendingBuffer.Length, byteRead);
byteRead = buffer.Length;
}
state.pendingBuffer = null;
if (state.message == null)
{
state.message = message;
moreMessage = state.message.ReadFirstMessage(buffer, byteRead);
Trace.WriteLine(string.Format("Receive 1st package MessageUID {0} ClientUID {1}", state.message.MessageUID, state.message.ClientUID));
}
else
{
moreMessage = state.message.AppendBuffer(buffer, byteRead);
Trace.WriteLine(string.Format("Receive more package MessageUID {0} ClientUID {1}", state.message.MessageUID, state.message.ClientUID));
}
if (state.message.IsComplete())
{
Trace.WriteLine(string.Format("Receive complete message {0} len {1}", state.message.MessageUID, state.message.MessageLength));
messageRead = state.message;
Trace.WriteLine(string.Format("Prepare to receive a new message. moreMessage = {0}", moreMessage));
state.message = null;
if (moreMessage > 0)
{
state.pendingBuffer = new byte[byteRead - moreMessage];
Array.Copy(buffer, moreMessage, state.pendingBuffer, 0, state.pendingBuffer.Length);
Trace.WriteLine(string.Format("Copy {0} bytes to pending buffer", state.pendingBuffer.Length));
}
}
return(messageRead);
}
private void AcceptCallback(IAsyncResult ar)
{
// Signal the main thread to continue.
_acceptCallbackDone.Set();
// Get the socket that handles the client request.
var listener = (Socket)ar.AsyncState;
try
{
var handler = listener.EndAccept(ar);
SignalConnected(handler);
var state = new SocketStateObject(handler);
handler.BeginReceive(state.Buffer, 0, state.Buffer.Length, 0, ReadCallback, state);
}
catch (ObjectDisposedException)
{
// when the socket is closed, an ObjectDisposedException is thrown
// by Socket.EndAccept(IAsyncResult)
}
}
private void ConnectCallback(IAsyncResult ar)
{
/* retrieve the socket from the state object */
Socket socketFd = (Socket)ar.AsyncState;
/* complete the connection */
socketFd.EndConnect(ar);
/* send data */
SendData(socketFd); ////////////////aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
/* create the SocketStateObject */
SocketStateObject state = new SocketStateObject();
state.m_SocketFd = socketFd;
/* begin receiving the data */
socketFd.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0,
new AsyncCallback(ReceiveCallback), state);
/////////aaaaaaaaaaaaaaaaaaaaaaaaaaa
}
//Uzyskuje socket i wysyla pierwsza wiadomosc (login)
public void ConnectCallback(IAsyncResult ar)
{
try
{
/* retrieve the socket from the state object */
Socket socketFd = (Socket)ar.AsyncState;
/* complete the connection */
socketFd.EndConnect(ar);
/* create the SocketStateObject */
socket = new SocketStateObject();
socket.m_SocketFd = socketFd;
this.client.LoginFormEnd();
client.setButton(client.NewGameButton, true);
PreaperMessageCI(10, client.clientnick);
}
catch (Exception exc)
{
this.client.login.setButton(true);
this.client.login.setLogginErrorLabel(true);
}
}
public void TryReadMessageTestOneLongOneShortMessage()
{
// Create a message to write as received in buffer
byte[] fakeBody = new byte[SocketStateObject.BufferSize * 2];
AbstractMessage messageToWrite1 = new BasicMessage(Guid.NewGuid(), fakeBody);
fakeBody = new byte[50];
AbstractMessage messageToWrite2 = new BasicMessage(Guid.NewGuid(), fakeBody);
byte[] bufferToSend = new byte[messageToWrite1.MessageLength + messageToWrite2.MessageLength];
int offset = messageToWrite1.Header.Write(bufferToSend, 0);
offset += messageToWrite1.GetBuffer().Length;
offset = messageToWrite2.Header.Write(bufferToSend, offset);
offset += messageToWrite2.GetBuffer().Length;
// Read per block
int readOffset = 0;
int counter = 0;
SocketStateObject state = new SocketStateObject();
while (readOffset < bufferToSend.Length)
{
int size = ((bufferToSend.Length - readOffset) > SocketStateObject.BufferSize) ?
SocketStateObject.BufferSize : (bufferToSend.Length - readOffset);
// Prepare the received buffer
Array.Copy(bufferToSend, readOffset, state.buffer, 0, size);
// Call the TryRead
AbstractMessage message = new BasicMessage();
int byteRead = size;
AbstractMessage actual = AbstractMessage.TryReadMessage(message, state, byteRead);
switch (counter)
{
case 0:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 1:
Assert.IsNull(actual);
Assert.IsNotNull(state.message);
Assert.IsNull(state.pendingBuffer);
break;
case 2:
Assert.IsNotNull(actual);
Assert.AreEqual(actual.MessageLength, messageToWrite1.MessageLength);
Assert.IsNull(state.message);
Assert.IsNotNull(state.pendingBuffer);
break;
}
counter++;
readOffset += size;
}
AbstractMessage message2 = new BasicMessage();
AbstractMessage actual2 = AbstractMessage.TryReadMessage(message2, state, 0);
Assert.IsNotNull(actual2);
Assert.AreEqual(actual2.MessageLength, messageToWrite2.MessageLength);
Assert.IsNull(state.message);
Assert.IsNull(state.pendingBuffer);
}
private void AcceptCallback(IAsyncResult ar)
{
// Signal the main thread to continue
_acceptCallbackDone.Set();
// Get the socket that listens for inbound connections
var listener = (Socket)ar.AsyncState;
// Get the socket that handles the client request
Socket handler;
try
{
handler = listener.EndAccept(ar);
}
catch (ObjectDisposedException ex)
{
// The listener is stopped through a Dispose() call, which in turn causes
// Socket.EndAccept(IAsyncResult) to throw an ObjectDisposedException
//
// Since we consider this ObjectDisposedException normal when the listener
// is being stopped, we only write a message to stderr if the listener
// is considered to be up and running
if (_started)
{
Console.Error.WriteLine("[{0}] Failure accepting new connection: {1}",
typeof(AsyncSocketListener).FullName,
ex);
}
return;
}
// Signal new connection
SignalConnected(handler);
lock (_syncLock)
{
// Register client socket
_connectedClients.Add(handler);
}
var state = new SocketStateObject(handler);
try
{
handler.BeginReceive(state.Buffer, 0, state.Buffer.Length, 0, ReadCallback, state);
}
catch (ObjectDisposedException ex)
{
// The listener is stopped through a Dispose() call, which in turn causes
// Socket.BeginReceive(...) to throw an ObjectDisposedException
//
// Since we consider this ObjectDisposedException normal when the listener
// is being stopped, we only write a message to stderr if the listener
// is considered to be up and running
if (_started)
{
Console.Error.WriteLine("[{0}] Failure receiving new data: {1}",
typeof(AsyncSocketListener).FullName,
ex);
}
}
}
private void ReceiveCallback(IAsyncResult ar)
{
try
{
/* retrieve the SocketStateObject */
state = (SocketStateObject)ar.AsyncState;
Socket socketFd = state.m_SocketFd;
/* read data */
int size = socketFd.EndReceive(ar);
//Console.Out.WriteLine("Read data");
if (size > 0)
{
state.m_StringBuilder.Append(Encoding.ASCII.GetString(state.m_DataBuf, 0, size));
//reszta danych
if (!(state.m_StringBuilder.ToString().IndexOf("<end>") > 0))
{
socketFd.BeginReceive(state.m_DataBuf, 0, state.m_DataBuf.Length, 0,
new AsyncCallback(ReceiveCallback), state);
}
}
if(state.m_StringBuilder.ToString().IndexOf("<end>") > 0)
{
if (state.m_StringBuilder.Length > 1)
{
Console.Out.WriteLine(state.m_StringBuilder.ToString());
/* all the data has arrived */
if (state.m_StringBuilder.ToString().IndexOf("<new_message>") == 0)//znalazł wzorzec
{
String tochat = state.m_StringBuilder.ToString().Remove(0, 14);
tochat = tochat.Remove(tochat.Length - 5, 5);
String roomname = tochat.Substring(tochat.IndexOf("<")+1,tochat.Length-tochat.IndexOf("<")-2);
tochat=tochat.Substring(0,tochat.IndexOf("<")-1);
Boolean insideRoom = false;
foreach (Room room in UserInsideRooms)
{
if(room.Name==roomname)
{
insideRoom = true;
break;
}
}
if (insideRoom == true)
{
dodajChat(tochat);
setThreadedChat();
//Console.Out.WriteLine(ActualRoom.ChatText);
if (roomname != ActualRoom.Name)
//dodajemy powiadomienie że coś nowego
{
foreach (Room room in Rooms)
{
if (roomname == room.Name)
{
dodajChat(tochat);
room.NewMessages = IRC.Room.inside.TAK;//nowe wiadomośći w tym pokoju
break;
}
}
}
}
}
else if (state.m_StringBuilder.ToString().IndexOf("<room_list>") == 0)
{
String roomlist = state.m_StringBuilder.ToString().Remove(0, 11);
int x = 0;
String roomname = String.Empty;
int roomOccupancy = 0;
bool koniec = false;
foreach (string s in roomlist.Split('>'))
{
//Console.Out.WriteLine(s);
if (s == "<end")
{ koniec = true; }
if (koniec == false)
{
String s1 = s.Remove(0, 1);
if (x % 2 == 0)
{ roomname = s1; }
else { roomOccupancy = Int32.Parse(s1); }
if (x % 2 != 0)
{
Room NewRoom = new Room(roomname, roomOccupancy);
Channels.Dispatcher.BeginInvoke(new Action(delegate()
{
Rooms.Add(NewRoom);
Channels.ItemsSource = null;
Channels.ItemsSource = Rooms;
}));
}
x++;
}
}
}
else if (state.m_StringBuilder.ToString().IndexOf("<new_room>") == 0)
{
Console.Out.WriteLine(state.m_StringBuilder.ToString());
String roomlist = state.m_StringBuilder.ToString().Remove(0, 10);
int x = 0;
String roomname = String.Empty;
int roomOccupancy = 0;
bool koniec = false;
foreach (string s in roomlist.Split('>'))
{
Console.Out.WriteLine(s);
if (s == "<end")
{ koniec = true; }
if (koniec == false)
{
String s1 = s.Remove(0, 1);
if (x % 2 == 0)
{ roomname = s1; }
else { roomOccupancy = Int32.Parse(s1); }
}
x++;
}
bool juzistnieje=false;
foreach(Room room in Rooms)
{
if(room.Name==roomname)
{ juzistnieje = true; }
}
if(juzistnieje==false)
{
Room NewRoom = new Room(roomname, roomOccupancy);
Channels.Dispatcher.BeginInvoke(new Action(delegate ()
{
Rooms.Add(NewRoom);
Channels.ItemsSource = null;
Channels.ItemsSource = Rooms;
}));
Console.Out.WriteLine(NewRoom.Name);
}
}
}
state.m_StringBuilder.Clear(); //po odczytaniu czyścimy
Console.Out.WriteLine("Czytam kolejną wiadomość");
ReadData();
}
}
catch (Exception exc)
{
MessageBox.Show("Exception Receive Callback :\t\n" + exc.Message.ToString());
setThreadedTextBox("Wyjdź z serwera i spróbuj ponownie!");
}
}
private static void recvPacket()
{
if (serverSocket == null || ! serverSocket.Connected) {
setCurrentState(ConnectionState.Disconnected);
return;
}
SocketStateObject sso = new SocketStateObject(serverSocket, null);
sso.socket.BeginReceive(sso.buffer, 0, sso.buffer.Length, 0, new AsyncCallback(ProcessReceive), sso);
setCurrentState(ConnectionState.Receiving);
}
private static void tryConnect() {
if (!initialized)
return;
if (serverSocket != null) {
// we need to disconnect the current connection;
try {
serverSocket.Shutdown(SocketShutdown.Both);
serverSocket.Close();
} catch (Exception e) {
serverSocket = null;
}
}
IPHostEntry ipHostInfo = Dns.Resolve(serverAddress);
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(ipAddress,serverPort);
// Create a TCP/IP socket.
serverSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp );
SocketStateObject sso = new SocketStateObject(serverSocket, null);
serverSocket.BeginConnect(remoteEP, new AsyncCallback(ProcessConnect), sso);
setCurrentState(ConnectionState.Connecting);
}
private static void sendPacket(string data)
{
if (serverSocket == null || ! serverSocket.Connected) {
setCurrentState(ConnectionState.Disconnected);
return;
}
SocketStateObject sso = new SocketStateObject(serverSocket, data + "\n\n");
sso.socket.BeginSend(sso.buffer, 0, sso.buffer.Length, 0, new AsyncCallback(ProcessSend), sso);
// Debug.Log ("Sending: " + data);
setCurrentState(ConnectionState.Sending);
}
/*
*
* Asynchroniczna obsluga polaczenia REPConnection
*
*/
private void ReceiveCallbackREP(IAsyncResult ar)
{
try {
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
//Socket socketFd = state.m_SocketFd;
/* read data */
int size = socketFdREP.EndReceive(ar);
// dla bufora jednobajtowego
bool end = false;
if (state.start)
{
if (state.m_DataBuf[0] != 0)
{
state.start = false;
setThreadedColor();
//MessageBox.Show(colorCount.ToString());
}
}
if (!state.start)
{
setThreadedColor();
state.m_MemoryStream.Write(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE);
if (state.m_DataBuf[0] == DataConst.endInOutBufferByte)
{
state.endCounter++;
if (state.endCounter == DataConst.endInOutBufferSize)
{
end = true;
}
}
else
{
state.endCounter = 0;
}
}
if (!end)
{
/* get the rest of the data */
socketFdREP.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(ReceiveCallbackREP), state);
}
else
{
stopWatchREP.Stop();
byte[] bytes = state.m_MemoryStream.ToArray();
if (DataConst.DEBUG)
{
}
// MessageBox.Show(Conversions.BytesToStringHex(bytes));
/* all the data has arrived */
// koniec transmisji danych odbiorczych
if (bytes.Length > 0)
{
//MessageBox.Show(Conversions.BytesToStringHex( Conversions.CharArrayToBytes(state.m_StringBuilder.ToString().ToCharArray())));
fromServerBufferREP = new FromServerBuffer(bytes);
//MessageBox.Show(Conversions.BytesToStringHex(fromServerBufferREP.bytes));
//MessageBox.Show(fromServerBufferREP.serverInfo.ToString());
if (fromServerBufferREP.orderCode == OrderCode.eServerData)
{
setThreadedTime();
setThreadedInsertRow(fromServerBufferREP.serverInfo);
}
else
{
setThreadedStatusLabel("Niepoprawna odpowiedź serwera");
}
// nalezy dodac zapetlenie
state.m_MemoryStream = new MemoryStream();
state.endCounter = 0;
state.start = true;
socketFdREP.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(ReceiveCallbackREP), state);
}
}
} catch (Exception exc) {
if (DataConst.DEBUG)
{
MessageBox.Show("Wyjątek:\t\n" + exc.Message.ToString());
}
setThreadedStatusLabel("Błąd odczytu danych połaczeń z serwera");
}
}
private void ConnectCallback(IAsyncResult ar)
{
try
{
/* retrieve the socket from the state object */
socketFd = (Socket)ar.AsyncState;
Console.Out.WriteLine("ConnectCallback");
/* complete the connection */
socketFd.EndConnect(ar);
state=new SocketStateObject();
state.m_SocketFd = socketFd;
setThreadedTextBox("Czekaj, odbieranie danych z serwera!");
Console.Out.WriteLine("Odbieranie danych");
/* begin receiving the data */
if(isConnected==false)
{//SendDate(state, user.Nick, "<new_user>");
isConnected = true;
}
ReadData();
}
catch (Exception exc)
{
MessageBox.Show("Exception: ConnectCallback \t\n" + exc.Message.ToString());
setThreadedTextBox("Wyjdź z serwera i spróbuj ponownie!");
}
}
/*
*
* Asynchroniczna obsluga polaczenia NormalConnection
*
*/
private void ReceiveCallback(IAsyncResult ar)
{
try {
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
/* read data */
int size = socketFd.EndReceive(ar);
// dla bufora jednobajtowego
bool end = false;
if (state.m_DataBuf[0] == DataConst.endInOutBufferByte)
{
state.endCounter++;
if (state.endCounter == DataConst.endInOutBufferSize)
{
end = true;
}
}
else
{
state.endCounter = 0;
}
if (state.start)
{
if (state.m_DataBuf[0] != 0)
{
state.start = false;
setThreadedColor();
//MessageBox.Show(colorCount.ToString());
}
}
if (!state.start)
{
setThreadedColor();
state.m_MemoryStream.Write(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE);
if (state.m_DataBuf[0] == DataConst.endInOutBufferByte)
{
state.endCounter++;
if (state.endCounter == DataConst.endInOutBufferSize)
{
end = true;
}
}
else
{
state.endCounter = 0;
}
}
if (!end)
{
/* get the rest of the data */
socketFd.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
stopWatch.Stop();
/* all the data has arrived */
// koniec transmisji danych odbiorczych
byte[] bytes = state.m_MemoryStream.ToArray();
if (DataConst.DEBUG)
{
MessageBox.Show(Conversions.BytesToStringHex(bytes));
}
if (bytes.Length > 0)
{
setThreadedConnectionTime((int)stopWatch.ElapsedMilliseconds);
fromServerBuffer = new FromServerBuffer(bytes);
switch (fromServerBuffer.orderCode)
{
case OrderCode.eMaxPing: {
if (fromServerBuffer.orderResponse == 0)
{
setThreadedStatusLabel("Aktualizowano maksymalny ping do " + toServerBuffer.maxPing + " ms");
}
else
{
setThreadedStatusLabel("Błąd podczas ustawienia maksymalnego pingu " + toServerBuffer.maxPing);
}
} break;
// //TODO obsluga startu watku odbierania danych
case OrderCode.eLogin: {
if (fromServerBuffer.orderResponse == 0)
{
setThreadedStatusLabel("Logowanie zakończone po " + stopWatch.ElapsedMilliseconds.ToString() + " ms");
if (this.InvokeRequired)
{
this.Invoke((MethodInvoker) delegate
{
this.timerDelayInfo.Enabled = true;
});
}
}
else
{
setThreadedStatusLabel("Błąd podczas logowania");
}
}
break;
// zakonczono testy
case OrderCode.eLogout: {
//CloseREP();
if (fromServerBuffer.orderResponse == 0)
{
if (this.InvokeRequired)
{
this.Invoke((MethodInvoker) delegate {
CloseREP();
this.Close();
});
}
}
else
{
setThreadedStatusLabel("Błąd podczas wylogowania");
}
}
break;
case OrderCode.eAddServer: {
if (fromServerBuffer.orderResponse == 0)
{
setThreadedStatusLabel("Dodano serwer " + oPDomain + " o porcie " + oPPort);
}
else
{
setThreadedStatusLabel("Błąd podczas dodania serwera " + oPDomain + " o porcie " + oPPort);
}
} break;
case OrderCode.eDeleteServer: {
if (fromServerBuffer.orderResponse == 0)
{
setThreadedStatusLabel("Usunięto serwer " + oPDomain + " o porcie " + oPPort);
setThreadedClearDataRecords();
}
else
{
setThreadedStatusLabel("Błąd podczas usuwania serwera " + oPDomain + " o porcie " + oPPort);
}
} break;
case OrderCode.eDeleteAllServers: {
if (fromServerBuffer.orderResponse == 0)
{
setThreadedStatusLabel("Usunięto wszystkie serwery");
setThreadedClearDataRecords();
}
else
{
setThreadedStatusLabel("Błąd podczas usuwania wszystkich serwerow");
}
}
break;
default: {
setThreadedStatusLabel("Niepoprawna odpowiedź serwera");
} break;
}
/* shutdown and close socket */
try {
socketFd.Shutdown(SocketShutdown.Both);
socketFd.Close();
} catch { }
}
}
} catch (Exception exc) {
//MessageBox.Show("Wyjątek:\t\n" + exc.Message.ToString());
setThreadedStatusLabel("Błąd odczytu danych z serwera");
}
}
public void SendDate(SocketStateObject state,String text,String co)
{
try
{
//this.state = state;
//state.m_DataBuf = Encoding.ASCII.GetBytes(String.Empty);
/* wstaw stringa do bufora */
// state.m_DataBuf = Encoding.ASCII.GetBytes(co + text + "<end>");
//Console.Out.WriteLine(Encoding.ASCII.GetString(state.m_DataBuf, 0, state.m_DataBuf.Length));
setThreadedTextBox("Wszystko OK!");
/* begin sending the date */
// state.m_SocketFd.BeginSend(state.m_DataBuf, 0, state.m_DataBuf.Length, 0,
// new AsyncCallback(SendCallback), state.m_SocketFd);
//state.m_DataBuf = Encoding.ASCII.GetBytes(String.Empty);
// setThreadedMessage(String.Empty);
}
catch (Exception exc)
{
Console.WriteLine("Send Data exception, "+exc.Message.ToString());
}
}
/*
*
* Asynchroniczna obsluga polaczenia
*
*/
private void ReceiveCallback(IAsyncResult ar)
{
try {
/* retrieve the SocketStateObject */
SocketStateObject state = (SocketStateObject)ar.AsyncState;
//Socket socketFd = state.m_SocketFd;
/* read data */
int size = socketFd.EndReceive(ar);
// dla bufora jednobajtowego
bool end = false;
state.m_MemoryStream.Write(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE);
if (state.m_DataBuf[0] == DataConst.endInOutBufferByte)
{
state.endCounter++;
if (state.endCounter == DataConst.endInOutBufferSize)
{
end = true;
}
}
else
{
state.endCounter = 0;
}
if (!end)
{
//state.m_MemoeyStream.Append(Encoding.u .GetString(state.m_DataBuf, 0, size));
/* get the rest of the data */
socketFd.BeginReceive(state.m_DataBuf, 0, SocketStateObject.BUF_SIZE, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
stopWatch.Stop();
byte[] bytes = state.m_MemoryStream.ToArray();
if (DataConst.DEBUG)
{
MessageBox.Show(Conversions.BytesToStringHex(bytes));
}
/* all the data has arrived */
// koniec transmisji danych odbiorczych
if (bytes.Length > 0)
{
fromServerBuffer = new FromServerBuffer(bytes);
if (fromServerBuffer.orderCode == OrderCode.eConnection)
{
setThreadedConnectButton(true);
setThreadedStatusLabel("Test zakończony pomyślnie po " + stopWatch.ElapsedMilliseconds.ToString() + " ms");
}
else
{
setThreadedConnectButton(true);
setThreadedStatusLabel("Niepoprawna odpowiedź serwera");
}
//MessageBox.Show(Conversions.BytesToStringHex(fromServerBuffer.bytes));
/* shutdown and close socket */
socketFd.Shutdown(SocketShutdown.Both);
socketFd.Close();
}
}
} catch (Exception exc) {
if (DataConst.DEBUG)
{
MessageBox.Show("Wyjątek:\t\n" + exc.Message.ToString());
}
setThreadedStatusLabel("Błąd odczytu danych z serwera");
setThreadedConnectButton(false);
}
}
