/// <summary>
/// 当有数据到达时
/// </summary>
/// <param name="data"></param>
/// <param name="actualSize"></param>
public void AddData(byte[] data, int actualSize)
{
SocketData socketdata = new SocketData();
socketdata.data = data;
socketdata.actualSize = actualSize;
mQueue.Enqueue(socketdata);
}
public void ctor_WithData_ReturnsData()
{
var bytes = Encoding.Default.GetBytes("Mein Test");
var socketData = new SocketData(bytes);
Assert.NotNull(socketData);
Assert.Equal(bytes, socketData.Data);
}
public static ReceiveGatewayData CreateJson(SocketData data)
{
ReceiveGatewayData res;
if (data.MessageType == WebSocketMessageType.Close)
{
res = null;
}
else
{
res = new ReceiveGatewayData();
var j = JsonConvert.DeserializeObject <GatewayJson>(data.GetText());
res.OpCode = j.op;
// ReSharper disable once SwitchStatementMissingSomeCases (default case exists)
switch (res.OpCode)
{
case GatewayOpCode.Dispatch:
res.Sequence = (int)j.s;
res.EventName = j.t;
res.Data = GatewayEvent.Create(j.t, j.d);
break;
case GatewayOpCode.Heartbeat:
res.Data = ((JValue)j.d).Value;
break;
case GatewayOpCode.Hello:
res.Data = new GatewayHelloData((JObject)j.d);
break;
case GatewayOpCode.InvalidSession:
res.Data = (bool)((JValue)j.d).Value;
break;
case GatewayOpCode.Reconnect:
case GatewayOpCode.HeartbeatAck:
res.Data = null;
break;
default:
throw new UnknownOpCodeException("Gateway op code " + (int)j.op + " is either invalid in a recieve context or is undefined.");
}
}
return(res);
}
public static void Reconnect(WebSocketSession session, SocketData socketData)
{
string key = socketData.data["key"].ToString();
Users userInfo = ServiceProvider.Instance <IUsersService> .Create.GetUserByKey(key);
if (userInfo == null)
{
Log.Info("Can't find user. key:" + key);
return;
}
WebSocketSession findOnlineUser = SessionPool.Get(userInfo.Id);
ServiceProvider.Instance <IUsersService> .Create.UpdateLoginDate(DateTime.Now, userInfo.Id);
ServiceProvider.Instance <IUsersService> .Create.UpdateLoginKey(userInfo.Id);
userInfo = ServiceProvider.Instance <IUsersService> .Create.GetUser(userInfo.Id);
if (findOnlineUser != null)
{
SessionPool.Remove(userInfo.Id);
}
SocketData sendData = new SocketData()
{
cmd_id = MainProtocol.LoginCheckIn, msg = "登录成功"
};
sendData.SetData(new
{
user_id = userInfo.Id,
key = userInfo.Key
});
session.Nick = userInfo.Nick;
session.UserId = userInfo.Id;
session.Photo = userInfo.Photo;
session.ConnectTime = DateTime.Now;
SessionPool.Add(session);
session.Send(sendData);
}
public void btnSendData_Click(System.Object sender, System.EventArgs e)
{
try
{
if (this.CfDataManagerContainer1.DataCount <= 0)
{
throw (new Exception("No data to select"));
}
SocketData dat = this.CfDataManagerContainer1.SelectedData;
this._dataSocketClient.SendDataToServer(dat);
this._dataSendCount++;
this.SetTextBoxText(this.txtDataSendedCounter, System.Convert.ToString(this._dataSendCount));
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void Listen()
{
Thread listenThread = new Thread(() =>
{
try
{
SocketData data = (SocketData)socket.Receive();
ProcessData(data);
}
catch (Exception)
{
}
});
listenThread.IsBackground = true;
listenThread.Start();
}
private void ClientThread(object cli)
{
player newPlayer = (player)cli;
//xử lý truyền nhận
try
{
do
{
//nhận dữ liệu từ player 1
SocketData temp = (SocketData)newPlayer.Player1Socket.Receive();
//xử lý dữ liệu ở đây !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if (temp.Command == (int)SocketCommand.QUIT)
{
//cap nhat giao dien
tbLog.AppendText("\r\n" + newPlayer.Player1Socket.client.RemoteEndPoint + " QUIT!!!");
foreach (String item in lbPlayer.Items)
{
if (item == newPlayer.Player1Socket.client.RemoteEndPoint.ToString())
{
lbPlayer.Items.Remove(item);
//xoa khoi danh sach
erasePlayer(newPlayer);
break;
}
}
}
else if (temp.Command == (int)SocketCommand.END_GAME)
{
newPlayer.Player2Socket.Send(new SocketData((int)SocketCommand.END_GAME, "Đã 5 con trên một hàng\r\n" + newPlayer.Player1Socket.client.RemoteEndPoint.ToString() + "\r\nWIN!!!", new Point()));
newPlayer.Player1Socket.Send(new SocketData((int)SocketCommand.END_GAME, "Đã 5 con trên một hàng\r\n" + newPlayer.Player1Socket.client.RemoteEndPoint.ToString() + "\r\nWIN!!!", new Point()));
}
else
{
//chuyển dữ liệu cho player 2
newPlayer.Player2Socket.Send(temp);
}
} while (true);
}
catch (Exception)
{
}
}
/// <summary>
/// Gửi tin khi nhấn nút send ( LAN)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSendMessage_Click(object sender, EventArgs e)
{
if (btnSendMessage.Text == "Kết nối")
{
btnPlay.Enabled = true;
btnSendMessage.Text = "Gửi tin";
socket.IP = tbmess.Text;
Mode1AndMode2.namePlayer = "Player black";
if (!socket.ConnectServer())
{
socket.CreateServer();
Mode1AndMode2.namePlayer = "Player white";
}
Thread listenThread = new Thread(() =>
{
while (true)
{
Thread.Sleep(500);
try
{
Listen();
// break;
}
catch
{
}
}
});
listenThread.IsBackground = true;
listenThread.Start();
}
else
{
string mess = Mode1AndMode2.namePlayer + " : " + tbmess.Text;
ListViewItem lvi = new ListViewItem(mess);
lvChat.Items.Add(lvi);
SocketData data = new SocketData((int)TypeData.GUI_TIN, mess, Mode1AndMode2.moveLAN);
socket.Send(data);
tbmess.Clear();
}
}
public static int Wrap(byte[] buf, int offset, SocketData sockData)
{
// marker
WriteByte(buf, PackageBreaker, ref offset);
// handle id
WriteShort(buf, sockData.handleId, ref offset);
// version
WriteByte(buf, sockData.version, ref offset);
// data size
WriteInt(buf, sockData.data.Length, ref offset);
// data
Array.Copy(sockData.data, 0, buf, offset, sockData.data.Length);
offset += sockData.data.Length;
// crc
WriteUInt32(buf, sockData.GetCRC(), ref offset);
// marker
WriteByte(buf, PackageBreaker, ref offset);
return(offset);
}
//Hàm lắng nghe
void Listen()
{
//Cho việc listen nằm ra một luồng riêng
Thread listenThread = new Thread(() =>
{
//Cố gắng nhận dữ liệu từ server
try
{
SocketData data = (SocketData)socket.Reveive();
ProcessData(data);
}
catch
{
}
});
listenThread.IsBackground = true;
listenThread.Start();
}
public void tmrAutoBroadCast_Tick(System.Object sender, System.EventArgs e)
{
try
{
IEnumerator enumm = default(IEnumerator);
enumm = this.lstAutoBroadCast.Items.GetEnumerator();
SocketData sockdat = default(SocketData);
while (enumm.MoveNext())
{
sockdat = (CommunicationsLibrary.Services.SocketsDataDistribution.Data.SocketData)enumm.Current;
this._dataBroadCastedCounter++;
this.txtAutoBroadCastCounter.Text = this._dataBroadCastedCounter.ToString();
this._DataSocketServer.BroadCastData(sockdat);
}
}
catch (Exception)
{
}
}
public void tmrInteger_Tick(System.Object sender, System.EventArgs e)
{
try
{
IEnumerator enumm = default(IEnumerator);
enumm = this.CfDataManagerContainer1.GetEnumerator();
SocketData sockdat = default(SocketData);
while (enumm.MoveNext())
{
sockdat = (SocketData)enumm.Current;
this._dataSocketClient.SendDataToServer(sockdat);
this._dataSendCount++;
this.SetTextBoxText(this.txtDataSendedCounter, System.Convert.ToString(this._dataSendCount));
}
}
catch (Exception)
{
}
}
private void btnPlay_Click(object sender, EventArgs e)
{
//neu dang o che do danh qua LAN thu truyen cho ben kia biet da bat dau
if (Mode1AndMode2.modeplay == 3)
{
SocketData data = new SocketData((int)TypeData.START, "start", Mode1AndMode2.moveLAN);
socket.Send(data);
}
StartGame(ChessPieceSide.WHITE);
// MessageBox.Show("da send click");
btnPlay.Visible = false;
//danh voi may thi khong can xai processbar player
//if (modeplay == 2)
// return;
//timerProcessbarPlayer.Start();
}
/// <summary>
///
/// </summary>
private void StartReading()
{
Console.WriteLine(this.server_name + " StartReading");
try {
if (this.ConnectionSocket == null)
{
Console.WriteLine(this.server_name + " ConnectionSocket NULL");
return;
}
SocketData s = new SocketData(this.ConnectionSocket, 2048); //MsConf.Instance.NetworkDataReadSize
if (this.ConnectionSocket != null)
{
Console.WriteLine("Socket BeginReceiveFrom");
this.ConnectionSocket.BeginReceiveFrom(s.Buffer, 0, s.Buffer.Length, SocketFlags.None, ref s.RemoteEndPoint, new AsyncCallback(ReceivedCallback), s);
}
} catch (Exception ex) {
Console.WriteLine(String.Concat(Assembly.GetExecutingAssembly().GetName().Name, Dns.GetHostName(), ex.Message, ex.StackTrace));
}
}
private void OnReadPacketComplete(int opaque, long sessionId, byte[] buffer, int packetSize)
{
SocketData data = new SocketData();
data.connection = sessionId;
data.buffer = Convert.ToBase64String(buffer);
Message msg = new Message();
msg.Source = 0;
msg.Destination = opaque;
msg.Method = "SocketData";
msg.Data = data.encode();
msg.RPCSession = 0;
msg.Type = MessageType.Socket;
ServiceContext service = ServiceSlots.GetInstance().Get(opaque);
service.Push(msg);
}
public SocketData receive()
{
byte[] data = new byte[79000000];
try
{
ClientSocket.Receive(data);
}
catch (Exception e)
{
Console.WriteLine(e);
ClientSocket.Close();
}
SocketData d = (SocketData)ChatAppUtils.Deserialize(data);
if (d == null)
{
return(new SocketData("NULLDATA", null));
}
return(d);
}
public void btnSendData_Click(System.Object sender, System.EventArgs e)
{
try
{
if (this.CFDataManagerCointainer1.DataCount <= 0)
{
throw (new Exception("No data available to send"));
}
SocketData data = this.CFDataManagerCointainer1.SelectedData;
if (!(data == null))
{
SocketsServerClientConnectionHandler client = this.GetSelectedClient();
this._DataSocketServer.SendDataToClient(client, data);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public static Boolean TryParse(SocketData incommingData, out MachineStatusData resultdata)
{
if (incommingData.DataName == MachineStatusData.MESSAGE_ID)
{
string lineName = "";
string machineName = "";
string statusAsString = "";
//we use the custom hashtable that is transportd in the socketData and not the native attributes table
CustomHashTable _table = (CustomHashTable)incommingData.Value;
if (
_table.ContainsKey(MachineStatusData.LINE_NAME)
&&
_table.ContainsKey(MachineStatusData.MACHINE_NAME)
&&
_table.ContainsKey(MachineStatusData.MACHINE_STATUS)
)
{
lineName = (string)_table.Item(MachineStatusData.LINE_NAME);
machineName = (string)_table.Item(MachineStatusData.MACHINE_NAME);
statusAsString = (string)_table.Item(MachineStatusData.MACHINE_STATUS);
MachineStatus status = GetStatusFromString(statusAsString);
resultdata = new MachineStatusData(lineName, machineName, status);
//pending to implement
return(true);
}
else
{
//it is not possible to parse as the ALDS data type requiered
resultdata = null;
return(false);
}
}
else
{
resultdata = null;
return(false);
}
}
private dynamic GetSocketData(Data data)
{
SocketData sockDat = default(SocketData);
string dataType = data.data.GetType().ToString();
switch (dataType)
{
case "System.String":
sockDat = new SocketData(data.DataName, System.Convert.ToString(data.data));
break;
case "System.Int32":
sockDat = new SocketData(data.DataName, System.Convert.ToInt32(data.data));
break;
case "System.Decimal":
sockDat = new SocketData(data.DataName, System.Convert.ToDecimal(data.data));
break;
case "System.Boolean":
sockDat = new SocketData(data.DataName, System.Convert.ToBoolean(data.data));
break;
case "System.Data.DataTable":
sockDat = new SocketData(data.DataName, (DataTable)data.data);
break;
case "UtilitiesLibrary.Data.CustomHashTable":
sockDat = new SocketData(data.DataName, (CustomHashTable)data.data);
break;
case "UtilitiesLibrary.Data.CustomList":
sockDat = new SocketData(data.DataName, (CustomList)data.data);
break;
case "UtilitiesLibrary.Data.CustomSortedList":
sockDat = new SocketData(data.DataName, (CustomSortedList)data.data);
break;
}
return(sockDat);
}
private void ReceiveCallbackEx <T>(IAsyncResult ar) where T : HttpMessage, new()
{
try
{
SocketData <T> state = (SocketData <T>)ar.AsyncState;
if (!state.Socket.Connected)
{
Unlock();
return;
}
int bytesRead = state.Socket.EndReceive(ar);
//Debug.Assert(bytesRead > 0);
if (bytesRead > 0)
{
state.ContentLength += bytesRead;
string str = Encoding.ASCII.GetString(state.Buffer, 0, bytesRead);
state.Builder.Append(str);
if (state.ContentLength == state.Http.ContentLength)
{
state.Http.Data = state.Builder.ToString();
Unlock();
}
else
{
state.Socket.BeginReceive(state.Buffer, 0, state.BufferSize, 0, new AsyncCallback(ReceiveCallbackEx <T>), state);
}
}
else
{
Unlock();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Unlock();
}
}
public void btnAddDataToBroadCast_Click(System.Object sender, System.EventArgs e)
{
frmDataCreationSelectionForm frm = new frmDataCreationSelectionForm();
if (frm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
if (!this._dataTable.ContainsKey(frm.Data.DataName))
{
SocketData sd = SocketData.GetSocketData(frm.Data.DataName, frm.Data.data);
this.lstAvailableData.Items.Add(sd);
this._dataTable.Add(sd.DataName, sd);
this.SetSelectedData();
this.SaveDataToFile();
}
else
{
MessageBox.Show("The data " + frm.Data.DataName + " is already contained in the list");
}
}
frm.Dispose();
}
public static SocketData ConvertToSocketData(PBMsg pb)
{
byte[] bytes = pb.bytes;
SocketData sockData = new SocketData();
sockData.handleId = pb.handle_id_;
sockData.version = VERSION;
if (bytes != null) // 干掉了这个验证 ProtoBuf.Meta.RuntimeTypeModel.Default.CanSerialize (byteArray.data.GetType()))
{
using (var ms = new System.IO.MemoryStream())
{
sockData.data = bytes;
}
}
else
{
Debug.LogError("Can not serialize object to proto: " + pb.handle_id_.ToString());
};
return(sockData);
}
public void tmrAutomaticSendToSelectedClient_Tick(System.Object sender, System.EventArgs e)
{
try
{
SocketsServerClientConnectionHandler clnt = default(SocketsServerClientConnectionHandler);
clnt = (CommunicationsLibrary.Services.SocketsDataDistribution.ClientConnectionsHandling.SocketsServerClientConnectionHandler) this.lstConnectedClients.SelectedItem;
IEnumerator enumm = default(IEnumerator);
enumm = this.lstAutoBroadCast.Items.GetEnumerator();
Data dat = default(Data);
SocketData sockdat = default(SocketData);
while (enumm.MoveNext())
{
dat = (CommunicationsUISupportLibrary.Data)enumm.Current;
sockdat = this.GetSocketData(dat);
this._DataSocketServer.SendDataToClient(clnt, sockdat);
}
}
catch (Exception)
{
}
}
public override void OnMessage(SocketData socket, Data remoteData)
{
var remoteIP = socket.endPoint.Address.ToString();
if (serverData.ContainsKey(remoteIP))
{
serverData[remoteIP].queue.Clear();
foreach (var r in remoteData.queue)
{
serverData[remoteIP].queue.Enqueue(r);
if (serverData[remoteIP].queue.Count > 1000)
{
serverData[remoteIP].queue.Dequeue();
}
}
}
else
{
serverData.Add(remoteIP, remoteData);
}
}
private void OnRead(IAsyncResult ar)
{
StateObject state = ar.AsyncState as StateObject;
Socket client = state.socket;
try
{
int byteRead = client.EndReceive(ar);
//包尺寸有问题，断线处理
if (byteRead < 1)
{
if (onConnectChangedAction != null)
{
onConnectChangedAction(ConnectType.DisConnect, client);
}
Console.WriteLine("client disconned!" + client.RemoteEndPoint);
return;
}
lock (lockObj)
{
SocketData data;
if (SocketData.DeserializeData(state.buff, byteRead, out data))
{
Console.WriteLine("read : " + data.cn + "_" + data.module + "_" + data.cmd + " : " + data.attach.ToString());
if (onReceiveAction != null)
{
onReceiveAction(data);
}
}
Array.Clear(state.buff, 0, state.buff.Length);
}
client.BeginReceive(state.buff, 0, state.buff.Length, SocketFlags.None, new AsyncCallback(OnRead), state);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void ClientChanged(object sender, EventArgs ea)
{
ListBox clientlist = sender as ListBox;
CloseCurrentConnection(true);
if (clientlist.SelectedItem != null)
{
SocketData remote = (SocketData)clientlist.SelectedItem;
try
{
Proxy.SetStream(new NetworkStream(remote.Client.Client, true));
client_needs_resync = true;
Proxy.BeginThread();
}
catch (Exception)
{
clientlist.SelectedIndex = -1;
AddMessage("Client abandoned connection.");
}
}
MaintainClientList();
}
public void connectToInternet()
{
string serverAddr = ipText.text;
string userName = nameText.text;
thisUser._name = userName;
// Create UDP Client
shutdownNetwork(); //just incase there was some sort of error last time
Networking.initNetwork();
endp = createIPEndpointData(serverAddr, 8888);
sock = initSocketData();
if (createSocket(ref sock, SocketType.UDP) == P_GenericError)
{
Debug.LogError(getLastNetworkError());
}
if (connectEndpoint(ref endp, ref sock) == P_GenericError)
{
Debug.LogError(getLastNetworkError());
}
jobClient = new NetworkClientJob()
{
sock = sock,
endp = endp
};
hnd = jobClient.Schedule(); //schedules the job to start asynchronously like std::detach in c++
string tmp = "@" + userName;
int dump = 0;
if (sendToPacket(ref sock, ref tmp, ref dump, ref endp) == P_GenericError)
{
Debug.LogError(getLastNetworkError());
}
}
// ----------------------------------------------------------------------
// サーバーからの要求を受け取る処理.
// ----------------------------------------------------------------------
private void RecieveInfo()
{
string jsonString = ws.RecvString();
while (jsonString != null)
{
SocketDataListWrapper recieveDataListWrapper = JsonUtility.FromJson <SocketDataListWrapper>(jsonString);
switch (recieveDataListWrapper.eventName)
{
case "login":
SocketData recieveData = JsonUtility.FromJson <SocketData>(jsonString);
LoginCallback(recieveData);
break;
case "sendHostInfo":
SetPlayerInfo(recieveDataListWrapper);
break;
}
jsonString = ws.RecvString();
}
//Debug.Log(jsonString);
}
// ----------------------------------------------------------------------
// 操作情報を送信する処理.
// ----------------------------------------------------------------------
private void SendPlayerAction()
{
float x = Input.GetAxis("Horizontal");
if (x == 0)
{
x = Input.acceleration.x;
}
float z = Input.GetAxis("Vertical");
if (z == 0)
{
z = Input.acceleration.y;
}
SocketData sendData = new SocketData();
sendData.playerId = playerId;
sendData.horizontal = x;
sendData.vertical = z;
Send("setPlayerAction", sendData);
}
void EndSockConnect(IAsyncResult iar)
{
int socket = (int)iar.AsyncState;
SocketData sd = null;
if (!GetSocketData(socket, out sd))
{
return;
}
try
{
sd.IsSelectable = true;
sd.Socket.EndConnect(iar);
}
catch
{
}
SignalThread();
}
int RegisterSocket(Socket socket, bool isSelectable)
{
if (_sockets.Count == MaxSockets)
{
return(ReturnError(SocketError.TooManyOpenSockets));
}
int handle;
lock (_sockets)
{
handle = ++_handleNext;
_sockets[handle] = new SocketData(socket);
_sockets[handle].IsSelectable = (isSelectable || socket.ProtocolType != ProtocolType.Tcp);
}
SignalThread();
return(handle);
}
private static SocketData <MensagemListResponse> TratarOutput <TData>(SocketData <MensagemListResponse> socketData)
{
Usuario usuario = WebSocketServico.autentificacaoServico.RecuperarPeloTokien(socketData.Token);
socketData.Data = new MensagemListResponse();
socketData.Origin = "Server";
if (socketData.Operacao.Equals("REQUEST"))
{
socketData.Data.List = WebSocketServico.mensagemServico.RecuperarMensagemUsuarioNaoLidas(usuario);
if (socketData.Data.List.Count > 0)
{
WebSocketServico.mensagemServico.GravarMensagemComoLida(socketData.Data.List, true);
}
}
else if (socketData.Operacao.Equals("REQUEST-ALL"))
{
socketData.Data.List = WebSocketServico.mensagemServico.RecuperarMensagensUsuario(usuario);
}
socketData.Data.List.ForEach(e => { e.UsuarioFrom = null; e.UsuarioTo = null; });
return(socketData);
}
public void ctor_WithData_IsInstanceOfISocketData()
{
var bytes = Encoding.Default.GetBytes("Mein Test");
var socketData = new SocketData(bytes);
Assert.IsAssignableFrom<ISocketData>(socketData);
}
static void SA_DataArrivedEvent(object sender, SocketData e)
{
if (offlineMode) return;
Debug.WriteLine("data arrived for me");
//try
//{
// Debug.WriteLine("deserialize object: " + recievedData.ToString());
//}
//catch (Exception ex)
//{
// Debug.WriteLine("error deserializing: " + ex.Message);
//}
//if (e.BroadcastPacket == false)
// this.AddDirectEventListItem(e);
//else
// this.AddEventListItem("Data Arrived Event", ItemState.NOTIFICATION);
}
static void SA_BroadcastDataArrivedEvent(object sender, SocketData e)
{
if (offlineMode) return;
debugMessage("Broadcast data arrived");
// Debug.WriteLine(String.Format("Message received: {0}", e.Message));
// Debug.WriteLine(String.Format("Data received: {0}", e.Data));
try
{
// SocketData sd = SAHelper.DeserializeToSocketData(e.Message);
// debugMessage(String.Format("Message received: {0}", e.Message));
// debugMessage(String.Format("Data received: {0}", e.Data));
TransMessage tm = (TransMessage)SAHelper.ByteArrayObjToObject(e.Data, typeof(TransMessage));
if (tm != null)
{
if (tm.StructureId == CurrentStructureId)
{
debugMessage("RECEIVED MESSAGE - " + tm.ToString());
processMessage(tm);
}
else
{
debugMessage("Received message but not for this structure");
}
}
}
catch (Exception ex)
{
debugMessage("ERROR deserializing: " + ex.Message);
}
}
public void ctor_WithEmptyData_ReturnsData()
{
var socketData = new SocketData(new byte[0]);
Assert.NotNull(socketData);
Assert.Equal(new byte[0], socketData.Data);
}
