Improved iSCSI parameter-negotiation-related code readability

ISCSI/ISCSI.Client/ClientHelper.cs

@@ -67,18 +67,18 @@ namespace ISCSI.Client
             request.LoginParameters.Add("MaxRecvDataSegmentLength", connection.InitiatorMaxRecvDataSegmentLength.ToString());
             if (!isDiscovery)
             {
-                request.LoginParameters.Add("ErrorRecoveryLevel", ISCSIClient.OfferedErrorRecoveryLevel.ToString());
-                request.LoginParameters.Add("InitialR2T", ISCSIClient.OfferedInitialR2T ? "Yes" : "No");
-                request.LoginParameters.Add("ImmediateData", ISCSIClient.OfferedImmediateData ? "Yes" : "No");
-                request.LoginParameters.Add("MaxBurstLength", ISCSIClient.OfferedMaxBurstLength.ToString());
-                request.LoginParameters.Add("FirstBurstLength", ISCSIClient.OfferedFirstBurstLength.ToString());
-                request.LoginParameters.Add("MaxConnections", ISCSIClient.OfferedMaxConnections.ToString());
-                request.LoginParameters.Add("DataPDUInOrder", ISCSIClient.OfferedDataPDUInOrder ? "Yes" : "No");
-                request.LoginParameters.Add("DataSequenceInOrder", ISCSIClient.OfferedDataSequenceInOrder ? "Yes" : "No");
-                request.LoginParameters.Add("MaxOutstandingR2T", ISCSIClient.OfferedMaxOutstandingR2T.ToString());
+                request.LoginParameters.Add("MaxConnections", ISCSIClient.DesiredParameters.MaxConnections.ToString());
+                request.LoginParameters.Add("InitialR2T", ISCSIClient.DesiredParameters.InitialR2T ? "Yes" : "No");
+                request.LoginParameters.Add("ImmediateData", ISCSIClient.DesiredParameters.ImmediateData ? "Yes" : "No");
+                request.LoginParameters.Add("MaxBurstLength", ISCSIClient.DesiredParameters.MaxBurstLength.ToString());
+                request.LoginParameters.Add("FirstBurstLength", ISCSIClient.DesiredParameters.FirstBurstLength.ToString());
+                request.LoginParameters.Add("MaxOutstandingR2T", ISCSIClient.DesiredParameters.MaxOutstandingR2T.ToString());
+                request.LoginParameters.Add("DataPDUInOrder", ISCSIClient.DesiredParameters.DataPDUInOrder ? "Yes" : "No");
+                request.LoginParameters.Add("DataSequenceInOrder", ISCSIClient.DesiredParameters.DataSequenceInOrder ? "Yes" : "No");
+                request.LoginParameters.Add("ErrorRecoveryLevel", ISCSIClient.DesiredParameters.ErrorRecoveryLevel.ToString());
             }
-            request.LoginParameters.Add("DefaultTime2Wait", ISCSIClient.OfferedDefaultTime2Wait.ToString());
-            request.LoginParameters.Add("DefaultTime2Retain", ISCSIClient.OfferedDefaultTime2Retain.ToString());
+            request.LoginParameters.Add("DefaultTime2Wait", ISCSIClient.DesiredParameters.DefaultTime2Wait.ToString());
+            request.LoginParameters.Add("DefaultTime2Retain", ISCSIClient.DesiredParameters.DefaultTime2Retain.ToString());
             
             return request;
         }
