FCC/Extension/WayneClassicFdcClient/FControlFUSIONCF/IFSFSockets.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Xml.Serialization;
using System.IO;

using System.Net;
using System.Net.Sockets;

//using DWItaly.Sinp.Utility;
using Wayne.Lib;
using Wayne.FDCPOSLibrary;
using Wayne.FDCPOSLibrary.Configuration;


namespace Wayne.ForecourtControl.Fusion
{
    public class TCPListenerThread
    {
        public bool bRunning = false;

        public bool bTerminate = false;
        TcpListener tcpListener = null;
        IFSFManager ifsfManager = null;
        string name = "";

        public TCPListenerThread(TcpListener _listener, IFSFManager _ifsfManager, string _name)
        {
            tcpListener = _listener;
            ifsfManager = _ifsfManager;
            name = _name;
        }

        public void TCPListenerThreadProc()
        {
            Trace.WriteLine(string.Format("TCPListenerThreadProc Id={0}, WId={1}: init", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID));
            TcpClient tcpclient = null;
            bRunning = true;
            try
            {
                if (tcpListener != null)
                {
                    Trace.WriteLine("tcpListener starting");
                    tcpListener.Start();
                    Trace.WriteLine("tcpListener started");
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("TCPListenerThreadProc: Exception tcpListener.Start! " + ex.Message + " - " + ex.StackTrace);
                bRunning = false;
                return;
            }

            bTerminate = false;
            string sbuffer = "";
            OverallResult result = OverallResult.Success;
            NetworkStream networkStream = null;
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            while (!bTerminate)
            {
                try
                {
                    result = OverallResult.Success;

                    if (tcpclient == null && tcpListener != null) //-- || !tcpclient.Connected)
                    {
                        Trace.WriteLine("TCPListenerThreadProc: TcpClient Accepting");
                        tcpclient = tcpListener.AcceptTcpClient();
                        Trace.WriteLine("TcpClient Accepted");
                    }
                    else
                    {
                        //Trace.WriteLine(string.Format("{0} getting stream ...", this.name));
                        if (tcpListener != null)
                            networkStream = tcpclient.GetStream();
                        else if (ifsfManager.clientSocket.socketReqChannelA != null)  // Disconnet() makes _socketRequChannelA to null!!!
                            networkStream = ifsfManager.clientSocket.socketReqChannelA.GetStream();
                        else
                        {
                            Trace.WriteLine("Both tcpListener and socketReqChannelA are null!!! break out - Id=" + this.ifsfManager.clientSocket.Id);
                            break;
                        }

                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("TCPListenerThreadProc Id={0}, WId={1}: {2} got stream ...", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID, this.name));
                        StringBuilder sb = new StringBuilder();


                        // read header
                        byte[] header;
                        int headerLength, encrStart;
                        if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                        {
                            headerLength = Define.HeaderLength + Define.MD5EncriptionLength;
                            encrStart = Define.HeaderLength;
                        }
                        else if (this.ifsfManager.clientSocket.headerEncryption != 0)
                        {
                            headerLength = Define.HeaderLength + Define.EncriptionTypeLength + Define.MD5EncriptionLength;
                            encrStart = Define.HeaderLength + Define.EncriptionTypeLength;
                        }
                        else
                        {
                            headerLength = Define.HeaderLength + Define.EncriptionTypeLength;
                            encrStart = Define.HeaderLength + Define.EncriptionTypeLength;
                        }
                        header = new byte[headerLength];
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("TCPListenerThreadProc: header length={0}", header.GetLength(0)));
                        int nread = 0, nreadtot = 0;
                        do
                        {
                            Trace.WriteLineIf(Trace.CheckTraceLevel(4), string.Format("TCPListenerThreadProc: reading ..."));
                            nread = networkStream.Read(header, nreadtot, (headerLength) - nreadtot);
                            Trace.WriteLineIf(Trace.CheckTraceLevel(4), string.Format("TCPListenerThreadProc Id={0}, WId={1}: read '{2}' bytes", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID, nread));
                            nreadtot += nread;
                            if (nread == 0)
                                Thread.Sleep(500);
                        }
                        while (nreadtot < headerLength);
                        int msglength = getMsgLength(header);
                        // There're some cases that msglenght was huge > 120mb
                        if (msglength > 40000)
                            throw new System.OutOfMemoryException("Wayne's exception: Out of memory");

                        // read message
                        byte[] buffer;
                        buffer = new byte[msglength];
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("TCPListenerThreadProc: buffer msg length={0}", buffer.GetLength(0)));
                        nreadtot = 0;
                        do
                        {
                            Trace.WriteLineIf(Trace.CheckTraceLevel(4), string.Format("TCPListenerThreadProc: reading ..."));
                            nread = networkStream.Read(buffer, nreadtot, msglength - nreadtot);
                            Trace.WriteLineIf(Trace.CheckTraceLevel(4), string.Format("TCPListenerThreadProc Id={0}, WId={1}: read '{2}' bytes", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID, nread));
                            nreadtot += nread;
                            if (nread == 0)
                                Thread.Sleep(500);
                        }
                        while (!bTerminate && (nreadtot < msglength));

                        sb.Remove(0, sb.Length);
                        sb.Append(Encoding.UTF8.GetString(buffer, 0, nreadtot));
                        Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("TCPListenerThreadProc Id={0}, WId={1}: read '{2}' bytes: {3}", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID, msglength, Encoding.ASCII.GetString(buffer, 0, msglength)));

                        sbuffer += sb.ToString();

                        bool bEnd = false;
                        string sEndmsg = "", smsg = "";
                        int indexEndMsgSR = -1, indexEndFDCMsg = -1, indexEnd = -1;
                        indexEnd = sbuffer.IndexOf("/>");
                        //Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("indexend={0}, buffer={1}", indexEnd, sbuffer));

                        do
                        {
                            indexEndMsgSR = sbuffer.IndexOf("</ServiceResponse>");
                            indexEndFDCMsg = sbuffer.IndexOf("</FDCMessage>");
                            if (indexEndMsgSR >= 0 && indexEndFDCMsg >= 0)
                            {
                                indexEnd = System.Math.Min(indexEndMsgSR, indexEndFDCMsg);
                                if (indexEndMsgSR < indexEndFDCMsg)
                                {
                                    sEndmsg = "</ServiceResponse>";
                                    indexEndFDCMsg = -1;
                                }
                                else
                                {
                                    sEndmsg = "</FDCMessage>";
                                    indexEndMsgSR = -1;
                                }
                            }
                            else if (indexEndMsgSR >= 0 && indexEndFDCMsg < 0)
                            {
                                indexEnd = indexEndMsgSR;
                                sEndmsg = "</ServiceResponse>";
                            }
                            else if (indexEndFDCMsg > 0)
                            {
                                indexEnd = indexEndFDCMsg;
                                sEndmsg = "</FDCMessage>";
                            }
                            else
                            {
                                indexEnd = sbuffer.IndexOf("/>");
                                sEndmsg = "/>";
                            }
                            if (indexEnd >= 0)
                            {
                                smsg = sbuffer.Substring(0, indexEnd + sEndmsg.Length);
                                sbuffer = sbuffer.Substring(indexEnd + sEndmsg.Length);
                                //Trace.WriteLine(string.Format("smsg={0}, sbuffer={1}", smsg, sbuffer));
                                //string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "CheckEncryption");
                                if (this.ifsfManager.clientSocket.headerEncryption != 0)
                                {
                                    MD5Crypter crypter = new MD5Crypter();
                                    if (!crypter.verifyMD5Hash(smsg + MD5Crypter.passphrase, System.Text.Encoding.ASCII.GetString(header, Define.HeaderLength, Define.MD5EncriptionLength)))
                                        result = OverallResult.ValidationError;
                                }
                                if (smsg.Length > 0)
                                {
                                    if (indexEndMsgSR >= 0)
                                        ifsfManager.ReadResponse(smsg, msglength, ref result);
                                    else if (indexEndFDCMsg > 0)
                                        ifsfManager.ReadMessage(smsg, msglength, ref result);
                                }
                            }
                            else bEnd = true;
                        } while (!bEnd);
                    }
                }
                catch (SocketException sex)
                {
                    Trace.WriteLine("Exception TCPListenerThreadProc: " + sex.Message);
                    tcpclient = null;
                    if (sex.ErrorCode == 10049)
                        ifsfManager.Disconnect();
                    Thread.Sleep(1000);
                }
                catch (Exception ex)
                {
                    tcpclient = null;
                    ifsfManager.isForcedToDisconnect = true;
                    Trace.WriteLine(string.Format("Exception TCPListenerThreadProc! {0}, Id={1}", ex.Message + " - " + ex.StackTrace, this.ifsfManager.clientSocket.Id));
                    ifsfManager.Disconnect();
                    bTerminate = true; // WJU - get out of the loop since Disconnect was called already. This is a quicker way out.
                }
            }
            if (tcpListener != null)
                tcpListener.Stop();
            bRunning = false;
            Trace.WriteLine(string.Format("TCPListenerThreadProc Id={0}, WId={1}: end", this.ifsfManager.clientSocket.Id, this.ifsfManager.clientSocket.workstationID));
        }

        private bool checkHash(string smsg, int encrStart, byte[] header)
        {
            MD5Crypter crypter = new MD5Crypter();
            byte[] datahash = crypter.ComputeHash(System.Text.Encoding.UTF8.GetBytes(smsg + MD5Crypter.passphrase));
            byte[] inputhash;
            inputhash = new byte[Define.MD5EncriptionLength];
            for (int i = encrStart; i < Define.MD5EncriptionLength + encrStart; i++)
                inputhash[i - encrStart] = header[i];
            bool error = false;
            for (int i = 0; i < Define.MD5EncriptionLength; i++)
                if (inputhash[i] != datahash[i])
                {
                    Trace.WriteLine(string.Format("ValidationError: inputhash={0}, datahash={1}", System.Text.Encoding.UTF8.GetString(inputhash, 0, inputhash.GetLength(0)), System.Text.Encoding.UTF8.GetString(datahash, 0, datahash.GetLength(0))));
                    Trace.WriteLine(string.Format("ValidationError: inputhash[{0}]={1} != datahash[{2}]={3}", i, inputhash[i], i, datahash[i]));
                    error = true;
                    break;
                }
            return error;
        }

        private int getMsgLength(byte[] header)
        {
            int length = 0;
            for (int pos = 1; pos <= Define.HeaderLength; pos++)
            {
                length |= ((int)(header[pos - 1] << (Define.HeaderLength - pos) * 8));
            }
            return length;
        }
    }


    public class IFSFSockets : IIdentifiableEntity, IDisposable//, IConnectable
    {
        private TcpClient _socketReqChannelA = null;
        public TcpClient socketReqChannelA
        {
            get { return _socketReqChannelA; }
        }

        private TcpListener _socketRespChannelB = null;
        public TcpListener socketRespChannelB
        {
            get { return _socketRespChannelB; }
        }

        private TcpListener _socketUnsolicitedChannelC = null;
        public TcpListener socketUnsolicitedChannelC
        {
            get { return _socketUnsolicitedChannelC; }
        }

        private TcpClient _socketReqChannelConfig = null;
        public TcpClient socketReqChannelConfig
        {
            get { return _socketReqChannelConfig; }
        }

        public TCPListenerThread respChannelBThreadObj;
        public Thread respChannelBThread;
        public TCPListenerThread unsolicitedChannelCThreadObj;
        public Thread unsolicitedChannelCThread;
        public TCPListenerThread respChannelConfigThreadObj;
        public Thread respChannelConfigThread;

        IFSFManager ifsfManager = null;

        IFSFMessages _ifsfMessages = null;
        public IFSFMessages ifsfMessages
        {
            get { return _ifsfMessages; }
        }

        private string _applicationSender = "";
        public string applicationSender
        {
            get { return _applicationSender; }
        }
        private string _workstationID = "";
        public string workstationID
        {
            get { return _workstationID; }
        }
        private string _sIPAddress = "";
        public string sIPAddress
        {
            get { return _sIPAddress; }
        }
        private string _sIPAddress2 = "";
        public string sIPAddress2
        {
            get { return _sIPAddress2; }
        }

        private int _iIPPortA = 0;
        public int iIPPortA
        {
            get { return _iIPPortA; }
        }
        private int _iIPPortB = 0;
        public int iIPPortB
        {
            get { return _iIPPortB; }
        }
        private int _iIPPortC = 0;
        public int iIPPortC
        {
            get { return _iIPPortC; }
        }

        private long _heartbeatInterval = 20000;
        public long heartbeatInterval
        {
            get { return _heartbeatInterval; }
        }

        private long _heartbeatTimeout = 20000;
        public long heartbeatTimeout
        {
            get { return _heartbeatTimeout; }
        }

        private long _headerEncryption = 1;
        public long headerEncryption
        {
            get { return _headerEncryption; }
            set { _headerEncryption = value; }
        }

        public bool logOnSendCalled = false;
        private byte[][] _validationInfo = null;
        public byte[][] validationInfo
        {
            get { return _validationInfo; }
            set { _validationInfo = value; }
        }

        private string _posInfo = "";
        public string posInfo
        {
            get { return _posInfo; }
            set { _posInfo = value; }
        }

        private bool disposed;
        private int id;
        private IIdentifiableEntity parentEntity;

        private object _socketLockObject = new object();
        internal object SocketLockObject
        {
            get { return _socketLockObject; }
        }

        private DeviceConnectionState _mainConnectionState = DeviceConnectionState.Disconnected;
        public DeviceConnectionState mainConnectionState
        {
            get { return _mainConnectionState; }
            set
            {
                lock (SocketLockObject)
                {
                    if (_mainConnectionState != value)
                    {
                        _mainConnectionState = value;
                        if (OnConnectionStateChange != null)
                        {
                            OnConnectionStateChange.Invoke(this, new ConnectionChangedEventArgs(mainConnectionState));
                        }
                    }
                }
            }
        }

        public event EventHandler<ConnectionChangedEventArgs> OnConnectionStateChange;
        public event EventHandler OnResponseTimeout;
        public readonly ConfigurationParams configParam;

        public IFSFSockets(int id, IFSFManager _ifsfManager/*, IIdentifiableEntity parentEntity*/)
        {
            this.id = id;
            this.parentEntity = (IIdentifiableEntity)ifsfManager;
            ifsfManager = _ifsfManager;

            configParam = _ifsfManager.ConfigParam;
            this._applicationSender = configParam.applicationSender;
            this._workstationID = configParam.workstationID;
            this._sIPAddress = configParam.sIPAddress;
            this._sIPAddress2 = configParam.sIPAddress2;
            this._iIPPortA = configParam.iIPPortA;
            this._iIPPortB = configParam.iIPPortB;
            this._iIPPortC = configParam.iIPPortC;
            this._heartbeatTimeout = configParam.heartbeatTimeout;
            this._heartbeatInterval = configParam.heartbeatInterval;
            this._headerEncryption = configParam.headerEncryption;

            _ifsfMessages = new IFSFMessages(this);
            _ifsfMessages.OnIFSFSMessageEnqueued += new EventHandler(ifsfmessages_OnMessageEnqueued);
            _ifsfMessages.OnResponseTimeout += new EventHandler(ifsfmessages_OnResponseTimeout);
        }

        private bool getConnectionParams(string connectionString)
        {
            Dictionary<string, string> connectionStringParamDict;
            connectionStringParamDict = Strings.ParseConnectionString(connectionString);
            string key = "";

            key = "IdShift";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    ((FUSIONForecourtControl)(FUSIONFactory.fusionForecourtControlList[this.Id])).manager.IdShift = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IdShift: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }

            key = "IdPumpShift";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    ((FUSIONForecourtControl)(FUSIONFactory.fusionForecourtControlList[this.Id])).manager.IdPumpShift = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IdPumpShift: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }

            key = "IdNozzleShift";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    ((FUSIONForecourtControl)(FUSIONFactory.fusionForecourtControlList[this.Id])).manager.IdNozzleShift = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IdNozzleShift: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }

            key = "IdTankShift";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    ((FUSIONForecourtControl)(FUSIONFactory.fusionForecourtControlList[this.Id])).manager.IdTankShift = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IdTankShift: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }

            key = "Host";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
                this._sIPAddress = connectionStringParamDict[key];
            key = "Host2";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
                this._sIPAddress2 = connectionStringParamDict[key];
            key = "Port";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._iIPPortA = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IPPortA: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            key = "PortB";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._iIPPortB = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IPPortB: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            key = "PortC";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._iIPPortC = Convert.ToInt32(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading IPPortC: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            //key = "workstationID";
            //if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            //    this._applicationSender = connectionStringParamDict[key];
            //else
            //{
            //    key = "ClientName";
            //    if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            //        this._applicationSender = connectionStringParamDict[key];
            //}
            //key = "applicationSender";
            //if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            //    this._workstationID = connectionStringParamDict[key];
            //else
            //{
            //    key = "ClientId";
            //    if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            //        this._workstationID = connectionStringParamDict[key];
            //}

            key = "ClientId";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                this._workstationID = connectionStringParamDict[key];
                this._applicationSender = connectionStringParamDict[key];
            }
            else
            {
                key = "applicationSender";
                if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
                {
                    this._workstationID = connectionStringParamDict[key];
                    this._applicationSender = connectionStringParamDict[key];
                }
            }

            key = "heartbeatInterval";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._heartbeatInterval = Convert.ToInt16(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading heartbeatInterval: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            key = "heartbeatTimeout";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._heartbeatTimeout = Convert.ToInt16(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading _heartbeatTimeout: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            key = "headerEncryption";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                try
                {
                    this._headerEncryption = Convert.ToInt16(connectionStringParamDict[key]);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading _headerEncryption: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            key = "posInfo";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
                this._posInfo = connectionStringParamDict[key];
            key = "validationInfo";
            if (connectionStringParamDict.ContainsKey(key) && connectionStringParamDict[key] != null && connectionStringParamDict[key] != "")
            {
                string[] validationInfoArray;
                try
                {
                    //validationInfoArray = connectionStringParamDict[key].Split('@');
                    //this._validationInfo = new byte[validationInfoArray.Length][];
                    //int i = 0;
                    //foreach(string s in validationInfoArray)
                    //{


                    string s = connectionStringParamDict[key];
                    string elem;
                    while (s.Length > 0)
                    {
                        if (s.IndexOf("@@@") >= 0)
                        {
                            elem = s.Substring(0, s.IndexOf("@@@"));
                            s = s.Substring(s.IndexOf("@@@") + 3);
                        }
                        else
                        {
                            elem = s;
                            s = "";
                        }
                        //DESCrypter descrypter = new DESCrypter();
                        //byte[] dataencrypted = descrypter.Encrypt(elem);

                        byte[] b = System.Text.Encoding.Unicode.GetBytes(elem);

                        this.ifsfManager.LogOnAddValidationInfo(b);

                        //IFSFManager.ArrayResize<byte[]>(ref _validationInfo, (_validationInfo != null) ? _validationInfo.Length + 1 : 1);
                        //this._validationInfo[_validationInfo.Length-1] = new byte[dataencrypted.Length];
                        //this._validationInfo[_validationInfo.Length-1] = dataencrypted;
                    }
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("Exception reading _validationInfo: {0}", ex.Message + " - " + ex.StackTrace));
                }
            }
            return true;
        }


        public void SendConfig(string commandFileName)
        {
            if (this.mainConnectionState == DeviceConnectionState.Connected)
            {
                int iIPPortConfig = Convert.ToInt32(IniFile.IniReadValue(ConfigurationParams.getSINPPath("ini\\") + @"ForecourtServer.ini", "FUSION-Connection", "IPPortConfig"));
                try
                {
                    IPAddress serverIPAddress = null;
                    IPEndPoint endPoint = null;
                    bool bIPAddress = false;

                    if (iIPPortConfig != this._iIPPortA)
                    {
                        int socketTimeout = 3000;
                        bool noDelay = true;
                        try
                        {
                            string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "SocketTimeout");
                            if (sValue.Length > 0)
                                socketTimeout = Convert.ToInt32(sValue);
                            Trace.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                            sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "NoDelay");
                            if (sValue.Length > 0 && sValue == "0")
                                noDelay = false;
                            Trace.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                        }
                        catch (Exception ex)
                        {
                            Trace.WriteLine("EXCEPTION! " + ex.Message);
                        }

                        _socketReqChannelConfig = new TcpClient();
                        _socketReqChannelConfig.SendTimeout = socketTimeout;
                        _socketReqChannelConfig.NoDelay = noDelay;
                        int retrycount = 0;

                        bool bConnected = false;
                        string ipAddress = this._sIPAddress;
                        string error = "";
                        while (!bConnected)
                        {
                            if (retrycount == 5)
                            {
                                if (this._sIPAddress2 != "") ipAddress = this._sIPAddress2;
                                Trace.WriteLine(error);
                            }
                            else if (retrycount == 10)
                            {
                                retrycount = 0;
                                ipAddress = this._sIPAddress;
                                Trace.WriteLine(error);
                                Thread.Sleep(5000);
                            }
                            retrycount++;

                            try
                            {
                                socketReqChannelConfig.Connect(ipAddress, iIPPortConfig);
                                bConnected = true;
                            }
                            catch (SocketException sex)
                            {
                                Trace.WriteLine(sex.Message + " - " + sex.StackTrace);
                                if (sex.ErrorCode == 10049)
                                    bIPAddress = false;
                                Thread.Sleep(1000);
                            }
                        }
                        respChannelConfigThreadObj = new TCPListenerThread(null, ifsfManager, "ChannelConfig");
                        respChannelConfigThread = new Thread(new ThreadStart(respChannelConfigThreadObj.TCPListenerThreadProc));
                        respChannelConfigThread.Start();
                    }
                    else
                        _socketReqChannelConfig = this._socketReqChannelA;

                    Thread.Sleep(2000);

                    // start reading file with config messages
                    string line, xmlconfigfile = ConfigurationParams.getSINPPath("ini\\") + commandFileName;
                    StringBuilder sb = new StringBuilder(); ;
                    StreamReader sr = new StreamReader(xmlconfigfile);
                    while (sr.Peek() != -1)
                    {
                        line = sr.ReadLine();
                        sb.Append(line);
                    }
                    sr.Close();
                    string allconfig = sb.ToString();
                    //string allconfig = sr.ReadToEnd();
                    string[] messages;
                    string msg2;
                    messages = allconfig.Split('#');
                    foreach (string msg in messages)
                    {
                        msg2 = msg;
                        //msg2 = msg.Replace("\r", "");
                        //msg2 = msg2.Replace("\n", "");
                        //msg2 = msg2.Replace("\t", "");
                        this.SendConfigMessage(msg2);
                    }
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(string.Format("end: EXCEPTION! Stack chiamate: {0} Messaggio: {1}", ex.StackTrace, ex.Message));
                }
                if (iIPPortConfig != this._iIPPortA)
                {
                    if (_socketReqChannelConfig != null)
                        this._socketReqChannelConfig.Close();
                    this._socketReqChannelConfig = null;
                }
            }
            else
                Trace.WriteLine("SendConfig ERROR: NOT Connected!");
        }

        /// <summary>
        /// will setup the tcp connect and send LogOn request to Fdc server.
        /// </summary>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        public bool Connect(string connectionString)
        {
            Trace.WriteLine(string.Format("start Connect: status='{0}'", this.mainConnectionState));

            lock (ifsfManager.SyncObject)
            {
                if ((this.mainConnectionState == DeviceConnectionState.Disconnected) || (this.mainConnectionState == DeviceConnectionState.Disconnecting))
                {
                    //this.mainConnectionState = DeviceConnectionState.Connecting;

                    try
                    {
                        Trace.WriteLine(string.Format("id={0}, -connectionString:'{1}'", this.id, connectionString));
                        getConnectionParams(connectionString);

                        FDCGlobal.ProtocolVersion = FDCVersion.V0007;// "00.07";// FDCGlobal.VersionFromString(IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "FDCPOSInterfaceVersion"));
                        Trace.WriteLine(string.Format("id={0}, version:'{1}'", this.id, FDCGlobal.ProtocolVersion));
                        this.ifsfManager.heartbeat.heartbeatInterval = this.heartbeatInterval;
                        this.ifsfManager.heartbeat.heartbeatTimeout = this.heartbeatTimeout;
                        int socketTimeout = 3000;
                        bool noDelay = true;
                        try
                        {
                            string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "SocketTimeout");
                            if (sValue.Length > 0)
                                socketTimeout = Convert.ToInt32(sValue);
                            Trace.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                            sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "NoDelay");
                            if (sValue.Length > 0 && sValue == "0")
                                noDelay = false;
                            Trace.WriteLine(string.Format("socketTimeout={0}", socketTimeout));
                        }
                        catch (Exception ex)
                        {
                            Trace.WriteLine("EXCEPTION! " + ex.Message);
                        }

                        IPAddress serverIPAddress = null;
                        IPEndPoint endPoint = null;

                        _socketReqChannelA = new TcpClient();
                        _socketReqChannelA.SendTimeout = socketTimeout;
                        _socketReqChannelA.NoDelay = noDelay;
                        int retrycount = 0;

                        bool bConnected = false;
                        string ipAddress = this._sIPAddress;
                        string error = "";
                        while (!bConnected)
                        {
                            if (retrycount == 5)
                            {
                                if (this._sIPAddress2 != "") ipAddress = this._sIPAddress2;
                                Trace.WriteLine(error);
                            }
                            else if (retrycount == 10)
                            {
                                retrycount = 0;
                                ipAddress = this._sIPAddress;
                                Trace.WriteLine(error);
                                Thread.Sleep(5000);
                            }
                            retrycount++;

                            try
                            {
                                Trace.WriteLine(string.Format("connecting to ip={0}, port={1}", ipAddress, this.iIPPortA));
                                this.socketReqChannelA.Connect(ipAddress, this.iIPPortA);
                                bConnected = true;
                            }
                            catch (SocketException sex)
                            {
                                error = sex.Message + " - " + sex.StackTrace;
                                Console.WriteLine("IFSFSocket to " + ipAddress + ", " + this.iIPPortA + " exceptioned: " + sex);
                                Thread.Sleep(3000);
                            }
                        }

                        if (iIPPortB != iIPPortA /*&& _socketRespChannelB == null*/)
                            _socketRespChannelB = new TcpListener(iIPPortB);
                        else
                            _socketRespChannelB = null;
                        if (iIPPortC != iIPPortA /*&& _socketUnsolicitedChannelC == null*/)
                            _socketUnsolicitedChannelC = new TcpListener(iIPPortC);
                        else
                            _socketUnsolicitedChannelC = null;


                        Trace.WriteLine(string.Format("Channel A Connected: Id={0}, WId={1}, AId={2}", this.id, this.workstationID, this.applicationSender));

                        ifsfManager.authentificationErrorRetry = true;
                        if (this.validationInfo != null)
                            ifsfManager.LogOn(validationInfo, posInfo, "");
                        else
                            ifsfManager.LogOnSend(posInfo);
                        ifsfManager.heartbeat.ResetDisconnectionTimeout();

                        if (iIPPortB != iIPPortA /*&& respChannelBThreadObj == null*/)
                        {
                            respChannelBThreadObj = new TCPListenerThread(socketRespChannelB, ifsfManager, "ChannelB");
                            respChannelBThread = new Thread(new ThreadStart(respChannelBThreadObj.TCPListenerThreadProc));
                            respChannelBThread.Start();
                        }
                        else /*if (respChannelBThreadObj == null)*/
                        {
                            respChannelBThreadObj = new TCPListenerThread(null, ifsfManager, "ChannelA");
                            respChannelBThread = new Thread(new ThreadStart(respChannelBThreadObj.TCPListenerThreadProc));
                            respChannelBThread.Start();
                        }
                        if (iIPPortC != iIPPortA /*&& unsolicitedChannelCThreadObj == null*/)
                        {
                            unsolicitedChannelCThreadObj = new TCPListenerThread(socketUnsolicitedChannelC, ifsfManager, "ChannelC");
                            unsolicitedChannelCThread = new Thread(new ThreadStart(unsolicitedChannelCThreadObj.TCPListenerThreadProc));
                            unsolicitedChannelCThread.Start();
                        }
                    }
                    catch (Exception ex)
                    {
                        Trace.WriteLine(string.Format("end: EXCEPTION! Stack chiamate: {0} Messaggio: {1}", ex.StackTrace, ex.Message));
                        return false;
                    }

                }

            }

            //if ((this.mainConnectionState != DeviceConnectionState.Disconnected) && (this.mainConnectionState != DeviceConnectionState.Disconnecting))
            //{
            //    throw new SocketException(SocketExceptionType.ClientNotDisconnected);
            //}
            //TransportFrameClientSocket.ValidateConnectionString(connectionString);
            //if (this.debugLogger.IsActive(LogCategory.UserRequest, DebugLogLevel.Normal))
            //{
            //    this.debugLogger.Add(string.Format("Connect({0})", connectionString), LogCategory.UserRequest, DebugLogLevel.Normal);
            //}
            //this.userWantConnection = true;
            //this.stateMachine.IncomingEvent(new ConnectionStringStateEngineEvent(connectionString, EventType.ConnectRequested));

            Trace.WriteLine("end: ok");
            return true;
        }

        public void Disconnect()
        {
            //if ((this.mainConnectionState == DeviceConnectionState.Connected) || (this.mainConnectionState == DeviceConnectionState.Connecting))
            {
                Trace.WriteLine("terminating respThreadObjs");
                if (respChannelBThreadObj != null)
                    respChannelBThreadObj.bTerminate = true;
                Trace.WriteLine("terminating respChannelCThreadObj");
                if (unsolicitedChannelCThreadObj != null)
                    unsolicitedChannelCThreadObj.bTerminate = true;

                if (respChannelConfigThreadObj != null)
                    respChannelConfigThreadObj.bTerminate = true;

                if (_socketReqChannelA != null)
                    this._socketReqChannelA.Close();
                this._socketReqChannelA = null;
                if (_socketReqChannelConfig != null)
                    this._socketReqChannelConfig.Close();
                this._socketReqChannelConfig = null;

                if (this._socketRespChannelB != null)
                    this._socketRespChannelB.Stop();
                _socketRespChannelB = null;
                if (this._socketUnsolicitedChannelC != null)
                    this._socketUnsolicitedChannelC.Stop();
                _socketUnsolicitedChannelC = null;

                //if (this.debugLogger.IsActive(LogCategory.UserRequest, DebugLogLevel.Normal))
                //{
                //    this.debugLogger.Add(string.Format("Disconnect()", new object[0]), LogCategory.UserRequest, DebugLogLevel.Normal);
                //}
                //this.userWantConnection = false;
                //this.stateMachine.IncomingEvent(new StateEngineEvent(EventType.DisconnectRequested));
            }
        }

        public virtual void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                this.disposed = true;
                if (disposing)
                {
                    //this.transportFrameClientSocket.Dispose();
                    //this.stateMachine.Dispose();
                    //this.debugLogger.Dispose();
                }
            }
        }

        // Properties
        //[CLSCompliant(false)]
        //public ushort ClientId
        //{
        //    get
        //    {
        //        return this.transportFrameClientSocket.ClientId;
        //    }
        //}

        //public string ClientName
        //{
        //    get
        //    {
        //        return this.transportFrameClientSocket.Name;
        //    }
        //}

        public DeviceConnectionState ConnectionState
        {
            get
            {
                return this.mainConnectionState;
            }
        }

        public string EntitySubType
        {
            get
            {
                return "RPC";
            }
        }

        public string EntityType
        {
            get
            {
                return "ClientSocket";
            }
        }

        /// <summary>
        /// This is used by the logger and should never be set by implementing classes
        /// </summary>
        public string FullEntityName { get; set; }

        public int Id
        {
            get
            {
                return this.id;
            }
        }

        public IIdentifiableEntity ParentEntity
        {
            get
            {
                return this.parentEntity;
            }
        }


        public void Serialize<T>(T sr)
        {
            if (sr != null && socketReqChannelA != null)
            {
                XmlSerializer serializer = null;
                var netstream = socketReqChannelA.GetStream();
                using (var memstream = new MemoryStream())
                {
                    serializer = new XmlSerializer(typeof(T));
                    serializer.Serialize(memstream, (T)sr);

                    // writes header and encription string
                    using (var memstream2 = new MemoryStream())
                    {
                        byte[] bytes = new byte[Define.HeaderLength];
                        using (var writer = new BinaryWriter(memstream2))
                        {
                            bytes[3] = (byte)(memstream.Length & 0x000000FF);
                            bytes[2] = (byte)((memstream.Length & 0x0000FF00) / Math.Pow(2, 8));
                            bytes[1] = (byte)((memstream.Length & 0x00FF0000) / Math.Pow(2, 16));
                            bytes[0] = (byte)((memstream.Length & 0xFF000000) / Math.Pow(2, 24));
                            writer.Write(bytes);
                            bytes = new byte[Define.EncriptionTypeLength];
                            //string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "CheckEncryption");
                            if (this.ifsfManager.clientSocket.headerEncryption != 0)
                            {
                                MD5Crypter crypter = new MD5Crypter();
                                byte[] hashingbytes = new byte[memstream.Length + crypter.getPassphrase().GetLength(0)];
                                Array.Copy(memstream.GetBuffer(), hashingbytes, (int)memstream.Length);
                                Array.Copy(crypter.getPassphrase(), 0, hashingbytes, (int)memstream.Length,
                                           (int)crypter.getPassphrase().Length);
                                bytes = crypter.ComputeHash(hashingbytes);
                            }
                            else
                            {
                                for (int i = 0; i < Define.EncriptionTypeLength; i++)
                                    bytes[i] = 0;
                            }
                            writer.Write(bytes);
                            memstream2.WriteTo(netstream);
                        }
                    }
                    memstream.WriteTo(netstream);
                }
                TraceXML(serializer, (T)sr);
            }
        }

        public void SendConfigMessage(string configmessage)
        {
            NetworkStream netstream = socketReqChannelConfig.GetStream();

            // writes header and encription string
            using (MemoryStream memstream = new MemoryStream())
            {
                byte[] bytes = new byte[Define.HeaderLength];
                using (BinaryWriter writer = new BinaryWriter(memstream))
                {

                    bytes[3] = (byte)(configmessage.Length & 0x000000FF);
                    bytes[2] = (byte)((configmessage.Length & 0x0000FF00) / Math.Pow(2, 8));
                    bytes[1] = (byte)((configmessage.Length & 0x00FF0000) / Math.Pow(2, 16));
                    bytes[0] = (byte)((configmessage.Length & 0xFF000000) / Math.Pow(2, 24));
                    writer.Write(bytes);
                    if (FDCGlobal.ProtocolVersion >= FDCVersion.V0100)
                    {
                        bytes = new byte[Define.EncriptionTypeLength];
                        if (this.ifsfManager.clientSocket.headerEncryption != 0)
                            bytes[1] = (byte)(1);
                        else
                            bytes[1] = (byte)(0);
                        bytes[0] = (byte)(0);
                        writer.Write(bytes);
                    }
                    // writes encryption
                    if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007 ||
                        (FDCGlobal.ProtocolVersion >= FDCVersion.V0100 && this.ifsfManager.clientSocket.headerEncryption != 0))
                    {
                        bytes = new byte[Define.MD5EncriptionLength];
                        //string sValue = IniFile.IniReadValue(ConfigurationParams.inifile, "FUSION-Connection", "CheckEncryption");
                        if (this.ifsfManager.clientSocket.headerEncryption != 0)
                        {
                            var crypter = new MD5Crypter();
                            byte[] hashingbytes = new byte[memstream.Length + crypter.getPassphrase().GetLength(0)];
                            Array.Copy(memstream.GetBuffer(), hashingbytes, (int)memstream.Length);
                            Array.Copy(crypter.getPassphrase(), 0, hashingbytes, (int)memstream.Length, (int)crypter.getPassphrase().Length);
                            bytes = crypter.ComputeHash(hashingbytes);
                        }
                        else
                        {
                            for (int i = 0; i < Define.MD5EncriptionLength; i++)
                                bytes[i] = 0;
                        }
                        writer.Write(bytes);
                    }


                    byte[] bytedata;
                    System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
                    bytedata = encoding.GetBytes(configmessage);
                    writer.Write(bytedata);

                    memstream.WriteTo(netstream);
                    TraceXML(memstream, configmessage);
                }
            }
        }

        private void ifsfmessages_OnResponseTimeout(object sender, EventArgs e)
        {
            if (OnResponseTimeout != null)
                OnResponseTimeout.Invoke(this, e);
        }

        private void ifsfmessages_OnMessageEnqueued(object sender, EventArgs e)
        {
            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("ifsfmessages_OnMessageEnqueued init"));
            string requestType = "";
            int requestId = 0;
            try
            {
                while (ifsfMessages.serviceRequestChannelA.Count > 0)
                {
                    BasePOSRequest sr = ifsfMessages.serviceRequestChannelA.Dequeue();
                    Trace.WriteLine(string.Format("sr.GetType:{0}", sr.GetType().FullName));
                    if (sr.GetType() == typeof(POSMessagePOSReady))
                    {
                        requestType = ((FDCMessage)sr).MessageType;
                        requestId = Convert.ToInt32(((FDCMessage)sr).MessageID);
                    }
                    else
                    {
                        requestType = ((ServiceRequest)sr).RequestType;
                        requestId = Convert.ToInt32(((ServiceRequest)sr).RequestID);
                    }

                    switch (requestType)
                    {
                        case "POSHeartBeat":
                            Serialize((ServiceRequestHeartbeat)sr);
                            break;
                        case "LogOn":
                            if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                                Serialize((ServiceRequestLogOnV07)sr);
                            else
                                Serialize((ServiceRequestLogOn)sr);
                            break;
                        case "LogOff":
                            Serialize((ServiceRequestLogOff)sr);
                            break;
                        case "VersionInfo":
                            Serialize((ServiceRequestVersionInfo)sr);
                            break;
                        case "StartForecourt":
                            Serialize((ServiceRequestStartForecourt)sr);
                            break;
                        case "StopForecourt":
                            Serialize((ServiceRequestStopForecourt)sr);
                            break;
                        case "GetCurrentFuellingStatus":
                            Serialize((ServiceRequestGetCurrentFuellingStatus)sr);
                            break;
                        case "GetFuelPointTotals":
                            Serialize((ServiceRequestGetFuelPointTotals)sr);
                            break;
                        case "GetDeviceState":
                            Serialize((ServiceRequestGetDeviceState)sr);
                            break;
                        case "TerminateFuelling":
                            Serialize((ServiceRequestTerminateFuelling)sr);
                            break;
                        case "AuthoriseFuelPoint":
                            Serialize((ServiceRequestAuthoriseFuelPoint)sr);
                            break;
                        case "ChangeFuelMode":
                            Serialize((ServiceRequestChangeFuelMode)sr);
                            break;
                        case "ChangeFuelPrice":
                            Serialize((ServiceRequestChangeFuelPrice)sr);
                            break;
                        case "LockFuelSaleTrx":
                            Serialize((ServiceRequestLockFuelSaleTrx)sr);
                            break;
                        case "UnlockFuelSaleTrx":
                            Serialize((ServiceRequestUnlockFuelSaleTrx)sr);
                            break;
                        case "ClearFuelSaleTrx":
                            Serialize((ServiceRequestClearFuelSaleTrx)sr);
                            break;
                        case "GetAvailableFuelSaleTrxs":
                            Serialize((ServiceRequestGetAvailableFuelSaleTrxs)sr);
                            break;
                        case "GetFuelSaleTrxDetails":
                            Serialize((ServiceRequestGetFuelSaleTrxDetails)sr);
                            break;
                        case "GetProductTable":
                            Serialize((ServiceRequestGetProductTable)sr);
                            break;
                        case "GetModeTable":
                            Serialize((ServiceRequestGetModeTable)sr);
                            break;
                        case "GetFuelMode":
                            Serialize((ServiceRequestGetFuelMode)sr);
                            break;
                        case "GetConfiguration":
                            Serialize((ServiceRequestGetConfiguration)sr);
                            break;
                        case "GetDSPConfiguration":
                            Serialize((ServiceRequestGetDSPConfiguration)sr);
                            break;
                        case "GetTLGConfiguration":
                            Serialize((ServiceRequestGetTLGConfiguration)sr);
                            break;
                        case "GetPPConfiguration":
                            Serialize((ServiceRequestGetPPConfiguration)sr);
                            break;
                        case "SetConfiguration":
                            Serialize((ServiceRequestSetConfiguration)sr);
                            break;
                        case "LockNozzle":
                            Serialize((ServiceRequestLockNozzle)sr);
                            break;
                        case "UnlockNozzle":
                            Serialize((ServiceRequestUnlockNozzle)sr);
                            break;
                        case "OpenDevice":
                            Serialize((ServiceRequestOpenDevice)sr);
                            break;
                        case "CloseDevice":
                            Serialize((ServiceRequestCloseDevice)sr);
                            break;
                        case "GetCountrySettings":
                            Serialize((ServiceRequestGetCountrySettings)sr);
                            break;
                        case "GetDSPLimits":
                            Serialize((ServiceRequestGetDSPLimits)sr);
                            break;
                        case "ChangeDSPLimits":
                            Serialize((ServiceRequestChangeDSPLimits)sr);
                            break;
                        case "SuspendFuelling":
                            Serialize((ServiceRequestSuspendFuelling)sr);
                            break;
                        case "ResumeFuelling":
                            Serialize((ServiceRequestResumeFuelling)sr);
                            break;
                        case "LockTank":
                            Serialize((ServiceRequestLockTank)sr);
                            break;
                        case "UnlockTank":
                            Serialize((ServiceRequestUnlockTank)sr);
                            break;
                        case "GetTankData":
                            Serialize((ServiceRequestGetTankData)sr);
                            break;
                        case "ReserveFuelPoint":
                            Serialize((ServiceRequestReserveFuelPoint)sr);
                            break;
                        case "FreeFuelPoint":
                            Serialize((ServiceRequestFreeFuelPoint)sr);
                            break;
                        case "StartFuelPointTest":
                            Serialize((ServiceRequestStartFuelPointTest)sr);
                            break;
                        case "EndFuelPointTest":
                            Serialize((ServiceRequestEndFuelPointTest)sr);
                            break;
                        case "OpenFuelPoint":
                            Serialize((ServiceRequestOpenFuelPoint)sr);
                            break;
                        case "CloseFuelPoint":
                            Serialize((ServiceRequestCloseFuelPoint)sr);
                            break;
                        case "SetDeviceAlarm":
                            Serialize((ServiceRequestSetDeviceAlarm)sr);
                            break;
                        case "OPTAdd":
                            Serialize((ServiceRequestOPTAdd)sr);
                            break;
                        case "OPTRemove":
                            Serialize((ServiceRequestOPTRemove)sr);
                            break;
                        case "OPTWrite":
                            if (FDCGlobal.ProtocolVersion <= FDCVersion.V0007)
                                Serialize((ServiceRequestOPTWriteV07)sr);
                            else
                                Serialize((ServiceRequestOPTWrite)sr);
                            break;
                        case "ConfigStart":
                            Serialize((ServiceRequestConfigStart)sr);
                            break;
                        case "ConfigEnd":
                            Serialize((ServiceRequestConfigEnd)sr);
                            break;
                        case "DefGrade":
                        case "DefGrades":
                            Serialize((ServiceRequestDefGrades)sr);
                            break;
                        case "AssignGradePars":
                            Serialize((ServiceRequestAssignGradePars)sr);
                            break;
                        case "DefTanks":
                            Serialize((ServiceRequestDefTanks)sr);
                            break;
                        case "DefFuelMode":
                            Serialize((ServiceRequestDefFuelMode)sr);
                            break;
                        case "DefFuellingMode":
                            Serialize((ServiceRequestDefFuellingMode)sr);
                            break;
                        case "DefFuelPoint":
                            Serialize((ServiceRequestDefFuelPoint)sr);
                            break;
                        case "AssignGrades":
                            Serialize((ServiceRequestAssignGrades)sr);
                            break;
                        case "AssignMeters":
                            Serialize((ServiceRequestAssignMeters)sr);
                            break;
                        case "AssignTanks":
                            Serialize((ServiceRequestAssignTanks)sr);
                            break;
                        case "DefPricePole":
                            Serialize((ServiceRequestDefPricePole)sr);
                            break;
                        case "LoadPriceset":
                            Serialize((ServiceRequestLoadPriceset)sr);
                            break;
                        case "GetTPState":
                            Serialize((ServiceRequestGetTPState)sr);
                            break;
                        default:
                            throw new ArgumentOutOfRangeException("probably a merge issue...");
                    }
                }
            }
            catch (SocketException sex)
            {
                Trace.WriteLine("ifsfmessages_OnMessageEnqueued RequestType:" + requestType + " RequestId:" + requestId + " Exception! " + sex.Message + " - " + sex.StackTrace);
                if (mainConnectionState != DeviceConnectionState.Disconnected)
                {
                    this.ifsfManager.Disconnect();
                    mainConnectionState = DeviceConnectionState.Disconnected;
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("ifsfmessages_OnMessageEnqueued RequestType:" + requestType + " RequestId:" + requestId + " Exception! " + ex.Message + " - " + ex.StackTrace);
                if (mainConnectionState != DeviceConnectionState.Disconnected)
                {
                    this.ifsfManager.Disconnect();
                    mainConnectionState = DeviceConnectionState.Disconnected;
                }
            }

            Trace.WriteLineIf(Trace.CheckTraceLevel(3), string.Format("ifsfmessages_OnMessageEnqueued end RequestType:{0}", requestType));
        }

        private void TraceXML<T>(XmlSerializer serializer, T sr)
        {
            try
            {
                if (configParam.TraceXML)
                {
                    DateTime now = DateTime.Now;
                    using (var testwriter = new StreamWriter(string.Format("{0}{1:00}-{2:00}-xmlClientMsg.xml", ConfigurationParams.tracePath, now.Day, now.Month), true))
                    {
                        serializer.Serialize(testwriter, (T)sr);
                    }
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

        private void TraceXML(MemoryStream ms, string msg)
        {
            try
            {
                if (configParam.TraceXML)
                {
                    DateTime now = DateTime.Now;
                    using (var testwriter = new StreamWriter(string.Format("{0}{1:00}-{2:00}-xmlClientMsg.xml", ConfigurationParams.tracePath, now.Day, now.Month), true))
                    {
                        testwriter.Write(msg);
                    }
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine("Exception! " + ex.Message + " - " + ex.StackTrace);
            }
        }

    }
}