public ConnectionState(LogDelegate logToServerHandler)
{
ReceiveBuffer = new NBTConnectionReceiveBuffer();
SendQueue = new BlockingQueue <SessionPacket>();
LogToServerHandler = logToServerHandler;
Dialect = SMBDialect.NotSet;
}
private void ProcessConnectionBuffer(ref ConnectionState state)
{
Socket clientSocket = state.ClientSocket;
NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
while (receiveBuffer.HasCompletePacket())
{
SessionPacket packet = null;
try
{
packet = receiveBuffer.DequeuePacket();
}
catch (Exception ex)
{
state.ClientSocket.Close();
state.LogToServer(Severity.Warning, "Rejected Invalid NetBIOS session packet: {0}", ex.Message);
break;
}
if (packet != null)
{
ProcessPacket(packet, ref state);
}
}
}
private void OnClientSocketReceive(object sender, SocketAsyncEventArgs ar)
{
ConnectionState state = (ConnectionState)ar.UserToken;
if (!m_clientSocket.Connected)
{
return;
}
int numberOfBytesReceived = 0;
try
{
numberOfBytesReceived = ar.BytesTransferred;
}
catch (ObjectDisposedException)
{
Log("[ReceiveCallback] EndReceive ObjectDisposedException");
return;
}
catch (SocketException ex)
{
Log("[ReceiveCallback] EndReceive SocketException: " + ex.Message);
return;
}
if (numberOfBytesReceived == 0)
{
m_isConnected = false;
}
else
{
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
buffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(state);
try
{
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.SetBuffer(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength);
args.Completed += OnClientSocketReceive;
args.UserToken = state;
if (!m_clientSocket.ReceiveAsync(ar))
{
OnClientSocketReceive(sender, ar);
}
}
catch (ObjectDisposedException)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive ObjectDisposedException");
}
catch (SocketException ex)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive SocketException: " + ex.Message);
}
}
}
private void OnClientSocketReceive(IAsyncResult ar)
{
if (ar != m_currentAsyncResult)
{
// We ignore calls for old sockets which we no longer use
// See: http://rajputyh.blogspot.co.il/2010/04/solve-exception-message-iasyncresult.html
return;
}
ConnectionState state = (ConnectionState)ar.AsyncState;
if (!m_clientSocket.Connected)
{
return;
}
int numberOfBytesReceived = 0;
try
{
numberOfBytesReceived = m_clientSocket.EndReceive(ar);
}
catch (ObjectDisposedException)
{
Log("[ReceiveCallback] EndReceive ObjectDisposedException");
return;
}
catch (SocketException ex)
{
Log("[ReceiveCallback] EndReceive SocketException: " + ex.Message);
return;
}
if (numberOfBytesReceived == 0)
{
m_isConnected = false;
}
else
{
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
buffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(state);
try
{
m_currentAsyncResult = m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
}
catch (ObjectDisposedException)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive ObjectDisposedException");
}
catch (SocketException ex)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive SocketException: " + ex.Message);
}
}
}
private void OnClientSocketReceive(IAsyncResult ar)
{
ConnectionState state = (ConnectionState)ar.AsyncState;
Socket clientSocket = state.ClientSocket;
if (!clientSocket.Connected)
{
return;
}
int numberOfBytesReceived = 0;
try
{
numberOfBytesReceived = clientSocket.EndReceive(ar);
}
catch (ArgumentException) // The IAsyncResult object was not returned from the corresponding synchronous method on this class.
{
return;
}
catch (ObjectDisposedException)
{
Log("[ReceiveCallback] EndReceive ObjectDisposedException");
return;
}
catch (SocketException ex)
{
Log("[ReceiveCallback] EndReceive SocketException: " + ex.Message);
return;
}
if (numberOfBytesReceived == 0)
{
m_isConnected = false;
}
else
{
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
buffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(state);
try
{
clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
}
catch (ObjectDisposedException)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive ObjectDisposedException");
}
catch (SocketException ex)
{
m_isConnected = false;
Log("[ReceiveCallback] BeginReceive SocketException: " + ex.Message);
}
}
}
private void ReceiveCallback(IAsyncResult result)
{
ConnectionState state = (ConnectionState)result.AsyncState;
Socket clientSocket = state.ClientSocket;
if (!m_listening)
{
clientSocket.Close();
return;
}
int numberOfBytesReceived;
try
{
numberOfBytesReceived = clientSocket.EndReceive(result);
}
catch (ObjectDisposedException)
{
m_connectionManager.ReleaseConnection(state);
return;
}
catch (SocketException)
{
m_connectionManager.ReleaseConnection(state);
return;
}
if (numberOfBytesReceived == 0)
{
// The other side has closed the connection
state.LogToServer(Severity.Debug, "The other side closed the connection");
m_connectionManager.ReleaseConnection(state);
return;
}
NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
receiveBuffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(ref state);
if (clientSocket.Connected)
{
try
{
clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
}
catch (ObjectDisposedException)
{
m_connectionManager.ReleaseConnection(state);
}
catch (SocketException)
{
m_connectionManager.ReleaseConnection(state);
}
}
}
public ConnectionState(ConnectionState state)
{
ClientSocket = state.ClientSocket;
ClientEndPoint = state.ClientEndPoint;
ReceiveBuffer = state.ReceiveBuffer;
SendQueue = state.SendQueue;
LogToServerHandler = state.LogToServerHandler;
Dialect = state.Dialect;
}
public ConnectionState(ConnectionState state)
{
m_clientSocket = state.ClientSocket;
m_clientEndPoint = state.ClientEndPoint;
m_receiveBuffer = state.ReceiveBuffer;
m_sendQueue = state.SendQueue;
m_creationDT = state.CreationDT;
m_lastReceiveDT = state.LastReceiveDT;
m_lastSendDTRef = state.LastSendDTRef;
LogToServerHandler = state.LogToServerHandler;
Dialect = state.Dialect;
}
public ConnectionState(Socket clientSocket, IPEndPoint clientEndPoint, LogDelegate logToServerHandler)
{
m_clientSocket = clientSocket;
m_clientEndPoint = clientEndPoint;
m_receiveBuffer = new NBTConnectionReceiveBuffer();
m_sendQueue = new BlockingQueue <SessionPacket>();
m_creationDT = DateTime.UtcNow;
m_lastReceiveDT = DateTime.UtcNow;
m_lastSendDTRef = DateTime.UtcNow;
LogToServerHandler = logToServerHandler;
Dialect = SMBDialect.NotSet;
}
private void ConnectSocket(IPAddress serverAddress, int port)
{
m_clientSocket?.Disconnect(false);
m_clientSocket?.Shutdown(SocketShutdown.Both);
m_clientSocket?.Dispose();
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_clientSocket.Connect(serverAddress, port);
ConnectionState state = new ConnectionState(m_clientSocket);
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, OnClientSocketReceive, state);
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity)
{
m_transport = transport;
if (!m_isConnected)
{
m_forceExtendedSecurity = forceExtendedSecurity;
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int port;
if (transport == SMBTransportType.DirectTCPTransport)
{
port = DirectTCPPort;
}
else
{
port = NetBiosOverTCPPort;
}
try
{
m_clientSocket.Connect(serverAddress, port);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState();
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.SetBuffer(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength);
args.Completed += OnClientSocketReceive;
args.UserToken = state;
if (!m_clientSocket.ReceiveAsync(args))
{
OnClientSocketReceive(m_clientSocket, args);
}
bool supportsDialect = NegotiateDialect(m_forceExtendedSecurity);
if (!supportsDialect)
{
m_clientSocket.Dispose();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
private bool ConnectSocket(IPAddress serverAddress, int port)
{
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
m_clientSocket.Connect(serverAddress, port);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState(m_clientSocket);
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
return(true);
}
private void ProcessConnectionBuffer(ConnectionState state)
{
NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
while (receiveBuffer.HasCompletePacket())
{
SessionPacket packet;
try
{
packet = receiveBuffer.DequeuePacket();
}
catch (Exception)
{
state.ClientSocket.Close();
break;
}
ProcessPacket(packet, state);
}
}
public bool Connect(IPAddress serverAddress, SMBTransportType transport, bool forceExtendedSecurity)
{
m_transport = transport;
if (!m_isConnected)
{
m_forceExtendedSecurity = forceExtendedSecurity;
m_clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int port;
if (transport == SMBTransportType.DirectTCPTransport)
{
port = DirectTCPPort;
}
else
{
port = NetBiosOverTCPPort;
}
try
{
m_clientSocket.Connect(serverAddress, port);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState();
NBTConnectionReceiveBuffer buffer = state.ReceiveBuffer;
m_currentAsyncResult = m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
bool supportsDialect = NegotiateDialect(m_forceExtendedSecurity);
if (!supportsDialect)
{
m_clientSocket.Close();
}
else
{
m_isConnected = true;
}
}
return(m_isConnected);
}
private void ReceiveCallback(object sender, SocketAsyncEventArgs result)
{
ConnectionState state = (ConnectionState)result.UserToken;
Socket clientSocket = state.ClientSocket;
if (!m_listening)
{
clientSocket.Dispose();
return;
}
int numberOfBytesReceived;
try
{
numberOfBytesReceived = result.BytesTransferred;
}
catch (ObjectDisposedException)
{
state.LogToServer(Severity.Debug, "The connection was terminated");
m_connectionManager.ReleaseConnection(state);
return;
}
catch (SocketException ex)
{
///const int WSAECONNRESET = 10054;
if (ex.SocketErrorCode == SocketError.ConnectionReset)
{
state.LogToServer(Severity.Debug, "The connection was forcibly closed by the remote host");
}
else
{
state.LogToServer(Severity.Debug, "The connection was terminated, Socket error code: {0}", ex.SocketErrorCode);
}
m_connectionManager.ReleaseConnection(state);
return;
}
if (numberOfBytesReceived == 0)
{
state.LogToServer(Severity.Debug, "The client closed the connection");
m_connectionManager.ReleaseConnection(state);
return;
}
state.UpdateLastReceiveDT();
NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
receiveBuffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(ref state);
if (clientSocket.Connected)
{
try
{
SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.SetBuffer(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength);
args.Completed += ReceiveCallback;
args.UserToken = state;
//m_currentAsyncResult =
if (!clientSocket.ReceiveAsync(args))
{
ReceiveCallback(sender, args);
}
}
catch (ObjectDisposedException)
{
m_connectionManager.ReleaseConnection(state);
}
catch (SocketException)
{
m_connectionManager.ReleaseConnection(state);
}
}
}
private void ReceiveCallback(IAsyncResult result)
{
ConnectionState state = (ConnectionState)result.AsyncState;
Socket clientSocket = state.ClientSocket;
if (!m_listening)
{
clientSocket.Close();
return;
}
int numberOfBytesReceived;
try
{
numberOfBytesReceived = clientSocket.EndReceive(result);
}
catch (ObjectDisposedException)
{
state.LogToServer(Severity.Debug, "The connection was terminated");
m_connectionManager.ReleaseConnection(state);
return;
}
catch (SocketException ex)
{
const int WSAECONNRESET = 10054;
if (ex.ErrorCode == WSAECONNRESET)
{
state.LogToServer(Severity.Debug, "The connection was forcibly closed by the remote host");
}
else
{
state.LogToServer(Severity.Debug, "The connection was terminated, Socket error code: {0}", ex.ErrorCode);
}
m_connectionManager.ReleaseConnection(state);
return;
}
if (numberOfBytesReceived == 0)
{
state.LogToServer(Severity.Debug, "The client closed the connection");
m_connectionManager.ReleaseConnection(state);
return;
}
state.UpdateLastReceiveDT();
NBTConnectionReceiveBuffer receiveBuffer = state.ReceiveBuffer;
receiveBuffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(ref state);
if (clientSocket.Connected)
{
try
{
clientSocket.BeginReceive(state.ReceiveBuffer.Buffer, state.ReceiveBuffer.WriteOffset, state.ReceiveBuffer.AvailableLength, 0, ReceiveCallback, state);
}
catch (ObjectDisposedException)
{
m_connectionManager.ReleaseConnection(state);
}
catch (SocketException)
{
m_connectionManager.ReleaseConnection(state);
}
}
}
public ConnectionState(Socket clientSocket)
{
m_clientSocket = clientSocket;
m_receiveBuffer = new NBTConnectionReceiveBuffer();
}
