private void ProcessConnectionBuffer(ConnectionState state)
{
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
while (buffer.HasCompletePDU())
{
ISCSIPDU pdu = null;
try
{
pdu = buffer.DequeuePDU();
}
catch (Exception)
{
throw;
}
if (pdu.GetType() == typeof(ISCSIPDU))
{
throw new Exception("Unsupported");
}
else
{
ProcessPDU(pdu, state);
}
}
}
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
{
ISCSIConnectionReceiveBuffer 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;
if (!m_clientSocket.Connected)
{
return;
}
int numberOfBytesReceived = 0;
try
{
numberOfBytesReceived = m_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
{
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
buffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(state);
try
{
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);
}
}
}
// This method accepts new connections
private void ConnectRequestCallback(IAsyncResult ar)
{
Socket listenerSocket = (Socket)ar.AsyncState;
Socket clientSocket;
try
{
clientSocket = listenerSocket.EndAccept(ar);
}
catch (ObjectDisposedException)
{
return;
}
catch (SocketException)
{
return;
}
Log(Severity.Information, "New connection has been accepted");
ConnectionState state = new ConnectionState();
state.ConnectionParameters.InitiatorEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
// Disable the Nagle Algorithm for this tcp socket:
clientSocket.NoDelay = true;
state.ClientSocket = clientSocket;
Thread senderThread = new Thread(delegate()
{
ProcessSendQueue(state);
});
senderThread.IsBackground = true;
senderThread.Start();
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
try
{
clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, 0, ReceiveCallback, state);
}
catch (ObjectDisposedException)
{
Log(Severity.Debug, "[OnConnectRequest] BeginReceive ObjectDisposedException");
}
catch (SocketException ex)
{
Log(Severity.Debug, "[OnConnectRequest] BeginReceive SocketException: {0}", ex.Message);
}
m_listenerSocket.BeginAccept(ConnectRequestCallback, m_listenerSocket);
}
public bool Connect(IPAddress targetAddress, int targetPort)
{
m_targetAddress = targetAddress;
m_targetPort = targetPort;
if (!m_isConnected)
{
m_clientSocket = new Socket(m_targetAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
m_clientSocket.Connect(m_targetAddress, m_targetPort);
}
catch (SocketException)
{
return(false);
}
ConnectionState state = new ConnectionState();
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
m_clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, SocketFlags.None, new AsyncCallback(OnClientSocketReceive), state);
m_isConnected = true;
}
return(m_isConnected);
}
private void ProcessConnectionBuffer(ConnectionState state)
{
Socket clientSocket = state.ClientSocket;
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
while (buffer.HasCompletePDU())
{
ISCSIPDU pdu = null;
try
{
pdu = buffer.DequeuePDU();
}
catch (Exception ex)
{
byte[] pduBytes = buffer.DequeuePDUBytes();
Log(Severity.Error, "[{0}] Failed to read PDU (Exception: {1})", state.ConnectionIdentifier, ex.Message);
RejectPDU reject = new RejectPDU();
reject.Reason = RejectReason.InvalidPDUField;
reject.Data = ByteReader.ReadBytes(pduBytes, 0, 48);
state.SendQueue.Enqueue(reject);
}
if (pdu != null)
{
if (pdu.GetType() == typeof(ISCSIPDU))
{
Log(Severity.Error, "[{0}][ProcessCurrentBuffer] Unsupported PDU (0x{1})", state.ConnectionIdentifier, pdu.OpCode.ToString("X"));
// Unsupported PDU
RejectPDU reject = new RejectPDU();
reject.InitiatorTaskTag = pdu.InitiatorTaskTag;
reject.Reason = RejectReason.CommandNotSupported;
reject.Data = ByteReader.ReadBytes(pdu.GetBytes(), 0, 48);
state.SendQueue.Enqueue(reject);
}
else
{
bool valid = ValidateCommandNumbering(pdu, state);
if (valid)
{
ProcessPDU(pdu, state);
}
else
{
// We ignore this PDU
Log(Severity.Warning, "[{0}] Ignoring PDU with CmdSN outside of expected range", state.ConnectionIdentifier);
}
}
}
if (!clientSocket.Connected)
{
// Do not continue to process the buffer if the other side closed the connection
if (buffer.BytesInBuffer > 0)
{
Log(Severity.Debug, "[{0}] Buffer processing aborted, bytes left in receive buffer: {1}", state.ConnectionIdentifier, buffer.BytesInBuffer);
}
return;
}
}
}
private void ReceiveCallback(IAsyncResult result)
{
if (!m_listening)
{
return;
}
ConnectionState state = (ConnectionState)result.AsyncState;
Socket clientSocket = state.ClientSocket;
if (!clientSocket.Connected)
{
HandleConnectionTermination(state);
return;
}
int numberOfBytesReceived;
try
{
numberOfBytesReceived = clientSocket.EndReceive(result);
}
catch (ObjectDisposedException)
{
HandleConnectionTermination(state);
Log(Severity.Debug, "[ReceiveCallback] EndReceive ObjectDisposedException");
return;
}
catch (SocketException ex)
{
HandleConnectionTermination(state);
Log(Severity.Debug, "[ReceiveCallback] EndReceive SocketException: {0}", ex.Message);
return;
}
if (numberOfBytesReceived == 0)
{
// The other side has closed the connection
Log(Severity.Verbose, "[{0}] The initiator has closed the connection", state.ConnectionIdentifier);
HandleConnectionTermination(state);
return;
}
ISCSIConnectionReceiveBuffer buffer = state.ReceiveBuffer;
buffer.SetNumberOfBytesReceived(numberOfBytesReceived);
ProcessConnectionBuffer(state);
try
{
clientSocket.BeginReceive(buffer.Buffer, buffer.WriteOffset, buffer.AvailableLength, 0, ReceiveCallback, state);
}
catch (ObjectDisposedException)
{
HandleConnectionTermination(state);
Log(Severity.Debug, "[ReceiveCallback] BeginReceive ObjectDisposedException");
}
catch (SocketException ex)
{
HandleConnectionTermination(state);
Log(Severity.Debug, "[ReceiveCallback] BeginReceive SocketException: {0}", ex.Message);
}
}