@@ -110,100 +110,139 @@ namespace ISCSI.Client
             request.LoginParameters.Add("MaxRecvDataSegmentLength", connection.InitiatorMaxRecvDataSegmentLength.ToString());
             if (targetName != null)
             {
-                request.LoginParameters.Add("ErrorRecoveryLevel", ISCSIClient.OfferedErrorRecoveryLevel.ToString());
-                request.LoginParameters.Add("InitialR2T", ISCSIClient.OfferedInitialR2T ? "Yes" : "No");
-                request.LoginParameters.Add("ImmediateData", ISCSIClient.OfferedImmediateData ? "Yes" : "No");
-                request.LoginParameters.Add("MaxBurstLength", ISCSIClient.OfferedMaxBurstLength.ToString());
-                request.LoginParameters.Add("FirstBurstLength", ISCSIClient.OfferedFirstBurstLength.ToString());
-                request.LoginParameters.Add("MaxConnections", ISCSIClient.OfferedMaxConnections.ToString());
-                request.LoginParameters.Add("DataPDUInOrder", ISCSIClient.OfferedDataPDUInOrder ? "Yes" : "No");
-                request.LoginParameters.Add("DataSequenceInOrder", ISCSIClient.OfferedDataSequenceInOrder ? "Yes" : "No");
-                request.LoginParameters.Add("MaxOutstandingR2T", ISCSIClient.OfferedMaxOutstandingR2T.ToString());
+                request.LoginParameters.Add("MaxConnections", ISCSIClient.DesiredParameters.MaxConnections.ToString());
+                request.LoginParameters.Add("InitialR2T", ISCSIClient.DesiredParameters.InitialR2T ? "Yes" : "No");
+                request.LoginParameters.Add("ImmediateData", ISCSIClient.DesiredParameters.ImmediateData ? "Yes" : "No");
+                request.LoginParameters.Add("MaxBurstLength", ISCSIClient.DesiredParameters.MaxBurstLength.ToString());
+                request.LoginParameters.Add("FirstBurstLength", ISCSIClient.DesiredParameters.FirstBurstLength.ToString());
+                request.LoginParameters.Add("MaxOutstandingR2T", ISCSIClient.DesiredParameters.MaxOutstandingR2T.ToString());
+                request.LoginParameters.Add("DataPDUInOrder", ISCSIClient.DesiredParameters.DataPDUInOrder ? "Yes" : "No");
+                request.LoginParameters.Add("DataSequenceInOrder", ISCSIClient.DesiredParameters.DataSequenceInOrder ? "Yes" : "No");
+                request.LoginParameters.Add("ErrorRecoveryLevel", ISCSIClient.DesiredParameters.ErrorRecoveryLevel.ToString());
             }
