/// <summary>
/// request online by host
/// 0: Accepted,
/// 1: Not Accepted,
/// 2: Already ON-LINE LOCAL,
/// 3: Already ON-LINE REMOTE.
/// </summary>
void handleS1F17()
{
SubScenarioName = Resource.Intialize_Scenario_3;
string ONLACK = String.Empty;
switch (this._equipmentStatusInfo.CRST)
{
case CRST.O:
ONLACK = "0";
break;
case CRST.L:
ONLACK = "2";
break;
case CRST.R:
ONLACK = "3";
break;
default:
ONLACK = "0";
break;
}
PrimaryMessage.S1F18(ONLACK);
if (launchControlStateProcess((int)CRST.R))
{
if (LaunchDateTimeUpdateProcess())
{
launchControlStateProcess(114);
}
}
}
PrimaryMessage CreateFail(PrimaryMessageType reason)
{
var pm = new PrimaryMessage();
pm.MessageType = reason;
return(pm);
}
internal void SendInfo(SyncFileMessageType type, object data)
{
var sfm = new SyncFileMessage();
sfm.Type = type;
sfm.TaskID = Task.ID;
sfm.OwnerID = OwnerID;
sfm.MessageRoot.Connection = Task.TargetUser.DefaultConnection;
sfm.MessageRoot.Connector = Task.TargetUser.DefaultConnector;
sfm.MessageRoot.RemoteId = Task.TargetUser.Id;
if (data != null)
{
if (data is Message)
{
sfm.ClientData.SetMessage(data as Message);
}
else if (data is ILoadSaveAble)
{
sfm.ClientData.SetLoadSaveAble(data as ILoadSaveAble);
}
else if (data is byte[])
{
sfm.ClientData.SetBinary(data as byte[]);
}
else
{
sfm.ClientData.SetSerializeAble(data);
}
}
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.SyncFile;
pm.ClientData.SetMessage(sfm);
Manager.Manager.SendMessage(pm);
}
/// <summary>
/// establish communication request by host
/// </summary>
void handleS1F13()
{
SubScenarioName = Resource.Intialize_Scenario_3;
EquipmentBaseInfo message = new EquipmentBaseInfo();
message.Parse(PrimaryMessage.SecsItem);
//this._equipmentBaseInfo = message;
PrimaryMessage.S1F14(_equipmentBaseInfo.MDLN ?? String.Empty, _equipmentBaseInfo.SOFTREV ?? String.Empty, "0");
}
/// <summary>
/// Equipment Constants Data Report
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchEquipmentConstantsDataReportProcess(string[] report)
{
SubScenarioName = Resource.DCS_Equipment_Constants_Request;
var itemList = new List <Item>();
foreach (var item in report)
{
itemList.Add(A(item ?? String.Empty));
}
PrimaryMessage.S2F14(L(itemList));
return(true);
}
/// <summary>
/// S1F4: Selected Equipment Status Data report
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchSelectedEquipmentStatusReportProcess(string[] report)
{
SubScenarioName = Resource.DCS_Host_request_value_status;
var itemList = new List <Item>();
foreach (var item in report)
{
itemList.Add(A(item ?? String.Empty));
}
PrimaryMessage.S1F4(L(itemList));
return(true);
}
/// <summary>
/// Host requests Enable or Disable events
/// </summary>
void handleS2F37()
{
var requestData = GetData(PrimaryMessage.SecsItem);
var ceed = PrimaryMessage.GetCommandValue();
if (requestData.Length >= 2)
{
var ceids = requestData.Skip(1).Take(requestData.Length - 1).ToArray();
dataCollection.EnableDisableEventReportRequestEvent(requestData);
}
PrimaryMessage.S2F38(0);
}
void DoPing()
{
if (Manager == null)
{
return;
}
if (Environment.TickCount - lastPing >= Manager.DefaultPingTime)
{
lastPing = Environment.TickCount;
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.Ping;
pm.ClientData.SetBinary(BitConverter.GetBytes(Environment.TickCount));
messages.Enqueue(pm);
}
}
private void handleRCMDMessage(int rcmd)
{
PrimaryMessage.S2F42(rcmd, 0);// 立即回复S2F42
switch ((RCMD)rcmd)
{
case RCMD.START:
SubScenarioName = Resource.RCS_Host_Command_Start;
break;
case RCMD.CANCEL:
SubScenarioName = Resource.RCS_Host_Command_Cancel;
break;
case RCMD.ABORT:
SubScenarioName = Resource.RCS_Host_Command_Abort;
break;
case RCMD.PAUSE:
SubScenarioName = Resource.RCS_Host_Command_Pause;
break;
case RCMD.RESUME:
SubScenarioName = Resource.RCS_Host_Command_Resume;
break;
case RCMD.OPERATOR_CALL:
SubScenarioName = Resource.RCS_Host_Command_Operator_Call;
break;
default:
break;
}
RemoteControlCommandRequest remoteControlCommandJob = new RemoteControlCommandRequest();
remoteControlCommandJob.Parse(PrimaryMessage.SecsItem);
remoteControlScenario.RemoteControlCommandRequestEvent(remoteControlCommandJob);
}
/// <summary>
/// 对 Formatted Process Program Request 的回复
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchFormattedProcessProgramReport(IReport report)
{
PrimaryMessage.S7F26(report.SecsItem);
return(true);
}
/// <summary>
/// 对CurrentEPPDRequest的回复
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchCurrentEPPDReportProcess(IReport report)
{
PrimaryMessage.S7F20(report.SecsItem);
return(true);
}
void ListenTo(TcpClient tcp)
{
var stream = tcp.GetStream();
var data = ConnectionHelper.Receive2(stream);
// ==== 1. Nachricht ====
var m = new PrimaryMessage();
m.Load(data);
// ---- Überprüfe den Typ der Nachricht ----
if (m.MessageType != PrimaryMessageType.WantToConnect)
{
ConnectionHelper.Send2(stream,
CreateFail(PrimaryMessageType.ConnectFailed_ExpectLogin));
return;
}
// ---- Überprüfe die Identifikation des Clienten ----
var id = m.ClientData.GetLoadSaveAble <CurrentIdentification>();
var cid = base.Manager.CurrentId;
if (id.StaticIdentification != cid.StaticIdentification ||
id.Version != cid.Version)
{
var b = CreateFail(PrimaryMessageType.ConnectFailed_WrongKey);
b.ClientData.SetLoadSaveAble(cid);
ConnectionHelper.Send2(stream, b);
return;
}
// ---- Überprüfe den Platz auf dem Server ----
if (base.Manager.Users.Count >= base.Manager.Users.MaxCount)
{
ConnectionHelper.Send2(stream,
CreateFail(PrimaryMessageType.ConnectFailed_FullServer));
return;
}
// ---- Lege Nutzerdaten an ----
var user = Manager.Users.AddNewUser();
user.GlobalId = id.Id;
Connection con = new Connection(ConnectorProtocol.TCP,
(tcp.Client.LocalEndPoint as IPEndPoint).Port);
int ctr = Manager.DefaultDataTransport.ConnectorId;
if (GetUserConnection != null)
{
GetUserConnection(user, ref con, ref ctr);
}
user.DefaultConnection = con;
user.DefaultConnector = ctr;
if (AddConnection != null)
{
AddConnection(tcp, con);
}
else
{
(Manager.DefaultDataTransport as DataTransport2).AddConnection(tcp, con);
}
// ==== 2. Nachricht - Die Verbindung wurde stattgegeben ====
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.ConnectAllowed;
ConnectionHelper.Send2(stream, pm);
}
void RunLoop()
{
while (base.ProgressRun)
{
if (State == LoginState.IsConnecting)
{
try
{
var ip = new IPEndPoint(IPAddress.Parse(ConnectTo),
ServerPort);
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.WantToConnect;
pm.ClientData.SetLoadSaveAble(Manager.CurrentId);
var tcp = new TcpClient();
tcp.Connect(ip);
var stream = tcp.GetStream();
ConnectionHelper.Send2(stream, pm);
pm.Load(ConnectionHelper.Receive2(stream));
ExceptedId = null;
if (pm.MessageType == PrimaryMessageType.ConnectAllowed)
{
State = LoginState.Connected;
var con = new Connection(ConnectorProtocol.TCP,
(tcp.Client.LocalEndPoint as IPEndPoint).Port,
ConnectTo);
var user = Manager.Users.AddNewUser();
user.GlobalId = pm.SenderID;
user.DefaultConnection = con;
user.DefaultConnector = Manager.DefaultDataTransport != null ?
Manager.DefaultDataTransport.ConnectorId : -1;
if (Connected != null)
{
Connected(user);
}
if (AddConnection != null)
{
AddConnection(tcp, con);
}
else
{
(Manager.DefaultDataTransport as DataTransport2).AddConnection(tcp, con);
}
}
else if (pm.MessageType == PrimaryMessageType.ConnectFailed_FullServer)
{
State = LoginState.ServerFull;
if (ServerFull != null)
{
ServerFull();
}
}
else if (pm.MessageType == PrimaryMessageType.ConnectFailed_WrongKey)
{
State = LoginState.WrongID;
ExceptedId = pm.ClientData.GetLoadSaveAble <CurrentIdentification>();
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
else
{
State = LoginState.NotConnectable;
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
}
catch
{
State = LoginState.NotConnectable;
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
}
Thread.Sleep(10);
}
}
internal void SendMessage(PrimaryMessage message)
{
MainObject.SendMessage(message);
}
/// <summary>
/// Host requests the formatted status
/// </summary>
void handleS1F5()
{
var sfcd = PrimaryMessage.GetCommandValue();
dataCollection.FormattedStatusRequestEvent((SFCD)sfcd, true);
}
public override void SendMessage(PrimaryMessage message)
{
base.SendMessage(message);
datas.Find((d) => d.con == message.MessageRoot.Connection).messages.Enqueue(message);
}
//public event GetUserConnectionHandler CreateServerUser;
void RunLoop()
{
while (base.ProgressRun)
{
if (State == LoginState.IsConnecting)
{
try
{
var ip = new IPEndPoint(IPAddress.Parse(ConnectTo), ServerPort);
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.WantToConnect;
pm.ClientData.SetLoadSaveAble(Manager.CurrentId);
using (var udp = new UdpClient())
{
var b = pm.Save();
udp.Send(b, b.Length, ip);
for (int i = 0; i < 500; ++i)
{
if (udp.Available != 0)
{
break;
}
Thread.Sleep(1);
}
b = udp.Receive(ref ip);
pm.Load(b);
if (pm.MessageType == PrimaryMessageType.ConnectAllowed)
{
State = LoginState.Connected;
var con = pm.ClientData.GetSerializeAble <Connection>();
con = new Connection(con.Protocol, con.Port, ConnectTo);
var user = Manager.Users.AddNewUser();
user.GlobalId = pm.SenderID;
user.DefaultConnection = con;
user.DefaultConnector = Manager.DefaultDataTransport != null ?
Manager.DefaultDataTransport.ConnectorId : -1;
if (Connected != null)
{
Connected(con);
}
}
else if (pm.MessageType == PrimaryMessageType.ConnectFailed_FullServer)
{
State = LoginState.ServerFull;
if (ServerFull != null)
{
ServerFull();
}
}
else if (pm.MessageType == PrimaryMessageType.ConnectFailed_WrongKey)
{
State = LoginState.WrongID;
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
else
{
State = LoginState.NotConnectable;
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
}
}
catch
{
State = LoginState.NotConnectable;
if (ErrorWhileConnection != null)
{
ErrorWhileConnection();
}
}
}
Thread.Sleep(10);
}
}
public void StartTask(FileTransportTask task) //Sender
{
if (task == null)
{
throw new ArgumentNullException("task");
}
if (task.State != FileTransportState.Waiting)
{
throw new ArgumentException();
}
Tasks.Add(task);
var t = new Task(() =>
{
#region Daten verkleinern nur ohne Datasets
if (CompressBytes && task.DatasetCount == 0)
{
task.State = FileTransportState.CompressBytes;
using (var m = new MemoryStream())
using (var comp = new DeflateStream(m, CompressionMode.Compress))
using (var r = new BinaryReader(m))
using (var w = new BinaryWriter(comp))
{
w.Write(task.Data);
m.Position = 0;
task.CompressedBytes = r.ReadBytes((int)m.Length);
}
}
else
{
task.CompressedBytes = task.Data;
}
task.Size = task.CompressedBytes.Length;
#endregion
//Verbinden
task.State = FileTransportState.WaitForLocalConnector;
Connection con = null;
if (Role == ServerClientRole.Server)
{
con = FindEmptyConnection();
while (con == null)
{
System.Threading.Thread.Sleep(10);
con = FindEmptyConnection();
}
SetUsedState(con, true);
task.Connection = con;
}
task.State = FileTransportState.ConnectToServer;
Action act = null;
act = new Action(() =>
{
if (task.State == FileTransportState.Transport && task.TransportedBytes == 0)
{
TcpClient tcp = null;
TcpListener server = null;
if (Role == ServerClientRole.Server)
{
server = new TcpListener(IPAddress.Any, con.Port);
server.Start();
tcp = server.AcceptTcpClient();
server.Stop();
server = null;
}
else
{
tcp = new System.Net.Sockets.TcpClient();
tcp.Connect(new System.Net.IPEndPoint(System.Net.IPAddress.Parse(task.Connection.Target), task.Connection.Port));
}
var stream = tcp.GetStream();
if (task.DatasetCount == 0)
{
var offset = 0;
while (offset < task.CompressedBytes.Length)
{
stream.Write(task.CompressedBytes, offset, Math.Min(task.CompressedBytes.Length - offset, tcp.SendBufferSize));
System.Threading.Thread.Sleep(1);
offset += tcp.SendBufferSize;
task.TransportedBytes = Math.Min(task.CompressedBytes.Length, offset);
task.OnServerStateUpdated();
}
}
else
{
for (task.CurrentDataset = 0; task.CurrentDataset < task.DatasetCount; ++task.CurrentDataset)
{
var bytes = task.OnGetDatasetData(task.CurrentDataset);
var datalength = BitConverter.GetBytes(bytes.Length);
stream.Write(datalength, 0, datalength.Length);
var offset = 0;
task.Size = bytes.Length;
task.TransportedBytes = 0;
while (offset < bytes.Length)
{
if (!tcp.Connected)
{
break;
}
stream.Write(bytes, offset, Math.Min(bytes.Length - offset, tcp.SendBufferSize));
System.Threading.Thread.Sleep(1);
offset += tcp.SendBufferSize;
task.TransportedBytes = Math.Min(bytes.Length, offset);
task.OnServerStateUpdated();
}
if (!tcp.Connected)
{
break;
}
}
}
tcp.Close();
task.State = FileTransportState.Finished;
Tasks.Remove(task);
task.OnServerStateUpdated();
task.ServerStateUpdated -= act;
if (con != null)
{
SetUsedState(con, false);
}
}
});
task.ServerStateUpdated += act;
var mes = new PrimaryMessage();
var ftd = new FileTransportData();
ftd.TransportID = task.ID;
ftd.SenderID = Manager.CurrentId.Id;
ftd.Type = FileTransportType.WantSendFile;
ftd.Size = task.Size;
ftd.Datasets = task.DatasetCount;
ftd.Connection = task.Connection;
mes.ClientData.SetSerializeAble(ftd);
mes.MessageType = PrimaryMessageType.FileTransportServerToClient;
mes.MessageRoot.Connection = task.TargetUser.DefaultConnection;
mes.MessageRoot.Connector = task.TargetUser.DefaultConnector;
mes.MessageRoot.RemoteId = task.TargetUser.Id;
Manager.SendMessage(mes);
});
t.Start();
}
void con__MesRec(PrimaryMessage obj)
{
obj.MessageRoot.Connector = MainObject.ConnectorId;
Owner.RecData(obj);
}
public override void SendMessage(PrimaryMessage message)
{
helper.SendMessage(message);
}
public void SendMessage(PrimaryMessage message)
{
manager.SendMessage(message);
}
void doConct(TcpClient tcp)
{
using (var stream = tcp.GetStream())
while (active)
{
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
DoPing();
while (tcp.Available > 0)
{
var l = new List <byte>();
var b = new byte[tcp.ReceiveBufferSize];
int len;
while (true)
{
len = stream.Read(b, 0, b.Length);
l.AddRange(b.ToList().GetRange(0, len).ToArray());
if (len < b.Length)
{
break;
}
}
try
{
var mes = new PrimaryMessage();
mes.Load(l.ToArray());
mes.MessageRoot.Connection = con;
mes.MessageRoot.Connector = connector;
mes.MessageRoot.RemoteId = id;
Manager.ReceiveMessage(mes);
}
catch
{
if (tcp.Connected)
{
continue;
}
else
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
}
}
while (messages.Count > 0)
{
var mes = messages.Dequeue();
if (mes == null)
{
continue;
}
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, mes);
return;
}
mes.SenderID = Manager.CurrentId.Id;
var b = mes.Save();
try
{
stream.Write(b, 0, b.Length);
}
catch
{
cl = new ConnectionLostEventArgument(datatr, con, mes);
return;
}
}
if (active)
{
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
Thread.Sleep(10);
}
}
}
/// <summary>
/// 对RequestAlarmList的回复
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchCurrentAlarmListReport(IReport report)
{
PrimaryMessage.S5F104(report.SecsItem);
return(true);
}
void RunLoop()
{
using (var udp = new UdpClient(new IPEndPoint(IPAddress.Any, Connections[0].Port)))
while (ProgressRun)
{
//Kurzerklärung:
//Ein Aufrufsignal mit einem ID-Paket wird geschickt. Dieses wird eingelesen und ein User wird erstellt.
//Eine Zielkooridinate wird erstellt und rückgesendet. Fertig.
while (udp.Available > 0)
{
var ep = new IPEndPoint(IPAddress.Any, 0);
var data = udp.Receive(ref ep);
//try
//{
var m = new PrimaryMessage();
m.Load(data);
byte[] b;
if (m.MessageType != PrimaryMessageType.WantToConnect)
{
b = CreateFail(PrimaryMessageType.ConnectFailed_ExpectLogin).Save();
udp.Send(b, b.Length, ep);
continue;
}
var id = m.ClientData.GetLoadSaveAble <CurrentIdentification>();
var cid = base.Manager.CurrentId;
if (id.StaticIdentification != cid.StaticIdentification || id.Version != cid.Version)
{
b = CreateFail(PrimaryMessageType.ConnectFailed_WrongKey).Save();
udp.Send(b, b.Length, ep);
continue;
}
if (base.Manager.Users.Count >= base.Manager.Users.MaxCount)
{
b = CreateFail(PrimaryMessageType.ConnectFailed_FullServer).Save();
udp.Send(b, b.Length, ep);
continue;
}
var user = Manager.Users.AddNewUser();
user.GlobalId = id.Id;
Connection con;
int ctr;
if (GetUserConnection != null)
{
GetUserConnection(user, out con, out ctr);
}
else
{
ctr = Manager.DefaultDataTransport.ConnectorId;
con = Manager.DefaultDataTransport.Connections.GetFree();
Manager.FindConnector(ctr).Connections[con] = true;
}
user.DefaultConnection = con;
user.DefaultConnector = ctr;
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.ConnectAllowed;
pm.ClientData.SetSerializeAble(con);
b = pm.Save();
udp.Send(b, b.Length, ep);
//}
//catch
//{
// var b = CreateFail(PrimaryMessageType.ConnectFailed).Save();
// udp.Send(b, b.Length, ep);
// continue;
//}
}
if (base.ProgressRun)
{
Thread.Sleep(10);
}
}
}
void doCont()
{
using (var stream = tcp.GetStream())
while (active)
{
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
DoPing();
while (tcp.Available > 0)
{
var data = ConnectionHelper.Receive2(stream);
try
{
var mes = new PrimaryMessage();
mes.Load(data);
mes.MessageRoot.Connection = con;
mes.MessageRoot.Connector = connector;
mes.MessageRoot.RemoteId = id;
var task = new Task(() => Manager.ReceiveMessage(mes));
task.Start();
}
catch
{
if (tcp.Connected)
{
continue;
}
else
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
}
}
while (messages.Count > 0)
{
var mes = messages.Dequeue();
if (mes == null)
{
continue;
}
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, mes);
return;
}
mes.SenderID = Manager.CurrentId.Id;
try { ConnectionHelper.Send2(stream, mes); }
catch
{
cl = new ConnectionLostEventArgument(datatr, con, mes);
return;
}
}
if (active)
{
if (!tcp.Connected)
{
cl = new ConnectionLostEventArgument(datatr, con, null);
return;
}
Thread.Sleep(10);
}
}
}
/// <summary>
/// Formatted Status Report
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public bool LaunchFormattedStatusReportProcess(IReport report)
{
SubScenarioName = Resource.DCS_Host_request_Formatted_status;
PrimaryMessage.S1F6(report.SecsItem);
return(true);
}
public override void SendMessage(PrimaryMessage message)
{
if (message.MessageType == PrimaryMessageType.FileTransportClientToServer)
{
var ftd = message.ClientData.GetSerializeAble <FileTransportData>();
switch (ftd.Type)
{
case FileTransportType.WaitToGetPort:
{
var task = FindTask(ftd.TransportID, ftd.SenderID);
task.State = FileTransportState.WaitForRemoteConnector;
task.RestUserToWait = ftd.UserWait;
task.OnServerStateUpdated();
} break;
case FileTransportType.CouldSendFile:
{
var task = FindTask(ftd.TransportID, ftd.SenderID);
task.State = FileTransportState.Transport;
if (ftd.Connection != null)
{
task.Connection = ftd.Connection;
}
task.OnServerStateUpdated();
} break;
}
}
if (message.MessageType == PrimaryMessageType.FileTransportServerToClient)
{
var ftd = message.ClientData.GetSerializeAble <FileTransportData>();
switch (ftd.Type)
{
case FileTransportType.WantSendFile:
{
var task = new FileTransportTask();
task.ID = ftd.TransportID;
task.State = FileTransportState.WaitForLocalConnector;
task.TargetUser = Manager.Users.GetUserFromId(message.MessageRoot.RemoteId);
task.Size = ftd.Size;
task.DatasetCount = ftd.Datasets;
task.Connection = ftd.Connection;
Tasks.Add(task);
if (RemoteTaskAdded != null)
{
RemoteTaskAdded(task);
}
Connection con = null;
if (Role != ServerClientRole.Client)
{
con = FindEmptyConnection();
userwait++;
while (con == null)
{
var pm = new PrimaryMessage();
pm.MessageRoot = message.MessageRoot;
pm.MessageType = PrimaryMessageType.FileTransportClientToServer;
ftd.UserWait = task.RestUserToWait = userwait;
ftd.Type = FileTransportType.WaitToGetPort;
pm.ClientData.SetSerializeAble(ftd);
Manager.SendMessage(pm);
System.Threading.Thread.Sleep(10);
con = FindEmptyConnection();
}
SetUsedState(con, true);
userwait--;
task.Connection = con;
}
var rm = new PrimaryMessage();
rm.MessageRoot = message.MessageRoot;
rm.MessageType = PrimaryMessageType.FileTransportClientToServer;
ftd.Type = FileTransportType.CouldSendFile;
ftd.Connection = con;
rm.ClientData.SetSerializeAble(ftd);
Manager.SendMessage(rm);
task.State = FileTransportState.Transport;
task.OnServerStateUpdated();
TcpListener tcplist = null;
TcpClient tcp = null;
if (Role == ServerClientRole.Client)
{
tcp = new TcpClient(task.Connection.Target, task.Connection.Port);
}
else
{
tcplist = new System.Net.Sockets.TcpListener(new System.Net.IPEndPoint(System.Net.IPAddress.Any, con.Port));
tcplist.Start();
tcp = tcplist.AcceptTcpClient();
}
var stream = tcp.GetStream();
if (task.DatasetCount == 0)
{
var l = new List <byte>();
var b = new byte[tcp.ReceiveBufferSize];
int len;
while (true)
{
len = stream.Read(b, 0, b.Length);
l.AddRange(b.ToList().GetRange(0, len).ToArray());
task.TransportedBytes += len;
task.OnServerStateUpdated();
if (len < b.Length)
{
System.Threading.Thread.Sleep(1);
if (stream.DataAvailable || tcp.Available > 0)
{
continue;
}
else
{
break;
}
}
}
tcp.Close();
if (tcplist != null)
{
tcplist.Stop();
}
task.CompressedBytes = l.ToArray();
}
else
{
for (task.CurrentDataset = 0; task.CurrentDataset < task.DatasetCount; ++task.CurrentDataset)
{
var l = new List <byte>();
var b = new byte[tcp.ReceiveBufferSize];
stream.Read(b, 0, 4);
var length = BitConverter.ToInt32(b, 0);
int len;
var timeout = false;
task.Size = length;
task.TransportedBytes = 0;
while (!timeout)
{
len = stream.Read(b, 0, b.Length);
l.AddRange(b.ToList().GetRange(0, len).ToArray());
task.TransportedBytes += len;
task.OnServerStateUpdated();
if (len < b.Length)
{
if (l.Count >= length)
{
break; //Fertig
}
int i = 0;
if (!tcp.Connected)
{
timeout = true;
break;
}
for (; i < 2000; ++i)
{
System.Threading.Thread.Sleep(1);
if (stream.DataAvailable || tcp.Available > 0)
{
break;
}
}
if (i == 2000)
{
timeout = true;
break; //Timeout nach 2 Sekunden
}
}
}
if (timeout)
{
break;
}
task.OnDatasetReceived(task.CurrentDataset, l.ToArray());
}
tcp.Close();
if (tcplist != null)
{
tcplist.Stop();
}
}
task.State = FileTransportState.DecompressBytes;
task.OnServerStateUpdated();
if (CompressBytes && task.DatasetCount == 0)
{
using (var m = new MemoryStream(task.CompressedBytes))
using (var defl = new DeflateStream(m, CompressionMode.Decompress))
using (var m2 = new MemoryStream())
using (var r = new BinaryReader(m2))
{
defl.CopyTo(m2);
m2.Position = 0;
task.Data = r.ReadBytes((int)m2.Length);
}
}
else
{
task.Data = task.CompressedBytes;
}
task.State = FileTransportState.Finished;
task.OnServerStateUpdated();
if (RemoteTaskFinished != null)
{
RemoteTaskFinished(task);
}
Tasks.Remove(task);
SetUsedState(con, false);
}
break;
}
}
}
internal void RecData(PrimaryMessage message)
{
manager.ReceiveMessage(message);
}
