bool OnOpen(SocketStream sock)
{
_startTime = 0;
_timeStamp = _startTime;
_sinkSock = sock;
return true;
}
/// <summary>
/// Closes the stream.
/// </summary>
/// <param name="stream">The <see cref="NetworkStream" /></param>
private void CloseStream(SocketStream stream)
{
this.Log(this.ToString(), "flush client stream", LogLevel.Debug);
stream.Close();
this.OnClientDisconnected?.Invoke(stream.ClientId);
}
public Messenger(SocketModel socket)
{
this.socket = socket;
stream = new SocketStream(socket);
stream.Write("Slim -- V0.3\n");
}
protected void HandleAcceptedSocket(Object _Socket)
{
Stopwatch Stopwatch = new Stopwatch();
Stopwatch.Start();
using (var Socket = (Socket)_Socket)
//using (var SocketStream = new BufferedStream(new SocketStream(Socket)))
using (var SocketStream = new SocketStream(Socket))
using (var SocketStreamReader = new StreamReader(SocketStream))
using (var SocketStreamWriter = new StreamWriter(SocketStream))
{
SocketStreamWriter.NewLine = "\r\n";
List <string> HeaderLines = new List <string>();
while (Socket.Connected)
{
string Line = SocketStreamReader.ReadLine();
if (Line == null || Line.Length == 0)
{
break;
}
HeaderLines.Add(Line.Trim());
}
//HeaderLines[0];
foreach (var Line in HeaderLines.Skip(1))
{
string[] Components = Line.Split(new string[] { ":" }, 2, StringSplitOptions.None);
string NormalizedKey = Components[0].Trim().ToLower();
string NormalizedValue = Components[1].Trim();
switch (NormalizedKey)
{
case "connection":
switch (NormalizedValue.ToLower())
{
case "keep-alive":
break;
case "close":
break;
}
break;
}
}
SocketStreamWriter.WriteLine("HTTP/1.1 200 OK");
SocketStreamWriter.WriteLine("Content-Type: text/html");
SocketStreamWriter.WriteLine("Connection: close");
SocketStreamWriter.WriteLine("");
SocketStreamWriter.WriteLine("Hello World!");
SocketStreamWriter.Flush();
Socket.Close();
}
Stopwatch.Stop();
Console.WriteLine(Stopwatch.Elapsed);
}
private void NsiFromSrv(SocketStream stmX, Dictionary <string, string> aC, DataSet ds,
ref string sErr, int nRetSrv)
{
int
nFullEnd = 0,
nStartRead = 0,
nEndRead = 0;
string
sMD5New = aC["MD5"],
sP = xNSI.sPathNSI + xNSI.DT[sTName].sXML;
SocketStream.ASRWERROR
nRErr;
if ((bMD_5 == true) && (sMD5New == (string)xNSI.BD_TINF_RW(sTName)["MD5"]))
{
sErr = "OK-No Load";
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
else
{
sErr = "Ошибка чтения XML";
string sXMLFile = "";
if (stmX.ASReadS.OutFile.Length == 0)
{
stmX.ASReadS.TermDat = AppC.baTermMsg;
nStartRead = Environment.TickCount;
nRErr = stmX.ASReadS.BeginARead(true, 1000 * 300);
nEndRead = Environment.TickCount;
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
}
sXMLFile = stmX.ASReadS.OutFile;
stmX.Disconnect();
try
{
xNSI.DT[sTName].dt.BeginLoadData();
xNSI.DT[sTName].dt.Clear();
System.Xml.XmlReader xmlRd = System.Xml.XmlReader.Create(sXMLFile);
xNSI.DT[sTName].dt.ReadXml(xmlRd);
xmlRd.Close();
xNSI.DT[sTName].dt.EndLoadData();
if (File.Exists(sP))
{
File.Delete(sP);
}
if (xNSI.AfterLoadNSI(sTName, true, sXMLFile) == AppC.RC_OK)
{
File.Move(sXMLFile, sP);
}
xNSI.BD_TINF_RW(sTName)["MD5"] = sMD5New;
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
finally
{
if (File.Exists(sXMLFile))
{// возникла ошибка при загрузке, иначе отработал бы Move
sErr = "Ошибка загрузки XML";
File.Delete(sXMLFile);
}
else
{// ошибок не было
sErr = "OK";
}
nFullEnd = Environment.TickCount;
//xNSI.DT[sTName].sDTStat = String.Format("{0(сокет)}-{1(XML)}-{2(Full)}",
// Srv.TimeDiff(nStartRead, nEndRead, 1),
// Srv.TimeDiff(nEndRead, nFullEnd, 1),
// Srv.TimeDiff(xNSI.DT[sTName].nCount, nFullEnd, 1));
xNSI.DT[sTName].sDTStat = String.Format("{0}(сокет)-{1}(XML)-{2}(Full)",
Srv.TimeDiff(nStartRead, nEndRead, 1),
Srv.TimeDiff(nEndRead, nFullEnd, 1),
Srv.TimeDiff(xNSI.DT[sTName].nCount, nFullEnd, 1));
}
}
}
public object Decode(object sender, SocketClient <object, object, object> client, SocketStream <object, object, object> stream)
{
MemoryStream ms = new MemoryStream();
byte data;
while ((data = (byte)stream.ReadByte()) != 0)
{
ms.WriteByte(data);
}
string xml = encoding.GetString(ms.ToArray());
return(NicoXmlRegistry.Deserialize(xml));
}
void RequestFrames(UInt32 timestamp, SocketStream sock, UInt32 maxFrames, UInt32[] gotFrames)
{
uint count = 0;
try
{
for (count = 0; count < maxFrames; count++)
{
IBuffer buffer = WindowsRuntimeBufferExtensions.AsBuffer(_buffer, 0, (Int32)(_mp3Reader.FrameLen));
Int32 len = (Int32)_mp3Reader.ReadFrames(buffer, 1);
byte[] byteArray = buffer.ToArray();
while (len > 0)
{
Int32[] sent = new Int32[1];
sock.Send(byteArray, (Int32)len, sent);
len -= sent[0];
byte[] byteArray2 = new byte[len];
Array.Copy(byteArray, sent[0], byteArray2, 0, len);
byteArray = byteArray2;
}
}
} catch {
// TODO
}
gotFrames[0] = count;
}
} // AddHookChannelUri
//
// end of IChannelReceiverHook implementation
//
// Thread for listening
void Listen()
{
bool bOkToListen = false;
try
{
_tcpListener.Start(_bExclusiveAddressUse);
bOkToListen = true;
}
catch (Exception e)
{
_startListeningException = e;
}
_waitForStartListening.Set(); // allow main thread to continue now that we have tried to start the socket
InternalRemotingServices.RemotingTrace("Waiting to Accept the Socket on Port: " + _port);
//
// Wait for an incoming socket
//
Socket socket;
while (bOkToListen)
{
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
try
{
socket = _tcpListener.AcceptSocket();
if (socket == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString(CultureInfo.InvariantCulture)));
}
else
{
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// Set keepalive flag, so that inactive sockets can be cleaned up
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
Stream netStream = new SocketStream(socket);
HttpServerSocketHandler streamManager = null;
//Create the socket Handler
streamManager = new HttpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
// @
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
}
catch (Exception e)
{
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
// <
}
}
}
} // while (bOkToListen)
}
/// <summary>
/// Logs in the user
/// </summary>
/// <returns> Instance of the user object if they login or null else.</returns>
/// <param name="clientConnection">Client connection.</param>
/// <param name="currentClientNumber">Current client number.</param>
private static User LoginUser(TcpClient clientConnection, int currentClientNumber)
{
bool notLoggedIn = true;
while (notLoggedIn)
{
Console.WriteLine("Logging user information");
// User wants to login, so we ask them for their username and password.
SocketStream.SendMessage("Enter Username - ", clientConnection.GetStream());
string username = SocketStream.RecieveMessage(clientConnection.GetStream());
Console.WriteLine(username);
SocketStream.SendMessage("Enter Password - ", clientConnection.GetStream());
string password = SocketStream.RecieveMessage(clientConnection.GetStream());
Console.WriteLine(password);
try
{
string getUsernameQuery = "SELECT * FROM user_accounts WHERE username = ?username;";
// Holds info grabbed from the db
string dbPassword = null;
string dbUsername = null;
int permissions = 0;
string lastname = null;
string firstname = null;
using (MySqlConnection con = new MySqlConnection(Database.Instance.ConnectionString))
{
con.Open();
using (var cmd = con.CreateCommand())
{
cmd.CommandText = getUsernameQuery;
cmd.Parameters.Add("?username", MySqlDbType.VarChar).Value = username;
using (var queryReader = cmd.ExecuteReader())
{
// Using while even though only one value should return as the usernames are unique.
while (queryReader.Read())
{
try
{
dbUsername = queryReader.GetString(queryReader.GetOrdinal("username"));
dbPassword = queryReader.GetString(queryReader.GetOrdinal("password"));
permissions = queryReader.GetInt32(queryReader.GetOrdinal("user_type"));
firstname = queryReader.GetString(queryReader.GetOrdinal("first_name"));
lastname = queryReader.GetString(queryReader.GetOrdinal("last_name"));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
// The username doesn't exist in the database or the password is incorrect
// so we loop again asking for a new password.
if ((dbUsername == null) || (!PasswordEncryptor.CheckPassword(password, dbPassword)))
{
// Tell the user the username or password is incorrect.
// Not too sure whether or not to be specific about which one
// The vagueness in the message increases security though, as
// Someone trying to guess a user's account might not know which one.
SocketStream.SendMessage("Username or password is incorrect, Try again? Y/N\n", clientConnection.GetStream());
// Used to decide if the user wants to continue with the login,
bool continueLogin = true;
// Use this as a form of user input error checking, so we only get y or n.
bool decisionNotMade = true;
while (decisionNotMade)
{
string userResponse = SocketStream.RecieveMessage(clientConnection.GetStream());
switch (userResponse.ToLower())
{
// the user wants to try again, so we can just break the loop and continue
case ("y"):
continueLogin = true;
decisionNotMade = false;
break;
case ("n"):
continueLogin = false;
decisionNotMade = false;
break;
// If the choice is not what we want, send the message saying incorrect response and
// try again.
default:
SocketStream.SendMessage("Invalid input, try again.", clientConnection.GetStream());
continue;
}
}
// If the user does not want to continue attempting the login then we return a null user
// the user is not logged in.
if (!continueLogin)
{
return(null);
}
// Here we go back to the start of the loop and ask for a username again.
continue;
}
// If this point is reached, the user has entered successful login information.
SocketStream.SendMessage(String.Format("Welcome back, {0}", firstname), clientConnection.GetStream());
return(new User(currentClientNumber, username, firstname, permissions));
}
}
}
}
catch (InvalidOperationException)
{
Console.WriteLine("Query cannot be executed, please check parameters.");
}
}
// Return null if the loop to login is broken, this means that the user would like to return to the main menu.
return(null);
}
/// <summary>
/// Gets the new username.
/// </summary>
/// <returns>The new username.</returns>
/// <param name="clientConnection">Client connection.</param>
private static string GetNewUsername(TcpClient clientConnection)
{
/////////////////////////////
/// USERNAME VALIDATION ///
/////////////////////////////
bool usernameValid = false;
bool usernameExists = false;
string username = null;
while (!usernameValid)
{
SocketStream.SendMessage("Please enter username: "******"Checking username...\n", clientConnection.GetStream());
using (MySqlConnection connection = new MySqlConnection(Database.Instance.ConnectionString))
{
connection.Open();
using (MySqlCommand usernameExistsCommand = connection.CreateCommand())
{
usernameExistsCommand.CommandText = "SELECT username from user_accounts WHERE username = ?username";
usernameExistsCommand.Parameters.Add("?username", MySqlDbType.VarChar).Value = inputUsername;
// Here we execute the command to the database and if it returns a non null value, the username exists
string usernameInDatabase = (string)usernameExistsCommand.ExecuteScalar();
if (usernameInDatabase != null)
{
usernameExists = true;
}
}
connection.Close();
}
// Here we put our username validity conditionals, space for more can be added
// if there are more constraints to be added at a later date
// such as certain strings not being accepted.
if (usernameLength >= 3 && usernameLength <= 20)
{
// Satisfies our length requirement
usernameValid = true;
username = inputUsername;
SocketStream.SendMessage("Username Accepted!\n", clientConnection.GetStream());
}
// Username exists already for a user
else if (usernameExists)
{
SocketStream.SendMessage("Username already exists! Please choose another.", clientConnection.GetStream());
continue;
}
// Username doesn't fall into our criteria
else
{
SocketStream.SendMessage("Username does not satisfy requirements, please insert a new one.", clientConnection.GetStream());
continue;
}
}
return(username);
}
/// <summary>
/// Registers a new user into the messenger database
/// </summary>
/// <param name="clientConnection">Client tcp connection.</param>
private static void RegisterNewUser(TcpClient clientConnection)
{
// Display the info asking for the user to input registration
string registationMenu = "[REGISTRATION MENU]\nUsername must be between 3 and 20 characters\n";
SocketStream.SendMessage(registationMenu, clientConnection.GetStream());
string username = GetNewUsername(clientConnection);
string encryptedPassword = GetNewPassword(clientConnection);
// While the username the user inputs is invalid, ask for a correct one.
/////////////////////
/// USER INFO ///
/////////////////////
// To do, get first name, last name and date of birth.
SocketStream.SendMessage("Please enter your personal information\nWhat is your first name? ", clientConnection.GetStream());
string firstName = SocketStream.RecieveMessage(clientConnection.GetStream());
SocketStream.SendMessage("What is your last name? ", clientConnection.GetStream());
string lastName = SocketStream.RecieveMessage(clientConnection.GetStream());
// Here we're getting the user's date of birth, going to implement age restrictions for 13 on this messaging service.
SocketStream.SendMessage("Please enter in format dd/mm/yyyy, dd.mm.yyyy, dd-mm-yyyy.\nWhat is your date of birth? ", clientConnection.GetStream());
// while a valid dob has not been input.
bool dateValid = false;
DateTime realDOB = new DateTime();
while (!dateValid)
{
string dob = SocketStream.RecieveMessage(clientConnection.GetStream());
// If dob is in form dd/mm/yyyy or dd.mm.yyyy or dd-mm-yyyy, it is correct.
// TODO: validate against the actual roman calander.(only dates that might not be correct is february 29th or something.)
if (Regex.IsMatch(dob, "^([0]?[1-9]|[1|2][0-9]|[3][0|1])[./-]([0]?[1-9]|[1][0-2])[./-]([0-9]{4}|[0-9]{2})$"))
{
try
{
// convert the dob into a date time object, use this to convert to an sql date object,
// then leave the loop to insert data into database.
realDOB = DateTime.Parse(dob);
break;
}
catch (FormatException)
{
Console.WriteLine("Unable to parse date, incorrect format.");
SocketStream.SendMessage("Try again.", clientConnection.GetStream());
continue;
}
}
}
try
{
// Inserting new user into database
using (var databaseConnection = new MySqlConnection(Database.Instance.ConnectionString))
{
string insertUserQuery = "INSERT INTO user_accounts(username, password, first_name, last_name, dob, user_since, user_type) VALUES (?username, ?password, ?firstname, ?lastname, ?dob, CURRENT_TIMESTAMP(), 1)";
databaseConnection.Open();
using (var command = databaseConnection.CreateCommand())
{
command.CommandText = insertUserQuery;
command.Parameters.Add("?username", MySqlDbType.VarChar).Value = username;
command.Parameters.Add("?password", MySqlDbType.VarChar).Value = encryptedPassword;
command.Parameters.Add("?firstname", MySqlDbType.VarChar).Value = firstName;
command.Parameters.Add("?lastname", MySqlDbType.VarChar).Value = lastName;
command.Parameters.Add("?dob", MySqlDbType.Date).Value = realDOB;
command.ExecuteNonQuery();
}
databaseConnection.Close();
SocketStream.SendMessage("\nUser Registered.\n", clientConnection.GetStream());
}
}
catch (Exception e)
{
Console.WriteLine("Error inputting to database - " + e);
}
}
private void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
TcpServerSocketHandler streamManager = null;
bool flag = true;
try
{
if (this._tcpListener.IsListening)
{
this._tcpListener.BeginAcceptSocket(this._acceptSocketCallback, null);
}
socket = this._tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"), new object[] { Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture) }));
}
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.Debug, 1);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
LingerOption optionValue = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, optionValue);
Stream stream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
WindowsIdentity identity = null;
flag = false;
if (this._secure)
{
identity = this.Authenticate(ref stream, streamManager);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, stream);
if ((this._authorizeRemotingConnection != null) && !this._authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
}
streamManager.ImpersonationIdentity = identity;
streamManager.DataArrivedCallback = new WaitCallback(this._transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception exception)
{
try
{
if (streamManager != null)
{
streamManager.SendErrorResponse(exception, false);
}
if (socket != null)
{
if (flag)
{
socket.Close(0);
}
else
{
socket.Close();
}
}
}
catch (Exception)
{
}
if (this._bListening)
{
SocketException exception3 = exception as SocketException;
}
}
}
public HttpStream(HttpEntity entity, SocketStream stream)
{
HttpEntity = entity;
SocketStream = stream;
AddHeaders = true;
}
public async Task WhenSendingMessagesToEchoServer_ThenStatisticsAreUpdated(
[LinuxInstance(InitializeScript = InitializeScripts.InstallEchoServer)] ResourceTask <InstanceLocator> vm,
[Credential(Role = PredefinedRole.IapTunnelUser)] ResourceTask <ICredential> credential,
[Values(
1,
(int)DataMessage.MaxDataLength,
(int)DataMessage.MaxDataLength * 2)] int length)
{
var message = new byte[length];
FillArray(message);
var locator = await vm;
var listener = SshRelayListener.CreateLocalListener(
new IapTunnelingEndpoint(
await credential,
await vm,
7,
IapTunnelingEndpoint.DefaultNetworkInterface,
TestProject.UserAgent),
new AllowAllRelayPolicy());
listener.ClientAcceptLimit = 1; // Terminate after first connection.
listener.ListenAsync(CancellationToken.None).ContinueWith(_ => { });
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Loopback, listener.LocalPort));
var clientStreamStats = new ConnectionStatistics();
var clientStream = new SocketStream(socket, clientStreamStats);
using (var tokenSource = new CancellationTokenSource())
{
// Write full payload.
await clientStream.WriteAsync(message, 0, message.Length, tokenSource.Token);
Assert.AreEqual(length, clientStreamStats.BytesTransmitted);
// Read entire response.
var response = new byte[length];
int totalBytesRead = 0;
while (true)
{
var bytesRead = await clientStream.ReadAsync(
response,
totalBytesRead,
response.Length - totalBytesRead,
tokenSource.Token);
totalBytesRead += bytesRead;
if (bytesRead == 0 || totalBytesRead >= length)
{
break;
}
}
await clientStream.CloseAsync(tokenSource.Token);
await Task.Delay(50);
Assert.AreEqual(length, totalBytesRead, "bytes read");
Assert.AreEqual(length, clientStreamStats.BytesReceived, "client received");
Assert.AreEqual(length, listener.Statistics.BytesReceived, "server received");
Assert.AreEqual(length, listener.Statistics.BytesTransmitted, "server sent");
}
}
public void Disconnect()
{
if (_disconnectedCallback != null)
{
try
{
_disconnectedCallback(this);
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
}
lock (_lockObject)
{
if (!Connected)
{
return;
}
Connected = false;
}
Log.InvokeInfoLog(this, $"Socket {ContextName} is Disconnected with Ip:{TcpClient.Client.RemoteEndPoint}. Id=" + Id);
try
{
_cancellationToken.Cancel(true);
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
try
{
SocketStatistic.WeHaveDisconnect();
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
try
{
SocketStream.Close();
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
try
{
TcpClient.Close();
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
try
{
_deliveryPublisherSubscriber.Stop();
}
catch (Exception e)
{
Log.InvokeExceptionLog(this, e, true);
}
Task.Run(ProcessOnDisconnectAsync);
}
public static HttpTransaction BeginTransaction(HttpServer server, SocketStream stream, HttpConnectionCallback cb)
{
HttpTransaction transaction = new HttpTransaction(server, stream, cb);
return(transaction);
}
public HttpResponse(SocketStream stream)
{
Socket = stream;
Stream = new HttpStream(this, stream);
}
void JitterMiss(UInt32 timestamp, SocketStream sock, UInt32 jitter)
{
}
public virtual async Task ConnectAsync()
{
Log.Start();
ActionReply reply = new ActionReply();
if (isDisposed)
{
throw new ApplicationException("This client has been disposed!");
}
if (m_stream == null)
{
m_stream = new SocketStream(ConnectionInfo.Security);
}
else
{
if (IsConnected)
{
await DisconnectAsync();
}
}
if (ConnectionInfo.Hostname == null)
{
throw new MissingPrimaryKeyException("Hostname is empty!");
}
if (UserInfo == null)
{
throw new MissingPrimaryKeyException("No user information has been set!");
}
m_stream.ConnectTimeout = ConnectionInfo.TimeoutMilliseconds;
m_stream.Connect(ConnectionInfo.Hostname, ConnectionInfo.Port);
m_stream.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive,
ConnectionInfo.KeepAlive);
if (ConnectionInfo.Security != SSLType.Unsecure)
{
switch (ConnectionInfo.Security)
{
case SSLType.AuthSSL:
reply = await SendCommandAsync("AUTH SSL");
if (reply.Success)
{
m_stream.ActivateEncryption(ConnectionInfo.Hostname, null, SslProtocols.Ssl3);
}
//else
// throw new SecurityNotAvailableException("SSL call failed!");
break;
case SSLType.AuthTLSv10:
reply = await SendCommandAsync("AUTH TLS");
if (reply.Success)
{
m_stream.ActivateEncryption(ConnectionInfo.Hostname, null, SslProtocols.Ssl3 | SslProtocols.Tls);
}
//else
// throw new SecurityNotAvailableException("TLS call failed!");
break;
case SSLType.AuthTLSv11:
reply = await SendCommandAsync("AUTH TLS");
if (reply.Success)
{
m_stream.ActivateEncryption(ConnectionInfo.Hostname, null, SslProtocols.Ssl3 | SslProtocols.Tls11);
}
//else
// throw new SecurityNotAvailableException("TLS call failed!");
break;
case SSLType.AuthTLSv12:
reply = await SendCommandAsync("AUTH TLS");
if (reply.Success)
{
m_stream.ActivateEncryption(ConnectionInfo.Hostname, null, SslProtocols.Ssl3 | SslProtocols.Tls12);
}
//else
// throw new SecurityNotAvailableException("TLS call failed!");
break;
case SSLType.ImplicitSSL:
m_stream.ActivateEncryption(ConnectionInfo.Hostname, null, SslProtocols.Ssl2);
break;
}
ActionLog(reply);
if (!reply.Success)
{
await DisconnectAsync();
return;
}
}
await HandshakeAsync();
await LogInAsync();
if (m_stream.IsEncrypted /* && DataConnectionEncryption*/)
{
if (!(reply = await SendCommandAsync("PBSZ 0")).Success)
{
ActionLog(reply);
await DisconnectAsync();
return;
//throw new FtpCommandException(reply);
}
if (!(reply = await SendCommandAsync("PROT P")).Success)
{
ActionLog(reply);
await DisconnectAsync();
return;
//throw new FtpCommandException(reply);
}
}
if ((reply = await SendCommandAsync("FEAT")).Success && reply.InfoMessages != null)
{
GetServerOptions(reply);
}
ActionLog(ActionEventType.None, reply);
if (TextEncoding == Encoding.ASCII && HasFeature(ServerCapabilities.UTF8))
{
TextEncoding = Encoding.UTF8;
reply = await SendCommandAsync("OPTS UTF8 ON");
ActionLog(reply);
}
if ((reply = await SendCommandAsync("SYST")).Success)
{
ServerSystem = reply.Message;
ActionLog(reply);
}
if (m_stream.IsEncrypted && ConnectionInfo.Security == SSLType.Unsecure)
{
if (!(reply = await SendCommandAsync("CCC")).Success)
{
ActionLog(reply);
await DisconnectAsync();
return;
}
else
{
m_stream.DeactivateEncryption();
await ReadStaleDataAsync(false, true);
}
}
//list whatever files and shit!
}
private void NsiFromSrv(SocketStream stmX, Dictionary <string, string> aC, DataSet ds,
ref string sErr, int nRetSrv)
{
SocketStream.ASRWERROR nRErr;
string sMD5New = aC["MD5"];
string sP = xNSI.sPathNSI + xNSI.DT[sTName].sXML;
if ((bMD_5 == true) && (sMD5New == (string)xNSI.BD_TINF_RW(sTName)["MD5"]))
{
sErr = "OK-No Load";
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
else
{
sErr = "Ошибка чтения XML";
string sXMLFile = "";
if (stmX.ASReadS.OutFile.Length == 0)
{
stmX.ASReadS.TermDat = AppC.baTermMsg;
nRErr = stmX.ASReadS.BeginARead(true, 1000 * 60);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
}
sXMLFile = stmX.ASReadS.OutFile;
stmX.Disconnect();
try
{
sErr = "Ошибка загрузки XML";
xNSI.DT[sTName].dt.BeginLoadData();
xNSI.DT[sTName].dt.Clear();
System.Xml.XmlReader xmlRd = System.Xml.XmlReader.Create(sXMLFile);
xNSI.DT[sTName].dt.ReadXml(xmlRd);
xmlRd.Close();
xNSI.DT[sTName].dt.EndLoadData();
sErr = "Ошибка сохранения XML";
if (File.Exists(sP))
{
File.Delete(sP);
}
if (xNSI.AfterLoadNSI(sTName, true, sXMLFile) == AppC.RC_OK)
{
File.Move(sXMLFile, sP);
}
xNSI.BD_TINF_RW(sTName)["MD5"] = sMD5New;
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
finally
{
if (File.Exists(sXMLFile))
{// возникла ошибка при загрузке, иначе отработал бы Move
sErr = "Ошибка загрузки XML";
File.Delete(sXMLFile);
}
else
{// ошибок не было
sErr = "OK";
}
}
}
}
private string ExchgSrv(int nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret)
{
string sC;
string sAdr = xPars.sHostSrv + ":" + xPars.nSrvPort.ToString();
string sErr = sAdr + "-нет связи с сервером";
int nRetSrv;
byte[] bAns = { };
//SocketStream.ASRWERROR nRErr;
System.IO.Stream stm = null;
ret = 0;
try
{
ssWrite = new SocketStream(xPars.sHostSrv, xPars.nSrvPort);
if (!TestConnection())
{
//throw new System.Net.Sockets.SocketException(11053);
}
stm = ssWrite.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команды не отправлена";
byte[] baCom = SetUpLoadCommand(nCom, sPar1, sDop);
// 20 секунд на запись команды
ssWrite.ASWriteS.TimeOutWrite = 1000 * 20;
ssWrite.ASWriteS.BeginAWrite(baCom, baCom.Length);
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
ssWrite.ASWriteS.TimeOutWrite = 1000 * 10;
// терминатор сообщения
ssWrite.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
sErr = sAdr + "-ошибка чтения";
/*
* // 120 секунд на чтение ответа
* ssWrite.ASReadS.TimeOutRead = 1000 * 120;
* ssWrite.ASReadS.TermMsg = AppC.baTermCom;
* nRErr = ssWrite.ASReadS.BeginARead();
* switch (nRErr)
* {
* case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
* sErr = " длинная команда";
* throw new System.Net.Sockets.SocketException(10061);
* case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
* sC = ssWrite.ASReadS.GetMsg();
* break;
* default:
* throw new System.Net.Sockets.SocketException(10061);
* }
*/
//============
int nCommLen = 0;
bAns = ReadAnswerCommand(stm, ref nCommLen);
sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
//================
Dictionary <string, string> aComm = SrvCommParse(sC, new char[] { ';' });
nRetSrv = int.Parse(aComm["RET"]);
if (aComm["COM"] == AppC.saComms[nCom])
{
if (nRetSrv == AppC.RC_OK)
{
sErr = "OK";
if (dgRead != null)
{
dgRead(stm, aComm, dsTrans, ref sErr, nRetSrv);
}
else
{//
//sErr = sAdr + "-завершение";
//// 5 секунд на чтение ответа
//ssWrite.ASReadS.TimeOutRead = 1000 * 5;
//ssWrite.ASReadS.TermMsg = AppC.baTermMsg;
//nRErr = ssWrite.ASReadS.BeginARead(256);
//switch (nRErr)
//{
// case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
// sErr = " длинная команда";
// throw new System.Net.Sockets.SocketException(10061);
// case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
// break;
// default:
// throw new System.Net.Sockets.SocketException(10061);
//}
}
}
else
{
if (aComm["MSG"] != "")
{
sErr = sAdr + " - ошибка:\r\n" + aComm["MSG"];
}
else
{
sErr = sAdr + "\r\n Отложено выполнение";
}
}
}
ret = nRetSrv;
}
catch (Exception e)
{
sC = e.Message;
ret = 3;
}
finally
{
ssWrite.Disconnect();
}
return(sErr);
}
public static HttpTransaction BeginTransaction(HttpServer server, SocketStream stream, HttpConnectionCallback cb, bool closeOnEnd = false)
{
HttpTransaction transaction = new HttpTransaction(server, stream, cb, closeOnEnd);
return(transaction);
}
private string ShMove(string sHostSh, int nPortSh, string sLogin, string sPass,
string sDevID, string sOper, ref int nRet)
{
string sC;
string sAdr = sHostSh + ":" + nPortSh.ToString();
string sErr = sAdr + "-нет связи с сервером";
SocketStream.ASRWERROR nRErr;
byte[] baCom;
SocketStream ssSH = null;
System.IO.Stream stm = null;
try
{
Encoding enc866 = Encoding.Default;
ssSH = new SocketStream(sHostSh, nPortSh);
if (!TestConnection())
{
//throw new System.Net.Sockets.SocketException(11053);
}
stm = ssSH.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команда не отправлена";
string sCom = "100|" + sLogin + "|" + sPass + "|" + sDevID + "|" + sOper;
baCom = enc866.GetBytes(sCom);
// 10 секунд на запись команды
ssSH.ASWriteS.TimeOutWrite = 1000 * 10;
ssSH.ASWriteS.BeginAWrite(baCom, baCom.Length);
sErr = sAdr + "-ошибка чтения";
// 20 секунд на чтение ответа
ssSH.ASReadS.TimeOutRead = 1000 * 30;
ssSH.ASReadS.MsgEncoding = Encoding.Default;
//ssSH.ASReadS.TermMsg = enc866.GetBytes("1|");
ssSH.ASReadS.TermDat = enc866.GetBytes("1|");
nRErr = ssSH.ASReadS.BeginARead(256);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
sErr = " длинная команда";
throw new System.Net.Sockets.SocketException(10061);
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
sC = ssSH.ASReadS.GetMsg();
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
sErr = " ошибочный ответ";
string[] saReply = sC.Split(new char[] { '|' });
nRet = int.Parse(saReply[2]);
switch (nRet)
{
case 0:
sErr = "OK";
break;
case -1:
sErr = " Неверный ID";
break;
case -2:
sErr = " Неверный User/Pass";
break;
case -3:
sErr = " Ошибка устройства";
break;
case -4:
sErr = " Нет прав";
break;
default:
sErr = " Неизвестная ошибка";
break;
}
}
catch (Exception e)
{
sC = e.Message;
nRet = 3;
}
finally
{
ssSH.Disconnect();
}
return(sErr);
}
// AcceptSocket method which will invoke the
// authorization callbacks
void AcceptSocketCallback(IAsyncResult ar)
{
Socket socket = null;
InternalRemotingServices.RemotingTrace("TCPChannel::Listen - tcpListen.Pending() == true");
TcpServerSocketHandler streamManager = null;
bool closeImmediately = true;
try
{
//
// Wait for an incoming socket
// if the listener is still active
if (_tcpListener.IsListening)
{
_tcpListener.BeginAcceptSocket(_acceptSocketCallback, null);
}
socket = _tcpListener.EndAcceptSocket(ar);
if (socket == null)
{
throw new RemotingException(
String.Format(
CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Socket_Accept"),
Marshal.GetLastWin32Error().ToString(CultureInfo.CurrentCulture)));
}
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingEndPointAuthorized(socket.RemoteEndPoint);
if (!authorized)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationEndpointFailed"));
}
}
// disable nagle delay
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
// Set keepalive flag, so that inactive sockets can be cleaned up
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);
// set linger option
LingerOption lingerOption = new LingerOption(true, 3);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
Stream netStream = new SocketStream(socket);
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
#if !FEATURE_PAL
WindowsIdentity identity = null;
#endif // !FEATURE_PAL
// If authentication is requested wait for auth request.
closeImmediately = false;
if (_secure)
{
#if !FEATURE_PAL
identity = Authenticate(ref netStream, streamManager);
// Create a new SocketHandler to wrap the new netStream
streamManager = new TcpServerSocketHandler(socket, CoreChannel.RequestQueue, netStream);
if (_authorizeRemotingConnection != null)
{
bool authorized = _authorizeRemotingConnection.IsConnectingIdentityAuthorized(identity);
if (!authorized)
{
throw new RemotingException(CoreChannel.GetResourceString(
"Remoting_Tcp_ServerAuthorizationIdentityFailed"));
}
}
#else
throw new NotSupportedException();
#endif // !FEATURE_PAL
}
#if !FEATURE_PAL
// Cache the identity for impersonation
streamManager.ImpersonationIdentity = identity;
#endif // !FEATURE_PAL
streamManager.DataArrivedCallback = new WaitCallback(_transportSink.ServiceRequest);
streamManager.BeginReadMessage();
}
catch (Exception e)
{
// Close the socket pre-emptively. We also close the socket if
// We need to catch all exceptions if we hit ObjectDisposedException
try{
if (streamManager != null)
{
streamManager.SendErrorResponse(e, false);
}
if (socket != null)
{
if (closeImmediately)
{
socket.Close(0);
}
else
{
socket.Close();
}
}
}catch (Exception) {}
if (!_bListening)
{
// We called Stop() on the tcp listener, so gracefully exit.
//bOkToListen = false;
}
else
{
// we want the exception to show up as unhandled since this
// is an unexpected failure.
if (!(e is SocketException))
{
// <
}
}
}
}
// Token: 0x0600184D RID: 6221 RVA: 0x00063F20 File Offset: 0x00062120
internal static bool TryOpenChannel(NetworkPath netPath, int timeoutInMs, out TcpClientChannel channel, out NetworkTransportException networkEx)
{
channel = null;
networkEx = null;
Exception ex = null;
Socket socket = null;
Stream stream = null;
NegotiateStream negotiateStream = null;
ReplayStopwatch replayStopwatch = new ReplayStopwatch();
replayStopwatch.Start();
try
{
socket = new Socket(netPath.TargetEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
if (netPath.Purpose == NetworkPath.ConnectionPurpose.Seeding)
{
socket.ReceiveBufferSize = RegistryParameters.SeedingNetworkTransferSize;
socket.SendBufferSize = RegistryParameters.SeedingNetworkTransferSize;
}
else
{
socket.ReceiveBufferSize = RegistryParameters.LogCopyNetworkTransferSize;
socket.SendBufferSize = RegistryParameters.LogCopyNetworkTransferSize;
}
if (netPath.HasSourceEndpoint())
{
socket.Bind(netPath.SourceEndPoint);
}
TcpClientChannel.ConnectAbandon connectAbandon = new TcpClientChannel.ConnectAbandon(socket);
IAsyncResult asyncResult = socket.BeginConnect(netPath.TargetEndPoint.Address, netPath.TargetEndPoint.Port, null, connectAbandon);
if (!asyncResult.AsyncWaitHandle.WaitOne(timeoutInMs, false))
{
socket = null;
connectAbandon.Cancel(asyncResult);
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
socket.EndConnect(asyncResult);
long elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
ExTraceGlobals.TcpClientTracer.TraceDebug <long>(0L, "Connection took {0}ms", elapsedMilliseconds);
socket.LingerState = new LingerOption(true, 0);
if (!netPath.UseSocketStream || RegistryParameters.DisableSocketStream)
{
stream = new NetworkStream(socket, false);
}
else
{
stream = new SocketStream(socket, netPath.SocketStreamBufferPool, netPath.SocketStreamAsyncArgPool, netPath.SocketStreamPerfCounters);
}
negotiateStream = new NegotiateStream(stream, false);
stream = null;
elapsedMilliseconds = replayStopwatch.ElapsedMilliseconds;
if (elapsedMilliseconds >= (long)timeoutInMs)
{
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
int num = timeoutInMs - (int)elapsedMilliseconds;
negotiateStream.WriteTimeout = num;
negotiateStream.ReadTimeout = num;
TcpClientChannel.AuthAbandon authAbandon = new TcpClientChannel.AuthAbandon(socket, negotiateStream);
string targetName;
if (netPath.UseNullSpn)
{
targetName = "";
}
else
{
targetName = "HOST/" + netPath.TargetNodeName;
}
bool encrypt = netPath.Encrypt;
ProtectionLevel protectionLevel;
if (encrypt)
{
protectionLevel = ProtectionLevel.EncryptAndSign;
}
else if (RegistryParameters.DisableNetworkSigning)
{
protectionLevel = ProtectionLevel.None;
}
else
{
protectionLevel = ProtectionLevel.Sign;
}
asyncResult = negotiateStream.BeginAuthenticateAsClient(CredentialCache.DefaultNetworkCredentials, targetName, protectionLevel, TokenImpersonationLevel.Identification, null, authAbandon);
if (!asyncResult.AsyncWaitHandle.WaitOne(num, false))
{
negotiateStream = null;
socket = null;
authAbandon.Abandon(asyncResult);
TcpChannel.ThrowTimeoutException(netPath.TargetNodeName, ReplayStrings.NetworkConnectionTimeout(timeoutInMs / 1000));
}
negotiateStream.EndAuthenticateAsClient(asyncResult);
bool flag = false;
if (!negotiateStream.IsAuthenticated)
{
flag = true;
}
else if (protectionLevel != ProtectionLevel.None && !negotiateStream.IsMutuallyAuthenticated)
{
if (netPath.IgnoreMutualAuth || MachineName.Comparer.Equals(netPath.TargetNodeName, Environment.MachineName))
{
ExTraceGlobals.TcpClientTracer.TraceDebug(0L, "Ignoring mutual auth since we are local");
}
else
{
flag = true;
}
}
if (!flag && encrypt && !negotiateStream.IsEncrypted)
{
ExTraceGlobals.TcpClientTracer.TraceError(0L, "Encryption requested, but could not be negotiated");
flag = true;
}
if (flag)
{
ExTraceGlobals.TcpClientTracer.TraceError <bool, bool, bool>(0L, "Security Negotiation failed. Auth={0},MAuth={1},Encrypt={2}", negotiateStream.IsAuthenticated, negotiateStream.IsMutuallyAuthenticated, negotiateStream.IsEncrypted);
NetworkManager.ThrowException(new NetworkCommunicationException(netPath.TargetNodeName, ReplayStrings.NetworkSecurityFailed));
}
ExTraceGlobals.TcpClientTracer.TraceDebug <long, bool, ProtectionLevel>(0L, "Authenticated Connection took {0}ms. Encrypt={1} ProtRequested={2}", replayStopwatch.ElapsedMilliseconds, negotiateStream.IsEncrypted, protectionLevel);
channel = new TcpClientChannel(netPath.TargetNodeName, socket, negotiateStream, timeoutInMs);
return(true);
}
catch (SocketException ex2)
{
ex = ex2;
}
catch (IOException ex3)
{
ex = ex3;
}
catch (AuthenticationException ex4)
{
ex = ex4;
}
catch (NetworkTransportException ex5)
{
ex = ex5;
}
finally
{
if (channel == null)
{
if (negotiateStream != null)
{
negotiateStream.Dispose();
}
else if (stream != null)
{
stream.Dispose();
}
if (socket != null)
{
socket.Close();
}
}
else
{
ReplayCrimsonEvents.NetworkConnectionSuccess.Log <string, IPEndPoint, IPEndPoint>(netPath.TargetNodeName, netPath.TargetEndPoint, channel.LocalEndpoint);
}
}
ExTraceGlobals.TcpClientTracer.TraceError <Exception>(0L, "TryOpenChannel failed. Ex={0}", ex);
ReplayCrimsonEvents.NetworkConnectionFailure.Log <string, IPEndPoint, IPEndPoint, string>(netPath.TargetNodeName, netPath.TargetEndPoint, netPath.SourceEndPoint, ex.ToString());
if (ex is NetworkTransportException)
{
networkEx = (NetworkTransportException)ex;
}
else
{
networkEx = new NetworkCommunicationException(netPath.TargetNodeName, ex.Message, ex);
}
return(false);
}
// обмен данными с сервером в формате XML
// nCom - номер команды
// sPar1
// nTOutRead - таймаут на ожидание ответа от сервера
public string ExchgSrv(string nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret, int nTOutRead, int nBufSize)
{
string
sOutFileXML = "",
sC,
sHost,
sAdr,
sErr;
int
nPort;
SocketStream.ASRWERROR
nRErr;
System.IO.Stream
stm = null;
ret = AppC.RC_CANCEL;
ServerRet = AppC.EMPTY_INT;
if (xMF.xCLoad != null)
{
xMF.xCLoad.xLastSE = this;
xMF.xCLoad.sFileFromSrv = "";
}
SelSrvPort(nCom, sPar1, out sHost, out nPort);
sAdr = sHost + ":" + nPort.ToString();
sErr = sAdr + "-нет соединения!";
Cursor.Current = Cursors.WaitCursor;
try
{
CurSocket = new SocketStream(sHost, nPort);
if (!TestConn(false, xMF.xBCScanner, xMF.xFPan))
{
TraiceWiFi(sErr);
//throw new System.Net.Sockets.SocketException(11053);
}
else
{
//MessageBox.Show("Good reset!");
}
//TraiceWiFi(nCom + " - перед Connect");
stm = CurSocket.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команда не отправлена";
byte[] baCom = SetCommand2Srv(nCom, sPar1, sDop);
//stm.Write(baCom, 0, baCom.Length);
//stm.Write(AppC.baTermCom, 0, AppC.baTermCom.Length);
// 20 секунд на запись команды
CurSocket.ASWriteS.TimeOutWrite = 1000 * 10;
CurSocket.ASWriteS.BeginAWrite(baCom, baCom.Length);
if ((dsTrans != null) || (XMLPars != null))
{// передача данных при выгрузке
//sErr = sAdr + "-ошибка выгрузки";
//dsTrans.WriteXml(stm, XmlWriteMode.IgnoreSchema);
//sErr = sAdr + "-ошибка завершения";
sErr = sAdr + "-ошибка выгрузки";
MemoryStream mst = new MemoryStream();
if (dsTrans != null)
{
dsTrans.WriteXml(mst, XmlWriteMode.IgnoreSchema);
}
if (XMLPars != null)
{
mst.Write(XMLPars, 0, XMLPars.Length);
}
// терминатор сообщения
mst.Write(AppC.baTermMsg, 0, AppC.baTermMsg.Length);
byte[] bm1 = mst.ToArray();
mst.Close();
// 60 секунд на запись данных
CurSocket.ASWriteS.TimeOutWrite = 1000 * 180;
CurSocket.ASWriteS.BeginAWrite(bm1, bm1.Length);
}
else
{
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
CurSocket.ASWriteS.TimeOutWrite = 1000 * 30;
// терминатор сообщения
CurSocket.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
}
//int nCommLen = 0;
//byte[] bAns = ReadAnswerCommand(stm, ref nCommLen);
//sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
sErr = sAdr + "-нет ответа сервера!";
// 120 секунд на чтение ответа
//m_ssExchg.ASReadS.TimeOutRead = 1000 * 120;
//m_ssExchg.ASReadS.BufSize = 256;
//nRErr = m_ssExchg.ASReadS.BeginARead(bUseFileAsBuf, 1000 * nTOutRead);
if (nBufSize > 0)
{
CurSocket.ASReadS.BufSize = nBufSize;
}
nRErr = CurSocket.ASReadS.BeginARead(1000 * nTOutRead);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
sErr = " длинная команда";
throw new System.Net.Sockets.SocketException(10061);
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
sC = CurSocket.ASReadS.GetMsg();
break;
default:
TraiceWiFi("Сетевая ошибка (чтение ответа)");
throw new System.Net.Sockets.SocketException(10061);
}
sErr = sAdr + "-ошибка чтения";
//Dictionary<string, string> aComm = SrvCommandParse(sC);
ServerAnswer = Srv.SrvAnswerParParse(sC);
SyncTimeWithSrv();
if (ServerAnswer.ContainsKey("PAR"))
{
StringAnsPars = ServerAnswer["PAR"];
StringAnsPars = StringAnsPars.Substring(1, StringAnsPars.Length - 2);
AnswerPars = Srv.SrvAnswerParParse(StringAnsPars, new char[] { ',' });
}
//TraiceWiFi("Ответ получен...");
ServerRet = int.Parse(ServerAnswer["RET"]);
if ((ServerAnswer["COM"] == nCom) &&
((ServerRet == AppC.RC_OK) ||
(ServerRet == AppC.RC_NEEDPARS) ||
(ServerRet == AppC.RC_HALFOK)))
{
CurSocket.ASReadS.OutFile = "";
if (ServerRet == AppC.RC_NEEDPARS)
{
CurSocket.ASReadS.TermDat = AppC.baTermMsg;
if (CurSocket.ASReadS.BeginARead(true, 1000 * nTOutRead) == SocketStream.ASRWERROR.RET_FULLMSG)
{
//TraiceWiFi("Доп.Данные получены...");
sOutFileXML = CurSocket.ASReadS.OutFile;
}
else
{
TraiceWiFi("Сетевая ошибка (чтение данных)");
throw new System.Net.Sockets.SocketException(10061);
}
}
if (dgRead != null)
{
dgRead(CurSocket, ServerAnswer, dsTrans, ref sErr, ServerRet);
}
try
{
sErr = ServerAnswer["MSG"];
}
catch { sErr = "OK"; }
//dgRead(m_ssExchg, aComm, dsTrans, ref sErr, nRetSrv);
//else
//{
// sErr = "OK";
//}
}
else
{
if (ServerAnswer["MSG"] != "")
{
sErr = ServerAnswer["MSG"];
}
else
{
sErr = sAdr + "\n Отложено выполнение";
}
}
ret = ServerRet;
}
catch (Exception e)
{
//sC = e.Message;
sErr = e.Message;
TraiceWiFi(sErr);
ret = 3;
}
finally
{
CurSocket.Disconnect();
Cursor.Current = Cursors.Default;
if (ServerRet == AppC.RC_NEEDPARS)
{
if (Srv.ExchangeContext.ExchgReason == AppC.EXCHG_RSN.NO_EXCHG)
{
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.SRV_INIT;
Srv.ExchangeContext.CMD_EXCHG = nCom;
DialogResult xDRslt = xMF.CallDllForm(xMF.sExeDir + "SGPF-Univ.dll", true,
new object[] { this, nCom, AppC.R_PARS, sOutFileXML });
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.NO_EXCHG;
if (xDRslt == DialogResult.OK)
{
}
}
}
}
return(sErr);
}
public async ValueTask SendPingAsync()
{
var pingPacket = GetPingPacket();
var packageToSend = TcpSerializer.Serialize(pingPacket);
await SocketStream.WriteAsync(packageToSend);
}
private async Task ProcessMessages()
{
Log?.LogInformation($"Connected from {RemoteAddress.ToString(true)}");
using (var collector = new FtpCommandCollector(() => Encoding))
{
await WriteAsync(new FtpResponse(220, "FTP Server Ready"), _cancellationTokenSource.Token).ConfigureAwait(false);
var buffer = new byte[1024];
try
{
Task <int> readTask = null;
for (; ;)
{
if (readTask == null)
{
readTask = SocketStream.ReadAsync(buffer, 0, buffer.Length, _cancellationTokenSource.Token);
}
var tasks = new List <Task>()
{
readTask
};
if (_activeBackgroundTask != null)
{
tasks.Add(_activeBackgroundTask);
}
Debug.WriteLine($"Waiting for {tasks.Count} tasks");
var completedTask = Task.WaitAny(tasks.ToArray(), _cancellationTokenSource.Token);
Debug.WriteLine($"Task {completedTask} completed");
if (completedTask == 1)
{
var response = _activeBackgroundTask?.Result;
if (response != null)
{
Write(response);
}
_activeBackgroundTask = null;
}
else
{
var bytesRead = readTask.Result;
readTask = null;
if (bytesRead == 0)
{
break;
}
var commands = collector.Collect(buffer, 0, bytesRead);
foreach (var command in commands)
{
await ProcessMessage(command).ConfigureAwait(false);
}
}
}
}
catch (OperationCanceledException)
{
// Ignore the OperationCanceledException
// This is normal during disconnects
}
catch (Exception ex)
{
Log?.LogError(ex, "Failed to process connection");
}
finally
{
Log?.LogInformation($"Disconnection from {RemoteAddress.ToString(true)}");
_closed = true;
Data.BackgroundCommandHandler.Cancel();
if (!ReferenceEquals(SocketStream, OriginalStream))
{
SocketStream.Dispose();
SocketStream = OriginalStream;
}
_socket.Dispose();
OnClosed();
}
}
}
public FitSocket(SocketModel socket, ProgressReporter reporter)
{
socketStream = new SocketStream(socket);
this.reporter = reporter;
this.socket = socket;
}