-            request.LoginParameters.Add("DefaultTime2Wait", ISCSIClient.OfferedDefaultTime2Wait.ToString());
-            request.LoginParameters.Add("DefaultTime2Retain", ISCSIClient.OfferedDefaultTime2Retain.ToString());
+            request.LoginParameters.Add("DefaultTime2Wait", ISCSIClient.DesiredParameters.DefaultTime2Wait.ToString());
+            request.LoginParameters.Add("DefaultTime2Retain", ISCSIClient.DesiredParameters.DefaultTime2Retain.ToString());
 
             return request;
         }
 
         internal static void UpdateOperationalParameters(KeyValuePairList<string, string> loginParameters, SessionParameters session, ConnectionParameters connection)
         {
-            session.InitialR2T = ISCSIClient.OfferedInitialR2T;
-            session.ImmediateData = ISCSIClient.OfferedImmediateData;
-            session.MaxBurstLength = ISCSIClient.OfferedMaxBurstLength;
-            session.FirstBurstLength = ISCSIClient.OfferedFirstBurstLength;
-            session.DefaultTime2Wait = ISCSIClient.OfferedDefaultTime2Wait;
-            session.DefaultTime2Retain = ISCSIClient.OfferedDefaultTime2Retain;
-            session.MaxOutstandingR2T = ISCSIClient.OfferedMaxOutstandingR2T;
-            session.DataPDUInOrder = ISCSIClient.OfferedDataPDUInOrder;
-            session.DataSequenceInOrder = ISCSIClient.OfferedDataSequenceInOrder;
-            session.ErrorRecoveryLevel = ISCSIClient.OfferedErrorRecoveryLevel;
-
             string value = loginParameters.ValueOf("MaxRecvDataSegmentLength");
             if (value != null)
             {
                 connection.TargetMaxRecvDataSegmentLength = Convert.ToInt32(value);
             }
 
+            value = loginParameters.ValueOf("MaxConnections");
+            if (value != null)
+            {
+                session.MaxConnections = Convert.ToInt32(value);
+            }
+            else
+            {
+                session.MaxConnections = ISCSIClient.DesiredParameters.MaxConnections;
+            }
+
             value = loginParameters.ValueOf("InitialR2T");
             if (value != null)
             {
                 session.InitialR2T = (value == "Yes") ? true : false;
             }
+            else
+            {
+                session.InitialR2T = ISCSIClient.DesiredParameters.InitialR2T;
+            }
 
             value = loginParameters.ValueOf("ImmediateData");
             if (value != null)
             {
                 session.ImmediateData = (value == "Yes") ? true : false;
             }
+            else
+            {
+                session.ImmediateData = ISCSIClient.DesiredParameters.ImmediateData;
+            }
 
             value = loginParameters.ValueOf("MaxBurstLength");
             if (value != null)
             {
                 session.MaxBurstLength = Convert.ToInt32(value);
             }
+            else
+            {
+                session.MaxBurstLength = ISCSIClient.DesiredParameters.MaxBurstLength;
+            }
 
             value = loginParameters.ValueOf("FirstBurstLength");
             if (value != null)
             {
                 session.FirstBurstLength = Convert.ToInt32(value);
             }
+            else
+            {
+                session.FirstBurstLength = ISCSIClient.DesiredParameters.FirstBurstLength;
+            }
 
             value = loginParameters.ValueOf("DefaultTime2Wait");
             if (value != null)
             {
                 session.DefaultTime2Wait = Convert.ToInt32(value);
             }
+            else
+            {
+                session.DefaultTime2Wait = ISCSIClient.DesiredParameters.DefaultTime2Wait;
+            }
 
             value = loginParameters.ValueOf("DefaultTime2Retain");
             if (value != null)
             {
                 session.DefaultTime2Retain = Convert.ToInt32(value);
             }
+            else
+            {
+                session.DefaultTime2Retain = ISCSIClient.DesiredParameters.DefaultTime2Retain;
+            }
 
             value = loginParameters.ValueOf("MaxOutstandingR2T");
             if (value != null)
             {
                 session.MaxOutstandingR2T = Convert.ToInt32(value);
             }
+            else
+            {
+                session.MaxOutstandingR2T = ISCSIClient.DesiredParameters.MaxOutstandingR2T;
+            }
 
             value = loginParameters.ValueOf("DataPDUInOrder");
             if (value != null)
             {
                 session.DataPDUInOrder = (value == "Yes") ? true : false;
             }
+            else
+            {
+                session.DataPDUInOrder = ISCSIClient.DesiredParameters.DataPDUInOrder;
+            }
 
             value = loginParameters.ValueOf("DataSequenceInOrder");
             if (value != null)
             {
                 session.DataSequenceInOrder = (value == "Yes") ? true : false;
             }
+            else
+            {
+                session.DataSequenceInOrder = ISCSIClient.DesiredParameters.DataSequenceInOrder;
+            }
 
             value = loginParameters.ValueOf("ErrorRecoveryLevel");
             if (value != null)
             {
                 session.ErrorRecoveryLevel = Convert.ToInt32(value);
             }
+            else
+            {
+                session.ErrorRecoveryLevel = ISCSIClient.DesiredParameters.ErrorRecoveryLevel;
+            }
         }
 
         internal static LogoutRequestPDU GetLogoutRequest(SessionParameters session, ConnectionParameters connection)

ISCSI/ISCSI.Client/ConnectionParameters.cs

@@ -12,15 +12,9 @@ namespace ISCSI.Client
 {
     public class ConnectionParameters
     {
-        public static int DeclaredMaxRecvDataSegmentLength = 262144;
-
         public ushort CID; // connection ID, generated by the initiator
         
-        /// <summary>
-        /// per direction parameter that the target or initator declares.
-        /// maximum data segment length that the target (or initator) can receive in a single iSCSI PDU.
-        /// </summary>
-        public int InitiatorMaxRecvDataSegmentLength = DeclaredMaxRecvDataSegmentLength;
+        public int InitiatorMaxRecvDataSegmentLength = ISCSIClient.DeclaredParameters.MaxRecvDataSegmentLength;
         public int TargetMaxRecvDataSegmentLength = DefaultParameters.Connection.MaxRecvDataSegmentLength;
 
         public bool StatusNumberingStarted;

ISCSI/ISCSI.Client/ISCSIClient.Parameters.cs

@@ -0,0 +1,40 @@
+/* Copyright (C) 2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+ * 
+ * You can redistribute this program and/or modify it under the terms of
+ * the GNU Lesser Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ */
+using System;
+
+namespace ISCSI.Client
+{
+    public partial class ISCSIClient
+    {
+        public class DesiredParameters
+        {
+            // Session parameters that will be offered to the target:
+            public static bool InitialR2T = true;
+            public static bool ImmediateData = true;
+            public static int MaxBurstLength = DefaultParameters.Session.MaxBurstLength;
+            public static int FirstBurstLength = DefaultParameters.Session.FirstBurstLength;
+            public static int DefaultTime2Wait = 0;
+            public static int DefaultTime2Retain = 20;
+            public static int MaxOutstandingR2T = 1;
+            public static bool DataPDUInOrder = true;
+            public static bool DataSequenceInOrder = true;
+            public static int ErrorRecoveryLevel = 0;
+            public static int MaxConnections = 1;
+        }
+
+        public class DeclaredParameters
+        {
+            // Connection parameters:
+            
+            /// <summary>
+            /// per direction parameter that the target or initator declares.
+            /// maximum data segment length that the target (or initator) can receive in a single iSCSI PDU.
+            /// </summary>
+            public static int MaxRecvDataSegmentLength = 262144;
+        }
+    }
+}

ISCSI/ISCSI.Client/ISCSIClient.cs

@@ -17,21 +17,8 @@ using Utilities;
 
 namespace ISCSI.Client
 {
-    public class ISCSIClient
+    public partial class ISCSIClient
     {
-        // Offered Session Parameters:
-        public static bool OfferedInitialR2T = true;
-        public static bool OfferedImmediateData = true;
-        public static int OfferedMaxBurstLength = DefaultParameters.Session.MaxBurstLength;
-        public static int OfferedFirstBurstLength = DefaultParameters.Session.FirstBurstLength;
-        public static int OfferedDefaultTime2Wait = 0;
-        public static int OfferedDefaultTime2Retain = 20;
-        public static int OfferedMaxOutstandingR2T = 1;
-        public static bool OfferedDataPDUInOrder = true;
-        public static bool OfferedDataSequenceInOrder = true;
-        public static int OfferedErrorRecoveryLevel = 0;
-        public static int OfferedMaxConnections = 1;
-
         private SessionParameters m_session = new SessionParameters();
         private ConnectionParameters m_connection = new ConnectionParameters();
 

ISCSI/ISCSI.Server/ConnectionParameters.cs

@@ -26,18 +26,12 @@ namespace ISCSI.Server
 
     public class ConnectionParameters
     {
-        public static int DeclaredMaxRecvDataSegmentLength = 262144;
-
         public ushort CID; // connection ID, generated by the initiator
         public string InitiatorName = String.Empty;
         public IPEndPoint InitiatorEndPoint;
 
-        /// <summary>
-        /// per direction parameter that the target or initator declares.
-        /// maximum data segment length that the target (or initator) can receive in a single iSCSI PDU.
-        /// </summary>
         public int InitiatorMaxRecvDataSegmentLength = DefaultParameters.Connection.MaxRecvDataSegmentLength;
-        public int TargetMaxRecvDataSegmentLength = DeclaredMaxRecvDataSegmentLength;
+        public int TargetMaxRecvDataSegmentLength = ISCSIServer.DeclaredParameters.MaxRecvDataSegmentLength;
 
         public uint StatSN = 0; // Initial StatSN, any number will do
         // Dictionary of current transfers: <transfer-tag, TransferEntry>

ISCSI/ISCSI.Server/ISCSIServer.Parameters.cs

@@ -0,0 +1,40 @@
+/* Copyright (C) 2012-2016 Tal Aloni <tal.aloni.il@gmail.com>. All rights reserved.
+ * 
+ * You can redistribute this program and/or modify it under the terms of
+ * the GNU Lesser Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ */
+using System;
+
+namespace ISCSI.Server
+{
+    public partial class ISCSIServer
+    {
+        public class DesiredParameters
+        {
+            // Session parameters that will be offered to the initiator:
+            public static bool InitialR2T = true; // implementation limit
+            public static bool ImmediateData = true;
+            public static int MaxBurstLength = DefaultParameters.Session.MaxBurstLength;
+            public static int FirstBurstLength = DefaultParameters.Session.FirstBurstLength;
+            public static int DefaultTime2Wait = 0;
+            public static int DefaultTime2Retain = 20;
+            public static int MaxOutstandingR2T = 1; // implementation limit
+            public static bool DataPDUInOrder = true; // implementation limit
+            public static bool DataSequenceInOrder = true; // implementation limit
+            public static int ErrorRecoveryLevel = 0; // implementation limit
+            public static int MaxConnections = 1; // implementation limit
+        }
+
+        public class DeclaredParameters
+        {
+            // Connection parameters:
+
+            /// <summary>
+            /// per direction parameter that the target or initator declares.
+            /// maximum data segment length that the target (or initator) can receive in a single iSCSI PDU.
+            /// </summary>
+            public static int MaxRecvDataSegmentLength = 262144;
+        }
+    }
+}

ISCSI/ISCSI.Server/ISCSIServer.cs

@@ -17,23 +17,10 @@ namespace ISCSI.Server
 {
     public delegate ushort GetNextTSIH();
 
-    public class ISCSIServer // Server may serve more than one target
+    public partial class ISCSIServer // Server may serve more than one target
     {
         public const int DefaultPort = 3260;
 
-        // Offered Session Parameters:
-        public static bool OfferedInitialR2T = true;
-        public static bool OfferedImmediateData = true;
-        public static int OfferedMaxBurstLength = DefaultParameters.Session.MaxBurstLength;
-        public static int OfferedFirstBurstLength = DefaultParameters.Session.FirstBurstLength;
-        public static int OfferedDefaultTime2Wait = 0;
-        public static int OfferedDefaultTime2Retain = 20;
-        public static int OfferedMaxOutstandingR2T = 1;
-        public static bool OfferedDataPDUInOrder = true;
-        public static bool OfferedDataSequenceInOrder = true;
-        public static int OfferedErrorRecoveryLevel = 0;
-        public static int OfferedMaxConnections = 1;
-
         private List<ISCSITarget> m_targets;
         private int m_port;
         private ushort m_nextTSIH = 1; // Next Target Session Identifying Handle

ISCSI/ISCSI.Server/ServerResponseHelper.cs

@@ -187,64 +187,64 @@ namespace ISCSI.Server
                 connectionParameters.InitiatorMaxRecvDataSegmentLength = Convert.ToInt32(value);
             }
 
-            value = loginParameters.ValueOf("InitialR2T");
+            value = loginParameters.ValueOf("MaxConnections");
             if (value != null)
             {
-                sessionParameters.InitialR2T = (value == "Yes") || ISCSIServer.OfferedInitialR2T;
+                sessionParameters.MaxConnections = Math.Min(Convert.ToInt32(value), ISCSIServer.DesiredParameters.MaxConnections);
             }
 
-            value = loginParameters.ValueOf("ImmediateData");
+            value = loginParameters.ValueOf("InitialR2T");
             if (value != null)
             {
-                sessionParameters.ImmediateData = (value == "Yes") && ISCSIServer.OfferedImmediateData;
+                sessionParameters.InitialR2T = (value == "Yes") || ISCSIServer.DesiredParameters.InitialR2T;
             }
 
-            value = loginParameters.ValueOf("MaxBurstLength");
+            value = loginParameters.ValueOf("ImmediateData");
             if (value != null)
             {
-                sessionParameters.MaxBurstLength = Math.Min(Convert.ToInt32(value), ISCSIServer.OfferedMaxBurstLength);
+                sessionParameters.ImmediateData = (value == "Yes") && ISCSIServer.DesiredParameters.ImmediateData;
             }
 
-            value = loginParameters.ValueOf("FirstBurstLength");
+            value = loginParameters.ValueOf("MaxBurstLength");
             if (value != null)
             {
-                sessionParameters.FirstBurstLength = Math.Min(Convert.ToInt32(value), ISCSIServer.OfferedFirstBurstLength);
+                sessionParameters.MaxBurstLength = Math.Min(Convert.ToInt32(value), ISCSIServer.DesiredParameters.MaxBurstLength);
             }
 
-            value = loginParameters.ValueOf("MaxConnections");
+            value = loginParameters.ValueOf("FirstBurstLength");
             if (value != null)
             {
-                sessionParameters.MaxConnections = Math.Min(Convert.ToInt32(value), ISCSIServer.OfferedMaxConnections);
+                sessionParameters.FirstBurstLength = Math.Min(Convert.ToInt32(value), ISCSIServer.DesiredParameters.FirstBurstLength);
             }
 
             value = loginParameters.ValueOf("DataPDUInOrder");
             if (value != null)
             {
-                sessionParameters.DataPDUInOrder = (value == "Yes") || ISCSIServer.OfferedDataPDUInOrder;
+                sessionParameters.DataPDUInOrder = (value == "Yes") || ISCSIServer.DesiredParameters.DataPDUInOrder;
             }
 
             value = loginParameters.ValueOf("DataSequenceInOrder");
             if (value != null)
             {
-                sessionParameters.DataSequenceInOrder = (value == "Yes") || ISCSIServer.OfferedDataSequenceInOrder;
+                sessionParameters.DataSequenceInOrder = (value == "Yes") || ISCSIServer.DesiredParameters.DataSequenceInOrder;
             }
 
             value = loginParameters.ValueOf("DefaultTime2Wait");
             if (value != null)
             {
-                sessionParameters.DefaultTime2Wait = Math.Max(Convert.ToInt32(value), ISCSIServer.OfferedDefaultTime2Wait);
+                sessionParameters.DefaultTime2Wait = Math.Max(Convert.ToInt32(value), ISCSIServer.DesiredParameters.DefaultTime2Wait);
             }
 
             value = loginParameters.ValueOf("DefaultTime2Retain");
             if (value != null)
             {
-                sessionParameters.DefaultTime2Retain = Math.Min(Convert.ToInt32(value), ISCSIServer.OfferedDefaultTime2Retain);
+                sessionParameters.DefaultTime2Retain = Math.Min(Convert.ToInt32(value), ISCSIServer.DesiredParameters.DefaultTime2Retain);
             }
 
             value = loginParameters.ValueOf("MaxOutstandingR2T");
             if (value != null)
             {
-                sessionParameters.MaxOutstandingR2T = Math.Min(Convert.ToInt32(value), ISCSIServer.OfferedMaxOutstandingR2T);
+                sessionParameters.MaxOutstandingR2T = Math.Min(Convert.ToInt32(value), ISCSIServer.DesiredParameters.MaxOutstandingR2T);
             }
         }
 
@@ -256,15 +256,15 @@ namespace ISCSI.Server
             loginParameters.Add("MaxRecvDataSegmentLength", connectionParameters.TargetMaxRecvDataSegmentLength.ToString());
             if (!sessionParameters.IsDiscovery)
             {
-                loginParameters.Add("ErrorRecoveryLevel", ISCSIServer.OfferedErrorRecoveryLevel.ToString());
+                loginParameters.Add("MaxConnections", sessionParameters.MaxConnections.ToString());
                 loginParameters.Add("InitialR2T", sessionParameters.InitialR2T ? "Yes" : "No");    // Microsoft iSCSI Target support InitialR2T = No
                 loginParameters.Add("ImmediateData", sessionParameters.ImmediateData ? "Yes" : "No");
                 loginParameters.Add("MaxBurstLength", sessionParameters.MaxBurstLength.ToString());
                 loginParameters.Add("FirstBurstLength", sessionParameters.FirstBurstLength.ToString());
-                loginParameters.Add("MaxConnections", sessionParameters.MaxConnections.ToString());
+                loginParameters.Add("MaxOutstandingR2T", sessionParameters.MaxOutstandingR2T.ToString());
                 loginParameters.Add("DataPDUInOrder", sessionParameters.DataPDUInOrder ? "Yes" : "No");
                 loginParameters.Add("DataSequenceInOrder", sessionParameters.DataSequenceInOrder ? "Yes" : "No");
-                loginParameters.Add("MaxOutstandingR2T", sessionParameters.MaxOutstandingR2T.ToString());
+                loginParameters.Add("ErrorRecoveryLevel", sessionParameters.ErrorRecoveryLevel.ToString());
             }
             loginParameters.Add("DefaultTime2Wait", sessionParameters.DefaultTime2Wait.ToString());
             loginParameters.Add("DefaultTime2Retain", sessionParameters.DefaultTime2Retain.ToString());

ISCSI/ISCSI.csproj

@@ -38,6 +38,7 @@
     <Compile Include="ISCSI.Client\ConnectionState.cs" />
     <Compile Include="ISCSI.Client\DefaultParameters.cs" />
     <Compile Include="ISCSI.Client\ISCSIClient.cs" />
+    <Compile Include="ISCSI.Client\ISCSIClient.Parameters.cs" />
     <Compile Include="ISCSI.Client\ISCSIDisk.cs" />
     <Compile Include="ISCSI.Client\PDUHelper.cs" />
     <Compile Include="ISCSI.Client\SessionParameters.cs" />
@@ -68,6 +69,7 @@
     <Compile Include="ISCSI.Server\DefaultParameters.cs" />
     <Compile Include="ISCSI.Server\Exceptions\InvalidTargetTransferTagException.cs" />
     <Compile Include="ISCSI.Server\ISCSIServer.cs" />
+    <Compile Include="ISCSI.Server\ISCSIServer.Parameters.cs" />
     <Compile Include="ISCSI.Server\ISCSITarget.cs" />
     <Compile Include="ISCSI.Server\PDUHelper.cs" />
     <Compile Include="ISCSI.Server\ServerResponseHelper.cs" />

ISCSIConsole/Program.SetCommand.cs

@@ -52,8 +52,8 @@ namespace ISCSIConsole
                         return;
                     }
 
-                    ConnectionParameters.DeclaredMaxRecvDataSegmentLength = requestedMaxRecvDataSegmentLength;
-                    Console.WriteLine("MaxRecvDataSegmentLength has been set to " + ISCSIServer.OfferedMaxBurstLength);
+                    ISCSIServer.DeclaredParameters.MaxRecvDataSegmentLength = requestedMaxRecvDataSegmentLength;
+                    Console.WriteLine("MaxRecvDataSegmentLength has been set to " + ISCSIServer.DesiredParameters.MaxBurstLength);
                 }
 
                 if (parameters.ContainsKey("MaxBurstLength".ToLower()))
@@ -65,13 +65,13 @@ namespace ISCSIConsole
                         return;
                     }
 
-                    ISCSIServer.OfferedMaxBurstLength = requestedMaxBurstLength;
-                    Console.WriteLine("Offered MaxBurstLength has been set to " + ISCSIServer.OfferedMaxBurstLength);
-                    if (ISCSIServer.OfferedMaxBurstLength < ISCSIServer.OfferedFirstBurstLength)
+                    ISCSIServer.DesiredParameters.MaxBurstLength = requestedMaxBurstLength;
+                    Console.WriteLine("Offered MaxBurstLength has been set to " + ISCSIServer.DesiredParameters.MaxBurstLength);
+                    if (ISCSIServer.DesiredParameters.MaxBurstLength < ISCSIServer.DesiredParameters.FirstBurstLength)
                     {
                         // FirstBurstLength MUST NOT exceed MaxBurstLength
-                        ISCSIServer.OfferedFirstBurstLength = ISCSIServer.OfferedMaxBurstLength;
-                        Console.WriteLine("Offered FirstBurstLength has been set to " + ISCSIServer.OfferedFirstBurstLength);
+                        ISCSIServer.DesiredParameters.FirstBurstLength = ISCSIServer.DesiredParameters.MaxBurstLength;
+                        Console.WriteLine("Offered FirstBurstLength has been set to " + ISCSIServer.DesiredParameters.FirstBurstLength);
                     }
                 }
 
@@ -84,13 +84,13 @@ namespace ISCSIConsole
                         return;
                     }
 
-                    ISCSIServer.OfferedFirstBurstLength = requestedFirstBurstLength;
-                    Console.WriteLine("Offered FirstBurstLength has been set to " + ISCSIServer.OfferedFirstBurstLength);
-                    if (ISCSIServer.OfferedMaxBurstLength < ISCSIServer.OfferedFirstBurstLength)
+                    ISCSIServer.DesiredParameters.FirstBurstLength = requestedFirstBurstLength;
+                    Console.WriteLine("Offered FirstBurstLength has been set to " + ISCSIServer.DesiredParameters.FirstBurstLength);
+                    if (ISCSIServer.DesiredParameters.MaxBurstLength < ISCSIServer.DesiredParameters.FirstBurstLength)
                     {
                         // FirstBurstLength MUST NOT exceed MaxBurstLength
-                        ISCSIServer.OfferedMaxBurstLength = ISCSIServer.OfferedFirstBurstLength;
-                        Console.WriteLine("Offered MaxBurstLength has been set to " + ISCSIServer.OfferedMaxBurstLength);
+                        ISCSIServer.DesiredParameters.MaxBurstLength = ISCSIServer.DesiredParameters.FirstBurstLength;
+                        Console.WriteLine("Offered MaxBurstLength has been set to " + ISCSIServer.DesiredParameters.MaxBurstLength);
                     }
                 }
             }