internal void ReceiveNotification(MQTSH tsh)
        {
            uint method = 0x608;

            this.TrEntry(method, new object[] { tsh });
            try
            {
                MQNOTIFICATION notification = new MQNOTIFICATION();
                notification.ReadStruct(tsh.TshBuffer, tsh.Offset);
                MQProxyQueue queue = this.FindProxyQueue(notification.notify.hObj);
                if (queue == null)
                {
                    NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x893, null);
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = "Unable to find proxy queue for Hobj";
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                    throw exception;
                }
                queue.ReceiveNotification(notification);
            }
            finally
            {
                base.TrExit(method);
            }
        }
        internal void AddMessage(MQTSH tsh)
        {
            uint method = 0x607;

            this.TrEntry(method, new object[] { tsh });
            try
            {
                MQASYNC_MESSAGE async = new MQASYNC_MESSAGE();
                tsh.Offset = async.ReadStruct(tsh.TshBuffer, tsh.Offset);
                base.TrData(method, 0, "Hobj to be removed", BitConverter.GetBytes(async.asyncMsg.hObj));
                MQProxyQueue queue = this.FindProxyQueue(async.asyncMsg.hObj);
                if (queue == null)
                {
                    NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x893, null);
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = "Unable to find proxy queue for Hobj";
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                    throw exception;
                }
                queue.AddMessage(tsh, async);
            }
            finally
            {
                base.TrExit(method);
            }
        }
        public void DeleteProxyQueue(MQProxyQueue proxyQueue)
        {
            uint method = 0x606;

            this.TrEntry(method, new object[] { proxyQueue });
            try
            {
                this.deletePQueue.Acquire();
                ManagedHobj manHobj = proxyQueue.ManHobj;
                if (manHobj != null)
                {
                    int handle = manHobj.Handle;
                    base.TrData(method, 0, "Hobj to be removed", BitConverter.GetBytes(handle));
                    MQProxyQueue queue = this.proxyQueues[handle];
                    if (queue != proxyQueue)
                    {
                        CommonServices.SetValidInserts();
                        CommonServices.ArithInsert1   = 1;
                        CommonServices.CommentInsert1 = "Couldn't find the ProxyQueue..";
                        base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                        NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x893, null);
                        base.TrException(method, ex);
                        throw ex;
                    }
                    this.proxyQueues.Remove(handle);
                }
            }
            finally
            {
                this.deletePQueue.Release();
                base.TrExit(method);
            }
        }
Esempio n. 4
0
        public static byte[] StringToQmgrBytes(NmqiEnvironment env, Hconn hconn, string str, byte[] charAttrs, int offset, int length)
        {
            Encoding dotnetEncoding = MQCcsidTable.GetDotnetEncoding(hconn.Ccsid);

            byte[] bytes = dotnetEncoding.GetBytes(str);
            if (bytes.Length > length)
            {
                NmqiException exception = new NmqiException(env, -1, null, 2, 0x7d5, null);
                env.LastException = exception;
                throw exception;
            }
            if ((offset + length) > charAttrs.Length)
            {
                NmqiException exception2 = new NmqiException(env, -1, null, 2, 0x7d5, null);
                env.LastException = exception2;
                throw exception2;
            }
            for (int i = 0; i < bytes.Length; i++)
            {
                charAttrs[offset + i] = bytes[i];
            }
            byte[] buffer2 = dotnetEncoding.GetBytes(" ");
            for (int j = bytes.Length; j < length; j++)
            {
                charAttrs[offset + j] = buffer2[0];
            }
            return(bytes);
        }
Esempio n. 5
0
        internal MQTSH ReceiveAsyncTSH()
        {
            uint method = 0x61a;

            this.TrEntry(method);
            MQTSH result = null;

            try
            {
                lock (this.asyncTshLock)
                {
                    while ((this.asyncTshQueue.Count == 0) && (this.asyncFailure == null))
                    {
                        try
                        {
                            long currentTimeInMs     = NmqiTools.GetCurrentTimeInMs();
                            int  millisecondsTimeout = 10;
                            Monitor.Wait(this.asyncTshLock, millisecondsTimeout, true);
                            if ((NmqiTools.GetCurrentTimeInMs() >= (currentTimeInMs + millisecondsTimeout)) && !this.Connection.IsConnected)
                            {
                                NmqiException ex = new NmqiException(base.env, 0x23fd, null, 2, 0x7d9, null);
                                base.TrException(method, ex);
                                throw ex;
                            }
                            continue;
                        }
                        catch (ThreadInterruptedException exception2)
                        {
                            base.TrException(method, exception2);
                            continue;
                        }
                    }
                    if (this.asyncFailure != null)
                    {
                        this.connectionBroken = true;
                        this.hconn.RaiseEvent(0x7d9);
                        NmqiException exception3 = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                        base.TrException(method, exception3);
                        throw exception3;
                    }
                }
                result = this.asyncTshQueue.Dequeue();
            }
            finally
            {
                base.TrExit(method, result);
            }
            return(result);
        }
Esempio n. 6
0
        public static int GetLength(NmqiEnvironment env, int version, int ptrSize)
        {
            switch (version)
            {
            case 1:
                return(GetLengthV1(ptrSize));

            case 2:
                return(GetLengthV2(ptrSize));
            }
            NmqiException exception = new NmqiException(env, -1, null, 2, 0x893, null);

            env.LastException = exception;
            throw exception;
        }
Esempio n. 7
0
        public int Write(byte[] buffer, int offset, int length)
        {
            uint method = 0x639;

            this.TrEntry(method);
            try
            {
                base.TrText(method, "Writing " + length + " bytes onto wire");
                if ((this.stream == null) || ((this.client != null) && !this.client.Connected))
                {
                    base.throwNewMQException(2, 0x7d9);
                }
                if ((this.maxkeyresetcount != 0L) && (this.maxkeyresetcount < (this.currentbytescount + length)))
                {
                    this.currentbytescount = 0L;
                    if (this.stream != null)
                    {
                        this.stream.Close();
                    }
                    if (this.client.Connected)
                    {
                        this.client.Close();
                    }
                    this.isClosed = true;
                    Exception     nestedException = new Exception("Max keyreset count reached..breaking the connection");
                    NmqiException exception2      = new NmqiException(this.env, -1, new string[] { "KeyResetCount=" + this.maxkeyresetcount, "CurrentCount=" + this.currentbytescount }, 2, 0x7d9, nestedException);
                    throw exception2;
                }
                if ((this.client != null) && this.client.Connected)
                {
                    this.stream.Write(buffer, offset, length);
                    base.TrText(method, "Current total bytes read/write on socket: " + this.currentbytescount);
                    Interlocked.Add(ref this.currentbytescount, (long)length);
                }
                base.TrText(method, "Write onto wire complete");
            }
            catch (Exception exception3)
            {
                base.TrException(method, exception3);
                throw exception3;
            }
            finally
            {
                base.TrExit(method);
            }
            return(length);
        }
Esempio n. 8
0
        public void DeliverException(NmqiException e, int flag, int _event)
        {
            uint method = 0x62d;

            this.TrEntry(method, new object[] { e, flag, _event });
            try
            {
                if (this.hconn != null)
                {
                    this.hconn.DeliverException(e, flag, _event);
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 9
0
        internal void SendTSH(MQTSH tsh)
        {
            uint method = 0x61c;

            this.TrEntry(method, new object[] { tsh });
            MQFAPConnection connection = this.Connection;

            try
            {
                if (this.IsEndRequested || (this.asyncFailure != null))
                {
                    NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                    throw exception;
                }
                byte[] tshBuffer = tsh.TshBuffer;
                byte[] buffer    = null;
                int    offset    = tsh.Offset;
                int    length    = tsh.Length;
                int    maxlength = length;
                base.TrData(method, 0, "Data before Processed by SendExits(if no exits are defined, this is final)", tshBuffer);
                if ((this.exitsActive && (this.exits != null)) && this.exits.sendExitDefined)
                {
                    buffer = this.exits.ProcessSendExits(ref tshBuffer, ref offset, ref length, ref maxlength);
                    base.TrData(method, 0, "Data after processed by SendExits", tshBuffer);
                }
                else
                {
                    buffer = tshBuffer;
                }
                try
                {
                    this.parentConnection.RequestSendLock();
                    connection.Send(buffer, offset, length, tsh.SegmentType, tsh.TSHType);
                }
                finally
                {
                    this.parentConnection.ReleaseSendLock();
                }
            }
            finally
            {
                tsh.ParentBuffer.Free();
                tsh.ParentBuffer = null;
                base.TrExit(method);
            }
        }
Esempio n. 10
0
        private int ReceiveBuffer()
        {
            uint method = 0x610;

            this.TrEntry(method);
            int dataAvailable = this.commsBuffer.DataAvailable;
            int offset        = dataAvailable + this.commsBuffer.DataUsed;
            int result        = 0;

            byte[] buffer = this.commsBuffer.Buffer;
            try
            {
                try
                {
                    result = this.remoteConnection.Receive(buffer, offset, buffer.Length - offset, SocketFlags.None);
                    this.commsBuffer.Buffer = buffer;
                    base.TrText(method, "Number of bytes read from Socket by RcvThread = " + result);
                }
                catch (NmqiException exception)
                {
                    base.TrException(method, exception);
                    if (!this.disconnecting)
                    {
                        throw exception;
                    }
                    result = -1;
                }
                if (!this.disconnecting && (result <= 0))
                {
                    NmqiException exception2 = new NmqiException(base.env, 0x23f8, null, 2, 0x7d9, null);
                    throw exception2;
                }
                if (result > 0)
                {
                    this.commsBuffer.DataAvailable = dataAvailable + result;
                }
            }
            finally
            {
                base.TrExit(method, result);
            }
            return(result);
        }
Esempio n. 11
0
        internal void SendData(byte[] bytes, int offset, int length, byte segmentType, int tshType)
        {
            uint method = 0xb1;

            this.TrEntry(method, new object[] { bytes, offset, length });
            MQFAPConnection connection = this.Connection;

            byte[] buffer    = null;
            int    maxlength = length;

            try
            {
                if (this.IsEndRequested || (this.asyncFailure != null))
                {
                    NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                    throw exception;
                }
                base.TrData(method, 0, "Data before Processed by SendExits(if no exits are defined, this is final)", bytes);
                if ((this.exitsActive && (this.exits != null)) && this.exits.sendExitDefined)
                {
                    buffer = this.exits.ProcessSendExits(ref bytes, ref offset, ref length, ref maxlength);
                    base.TrData(method, 0, "Data after processed by SendExits", bytes);
                }
                else
                {
                    buffer = bytes;
                }
                try
                {
                    this.parentConnection.RequestSendLock();
                    connection.Send(buffer, offset, length, segmentType, tshType);
                    buffer = null;
                }
                finally
                {
                    this.parentConnection.ReleaseSendLock();
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 12
0
        public static QueueManagerInfo GetQueueManagerInfo(NmqiEnvironment env, NmqiMQ mq, Hconn hconn)
        {
            QueueManagerInfo   info     = env.NewQueueManagerInfo();
            MQObjectDescriptor pObjDesc = env.NewMQOD();

            pObjDesc.ObjectType = 5;
            int   options   = 0x20;
            Phobj pHobj     = env.NewPhobj();
            int   pCompCode = 0;
            int   pReason   = 0;

            mq.MQOPEN(hconn, ref pObjDesc, options, pHobj, out pCompCode, out pReason);
            if (pReason == 0)
            {
                Hobj   hOBJ       = pHobj.HOBJ;
                int[]  pSelectors = new int[] { 0x1f, 0x20, 2, 0x7df, 0x7f0 };
                int[]  pIntAttrs  = new int[3];
                byte[] pCharAttrs = new byte[0x60];
                mq.MQINQ(hconn, hOBJ, pSelectors.Length, pSelectors, pIntAttrs.Length, pIntAttrs, pCharAttrs.Length, pCharAttrs, out pCompCode, out pReason);
                if (pReason == 0)
                {
                    info.CommandLevel = pIntAttrs[0];
                    info.Platform     = pIntAttrs[1];
                    info.Ccsid        = pIntAttrs[2];
                    Encoding dotnetEncoding = MQCcsidTable.GetDotnetEncoding(info.Ccsid);
                    info.Name = dotnetEncoding.GetString(pCharAttrs, 0, 0x30);
                    info.Uid  = dotnetEncoding.GetString(pCharAttrs, 0x30, 0x30);
                }
                else
                {
                    NmqiException exception = new NmqiException(env, 0x253a, null, pCompCode, pReason, null);
                    env.LastException = exception;
                    throw exception;
                }
                mq.MQCLOSE(hconn, pHobj, 0, out pCompCode, out pReason);
                return(info);
            }
            NmqiException exception2 = new NmqiException(env, 0x2525, null, pCompCode, pReason, null);

            env.LastException = exception2;
            throw exception2;
        }
Esempio n. 13
0
        internal void CheckIfDisconnected()
        {
            uint method = 0x612;

            this.TrEntry(method);
            try
            {
                ManagedHconn reconnectableParent = this.ReconnectableParent;
                if (this.disconnected && ((reconnectableParent == null) || ((reconnectableParent != null) && reconnectableParent.HasFailed())))
                {
                    NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                    base.TrException(method, ex);
                    throw ex;
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 14
0
 public static byte[] GetUtf8Bytes(NmqiEnvironment env, string str, string name)
 {
     if (str == null)
     {
         return(new byte[0]);
     }
     try
     {
         return(Encoding.GetEncoding("UTF-8").GetBytes(str));
     }
     catch (IOException exception)
     {
         string[] strArray2 = new string[3];
         strArray2[0] = GetExSumm(exception);
         strArray2[2] = exception.Source;
         string[]      inserts    = strArray2;
         NmqiException exception2 = new NmqiException(env, 0x254a, inserts, 2, 0x893, exception);
         env.LastException = exception2;
         throw exception2;
     }
     return(null);
 }
Esempio n. 15
0
        internal void DeliverExchangeReply(int requestId, MQTSH tsh)
        {
            uint method = 0x61e;

            this.TrEntry(method, new object[] { requestId, tsh });
            try
            {
                tsh = this.ProcessReceivedData(tsh);
                lock (this.requestEntryMutex)
                {
                    MQRequestEntry exchangeRequests = this.exchangeRequests;
                    while ((exchangeRequests != null) && (exchangeRequests.RequestID != requestId))
                    {
                        exchangeRequests = exchangeRequests.Next;
                    }
                    if (exchangeRequests == null)
                    {
                        CommonServices.SetValidInserts();
                        CommonServices.ArithInsert1   = (uint)requestId;
                        CommonServices.ArithInsert2   = tsh.SegmentType;
                        CommonServices.CommentInsert1 = "Unexpected flow received in DeliverExchangeReply";
                        CommonServices.CommentInsert2 = "Cached RequestEntry is null for given RequestId";
                        base.FFST("%Z% %W% %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                        NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x893, null);
                        base.TrException(method, ex);
                        throw ex;
                    }
                    lock (exchangeRequests)
                    {
                        exchangeRequests.Reply = tsh;
                        Monitor.Pulse(exchangeRequests);
                    }
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 16
0
        public MQXARecoveryBridge(ManagedHconn hconn, NmqiEnvironment env) : base(env)
        {
            this.recoveryProperties    = new Hashtable(6);
            this.TransactionLogList    = new Hashtable(10);
            this.recoveryQueueOpenOpts = 0x12;
            uint method = 0x529;

            this.TrEntry(method, new object[] { hconn, env });
            try
            {
                base.TrConstructor("%Z% %W%  %I% %E% %U%");
                this.recoveryHconn               = hconn;
                this.recoveryPutPmo              = new MQPutMessageOptions();
                this.recoveryPutPmo.Options      = 0xc0;
                this.recoveryGetGmo              = new MQGetMessageOptions();
                this.recoveryGetGmo.MatchOptions = 1;
                this.recoveryGetGmo.Options      = 1;
                this.recoveryGetGmo.WaitInterval = 0x3e8;
                this.InitializeTransactionRecovery();
            }
            catch (MQException exception)
            {
                base.TrException(method, exception, 1);
                throw exception;
            }
            catch (Exception exception2)
            {
                base.TrException(method, exception2, 2);
                NmqiException exception3 = new NmqiException(env, -1, null, 2, 0x893, exception2);
                throw exception3;
            }
            finally
            {
                base.TrExit(method);
            }
        }
        private MQProxyQueue FindProxyQueue(int clientId)
        {
            uint method = 0x604;

            this.TrEntry(method, new object[] { clientId });
            MQProxyQueue queue = null;

            try
            {
                this.findingPQueue.Acquire();
                try
                {
                    queue = this.proxyQueues[clientId];
                }
                catch (KeyNotFoundException)
                {
                }
                if (queue == null)
                {
                    NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x893, null);
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = this.hconn.Session.ParentConnection.NegotiatedChannel.ChannelName.Trim();
                    CommonServices.CommentInsert2 = "No proxy queue with ClientId ";
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                    base.TrException(method, ex);
                    throw ex;
                }
            }
            finally
            {
                this.findingPQueue.Release();
                base.TrExit(method);
            }
            return(queue);
        }
Esempio n. 18
0
        public void Run()
        {
            uint method = 0x60e;

            this.TrEntry(method);
            this.threadId = Thread.CurrentThread.GetHashCode();
            string str = "RcvThread: " + this.remoteConnection.ToString();

            Thread.CurrentThread.Name = str;
            try
            {
                int       conversationID;
                int       requestID;
                MQSession sessionByConvId;
                int       segmentType;
                MQSOCKACT mqsockact;
                MQTSH     rTSH = null;
Label_0040:
                rTSH = this.ReceiveOneTSH();
                if (rTSH == null)
                {
                    base.TrText(method, "Null TSH is received.. breaking and disconnecting now");
                    return;
                }
                if (this.remoteConnection.RemoteEncoding != rTSH.Encoding)
                {
                    this.remoteConnection.RemoteEncoding = rTSH.Encoding;
                }
                switch (rTSH.TSHType)
                {
                case 1:
                    base.TrText(method, "TSHM data has been received");
                    conversationID = rTSH.ConversationID;
                    requestID      = rTSH.RequestID;
                    base.TrText(method, "ConversationId = " + conversationID);
                    base.TrText(method, "RequestId = " + requestID);
                    sessionByConvId = this.remoteConnection.GetSessionByConvId(conversationID);
                    if ((sessionByConvId == null) || !sessionByConvId.IsEndRequested)
                    {
                        break;
                    }
                    base.TrText(method, "Current Sessions " + sessionByConvId.ToString() + " ending..");
                    goto Label_0040;

                case 2:
                {
                    if (rTSH.SegmentType != 12)
                    {
                        goto Label_0515;
                    }
                    mqsockact = new MQSOCKACT();
                    if ((rTSH.Encoding & 15) == 2)
                    {
                        goto Label_037D;
                    }
                    base.TrText(method, "We received BigEndian data, read it into our encoding");
                    byte[] dst = new byte[mqsockact.GetLength()];
                    Buffer.BlockCopy(rTSH.TshBuffer, rTSH.Offset, dst, 0, mqsockact.GetLength());
                    Array.Reverse(dst);
                    mqsockact.ReadStruct(dst, 0);
                    goto Label_0391;
                }

                default:
                {
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = this.remoteConnection.NegotiatedChannel.ChannelName;
                    CommonServices.CommentInsert2 = "Invalid TSH flow is received on the receiver thread";
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                    NmqiException exception7 = new NmqiException(base.env, -1, null, 2, 0x7d9, null);
                    base.TrException(method, exception7);
                    throw exception7;
                }
                }
                if (requestID == 0)
                {
                    if (sessionByConvId != null)
                    {
                        sessionByConvId.DeliverTSH(rTSH);
                    }
                    else if (conversationID == 1)
                    {
                        this.remoteConnection.DeliverTSH(rTSH);
                    }
                    else
                    {
                        base.TrText(method, "Unknown Conversation & RequestId");
                    }
                }
                else
                {
                    if (requestID != 1)
                    {
                        goto Label_0285;
                    }
                    if (sessionByConvId == null)
                    {
                        base.TrText(method, "Unknown Conversation and no existing Session could be found for it.");
                    }
                    else
                    {
                        MQProxyQueueManager proxyQueueManager;
                        rTSH        = sessionByConvId.ProcessReceivedData(rTSH);
                        segmentType = rTSH.SegmentType;
                        switch (segmentType)
                        {
                        case 13:
                        case 15:
                            proxyQueueManager = sessionByConvId.Hconn.ProxyQueueManager;
                            if (proxyQueueManager == null)
                            {
                                NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x7d9, null);
                                CommonServices.SetValidInserts();
                                CommonServices.ArithInsert1   = 1;
                                CommonServices.ArithInsert2   = (uint)segmentType;
                                CommonServices.CommentInsert1 = "PQM couldn't be found on obtained Session for TSH flow";
                                base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                                throw exception;
                            }
                            break;

                        default:
                            goto Label_0237;
                        }
                        switch (segmentType)
                        {
                        case 13:
                            proxyQueueManager.AddMessage(rTSH);
                            break;

                        case 15:
                            proxyQueueManager.ReceiveNotification(rTSH);
                            break;
                        }
                        sessionByConvId.ReleaseReceivedTSH(rTSH);
                    }
                }
                goto Label_0040;
Label_0237:
                CommonServices.SetValidInserts();
                CommonServices.ArithInsert1   = 1;
                CommonServices.ArithInsert2   = (uint)segmentType;
                CommonServices.CommentInsert1 = "Incorrect Segment type received on multiplexing flow";
                base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                NmqiException exception2 = new NmqiException(base.env, -1, null, 2, 0x7d9, null);
                throw exception2;
Label_0285:
                if ((requestID % 2) != 0)
                {
                    if (sessionByConvId == null)
                    {
                        base.TrText(method, "Unknown Conversation and no existing Session could be found for it.");
                    }
                    else
                    {
                        sessionByConvId.DeliverExchangeReply(requestID, rTSH);
                    }
                    goto Label_0040;
                }
                NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x893, null);
                CommonServices.SetValidInserts();
                CommonServices.ArithInsert1   = 1;
                CommonServices.CommentInsert1 = this.remoteConnection.NegotiatedChannel.ChannelName;
                CommonServices.CommentInsert2 = "Unknown request id flow on the multiplexed connection";
                base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                base.TrException(method, ex);
                throw ex;
Label_037D:
                mqsockact.ReadStruct(rTSH.TshBuffer, rTSH.Offset);
Label_0391:
                switch (mqsockact.Type)
                {
                case 1:
                case 4:
                case 5:
                case 6:
                    goto Label_0040;

                case 2:
                {
                    bool informQmgr = false;
                    if ((rTSH.ControlFlags1 & 1) != 0)
                    {
                        base.TrText(method, "rfpSAT_END_CONV request with rfpTCF_CONFIRM_REQUEST received");
                        informQmgr = true;
                    }
                    int       convId   = mqsockact.ConversationID;
                    MQSession session2 = this.remoteConnection.GetSessionByConvId(convId);
                    if (session2 != null)
                    {
                        this.remoteConnection.RemoveSession(session2.ConversationId, informQmgr);
                        NmqiException exception4 = new NmqiException(base.env, -1, null, 2, 0x7d9, null);
                        base.TrException(method, exception4);
                        session2.AsyncFailureNotify(exception4);
                    }
                    else if (convId == 1)
                    {
                        NmqiException exception5 = new NmqiException(base.env, -1, null, 2, 0x7d9, null);
                        base.TrException(method, exception5);
                        this.remoteConnection.AsyncFailureNotify(exception5, false);
                    }
                    else
                    {
                        base.TrData(method, 1, "hConn not recognised by connection,ConversationID ", BitConverter.GetBytes(mqsockact.ConversationID));
                    }
                    goto Label_057D;
                }

                case 3:
                {
                    NmqiException exception6 = new NmqiException(base.env, -1, null, 2, 0x89a, null);
                    base.TrException(method, exception6);
                    this.remoteConnection.AsyncFailureNotify(exception6, true);
                    goto Label_0040;
                }

                case 7:
                    this.remoteConnection.QmQuiescing();
                    goto Label_057D;

                case 9:
                    switch (mqsockact.Parm1)
                    {
                    case 1:
                        goto Label_0507;
                    }
                    goto Label_057D;

                default:
                    goto Label_057D;
                }
                this.remoteConnection.NotifyReconnect(false);
                goto Label_057D;
Label_0507:
                this.remoteConnection.NotifyReconnect(true);
                goto Label_057D;
Label_0515:
                if ((rTSH.ControlFlags1 & 8) != 0)
                {
                    this.remoteConnection.AnalyseErrorSegment(rTSH);
                    goto Label_057D;
                }
                if (rTSH.SegmentType != 9)
                {
                    goto Label_0570;
                }
                if (this.remoteConnection.FapLevel >= 10)
                {
                    if ((rTSH.ControlFlags1 & 1) != 0)
                    {
                        goto Label_0562;
                    }
                    goto Label_0040;
                }
                if ((rTSH.ControlFlags1 & 1) != 0)
                {
                    goto Label_0040;
                }
Label_0562:
                this.remoteConnection.SendHeartbeat(2);
                goto Label_057D;
Label_0570:
                if (rTSH.SegmentType == 11)
                {
                    goto Label_0040;
                }
Label_057D:
                this.remoteConnection.ReleaseReceivedTSH(rTSH);
                goto Label_0040;
            }
            catch (Exception exception8)
            {
                base.TrException(method, exception8, 1);
                NmqiException e = null;
                if (exception8 is NmqiException)
                {
                    e = (NmqiException)exception8;
                }
                else if (exception8 is MQException)
                {
                    e = new NmqiException(base.env, -1, null, (exception8 as MQException).CompCode, (exception8 as MQException).Reason, null);
                }
                else
                {
                    int compCode = 2;
                    int reason   = 0x893;
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = this.remoteConnection.NegotiatedChannel.ChannelName.Trim();
                    CommonServices.CommentInsert2 = "System Exception generated on Receiver thread - " + exception8.Message;
                    CommonServices.CommentInsert3 = "Exception Stack - " + exception8.StackTrace;
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                    e = new NmqiException(base.env, -1, null, compCode, reason, exception8);
                }
                try
                {
                    if (this.remoteConnection != null)
                    {
                        this.remoteConnection.AsyncFailureNotify(e, false);
                    }
                }
                catch (NmqiException exception10)
                {
                    base.TrException(method, exception10, 2);
                }
                catch (Exception exception11)
                {
                    base.TrException(method, exception11, 3);
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = 1;
                    CommonServices.CommentInsert1 = this.remoteConnection.NegotiatedChannel.ChannelName;
                    CommonServices.CommentInsert2 = "System Exception generated on AsyncFailureNotify - " + exception11.Message;
                    CommonServices.CommentInsert3 = "Exception Stack - " + exception11.StackTrace;
                    base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                }
                if (!this.disconnecting)
                {
                    try
                    {
                        if (this.remoteConnection != null)
                        {
                            this.remoteConnection.Disconnect();
                        }
                    }
                    catch (NmqiException exception12)
                    {
                        base.TrException(method, exception12, 4);
                    }
                    catch (Exception exception13)
                    {
                        base.TrException(method, exception13, 5);
                        CommonServices.SetValidInserts();
                        CommonServices.ArithInsert1   = 1;
                        CommonServices.CommentInsert1 = this.remoteConnection.NegotiatedChannel.ChannelName;
                        CommonServices.CommentInsert2 = "System Exception generated while Disconnecting - " + exception13.Message;
                        CommonServices.CommentInsert3 = "Exception Stack - " + exception13.StackTrace;
                        base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009213, 0);
                    }
                }
            }
            finally
            {
                if (this.commsBuffer != null)
                {
                    this.commsBuffer.Free();
                }
                base.TrExit(method);
            }
        }
Esempio n. 19
0
        public void Run()
        {
            uint method = 0x3b9;

            this.TrEntry(method);
            this.threadName           = "DispatchThread: [" + this.hconn + "]";
            Thread.CurrentThread.Name = this.threadName;
            base.TrText(method, "Dispatcher's name = " + this.threadName);
            Thread.SetData(Thread.GetNamedDataSlot("MQ_CLIENT_THREAD_TYPE"), 2);
            int num2 = 0;
            int num3 = 0;

            try
            {
                this.hconn.RequestThreadLock();
                this.hconn.ReleaseThreadLock();
                while (!this.exitThread)
                {
                    num2 = 0;
                    this.savedDispatchSeq = this.dispatchSeq;
                    this.noMsgsWait       = 0;
                    if (this.hconnActive)
                    {
                        this.hconn.RequestDispatchLock(-1);
                        try
                        {
                            this.ProcessHconn();
                            if ((this.hconnActive && this.hconn.IsStarted()) && !this.hconn.IsSuspended())
                            {
                                this.processed = 0;
                                num3           = 0;
                                MQProxyQueue[] getDispatchQueueList = this.hconn.GetDispatchQueueList;
                                for (int i = 0; i < getDispatchQueueList.Length; i++)
                                {
                                    MQProxyQueue pq = getDispatchQueueList[i];
                                    this.waitQ = (pq.MqcbGmo.WaitInterval > 0) && ((pq.MqcbGmo.Options & 1) != 0);
                                    if (this.waitQ)
                                    {
                                        this.now = DateTime.Now.Millisecond;
                                    }
                                    IntPtr callbackFunction = pq.MqcbCBD.CallbackFunction;
                                    if ((pq.Status & 0x40000) == 0)
                                    {
                                        if (pq.EventsRaised != this.hconn.EventsHad)
                                        {
                                            pq.DriveEventsMC();
                                        }
                                        if (!pq.IsEmpty())
                                        {
                                            this.DeliverMsgs(pq);
                                        }
                                        else if (this.ShouldDriveNoMsgs(pq) || pq.CallbackOnEmpty())
                                        {
                                            pq.CallConsumer(5, 2, 0x7f1);
                                            pq.UnsetCallbackOnEmpty();
                                        }
                                        if (this.hconn.ConsumersChanged())
                                        {
                                            this.hconn.DriveOutstanding();
                                        }
                                        if ((pq.Status & 0x80) != 0)
                                        {
                                            if (this.processed != 0)
                                            {
                                                num3++;
                                            }
                                        }
                                        else
                                        {
                                            num3++;
                                        }
                                        if ((pq.Status & 0x80000) != 0)
                                        {
                                            this.hconn.RemoveFromDispatchList(pq);
                                            this.hconn.ProxyQueueManager.DeleteProxyQueue(pq);
                                        }
                                    }
                                    num2 += this.processed;
                                    getDispatchQueueList = this.hconn.GetDispatchQueueList;
                                }
                            }
                        }
                        finally
                        {
                            if (this.hconn != null)
                            {
                                try
                                {
                                    this.hconn.ReleaseDispatchLock();
                                }
                                catch (SynchronizationLockException)
                                {
                                }
                            }
                        }
                        Thread.Sleep(0);
                    }
                    if ((num2 == 0) && (this.savedDispatchSeq == this.dispatchSeq))
                    {
                        this.hconn.RequestThreadLock();
                        try
                        {
                            if (this.savedDispatchSeq != this.dispatchSeq)
                            {
                                continue;
                            }
                            this.status |= 1;
                        }
                        finally
                        {
                            this.hconn.ReleaseThreadLock();
                        }
                        this.SleepPhase();
                    }
                }
            }
            catch (Exception exception)
            {
                NmqiException ex = null;
                if ((exception is NmqiException) || (exception is MQException))
                {
                    if (exception is MQException)
                    {
                        ex = new NmqiException(base.env, -1, null, ((MQException)exception).CompCode, ((MQException)exception).Reason, exception);
                    }
                    else
                    {
                        ex = (NmqiException)exception;
                    }
                    if (ex.Reason == 0x893)
                    {
                        CommonServices.SetValidInserts();
                        CommonServices.ArithInsert1   = 1;
                        CommonServices.ArithInsert2   = (uint)this.status;
                        CommonServices.CommentInsert1 = exception.Message;
                        CommonServices.CommentInsert2 = exception.StackTrace;
                        base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                    }
                    base.TrException(method, ex);
                    throw ex;
                }
                CommonServices.SetValidInserts();
                CommonServices.ArithInsert1   = 1;
                CommonServices.ArithInsert2   = (uint)this.status;
                CommonServices.CommentInsert1 = exception.Message;
                CommonServices.CommentInsert2 = exception.StackTrace;
                base.FFST("%Z% %W%  %I% %E% %U%", "%C%", method, 1, 0x20009546, 0);
                base.TrException(method, exception);
                throw exception;
            }
            finally
            {
                base.TrExit(method);
            }
        }
        private MQFAPConnection CreateAndConnectConnection(MQChannelDefinition mqcd, MQSSLConfigOptions sslConfigOptions, MQConnectionSecurityParameters mqcsp, MQFAP fap, string qMgrName, int connectOptions, int maxFapLevel)
        {
            MQFAPConnection connection;
            uint            method = 0x59a;

            this.TrEntry(method, new object[] { mqcsp, fap, qMgrName, connectOptions, maxFapLevel });
            try
            {
                if (mqcd == null)
                {
                    CommonServices.SetValidInserts();
                    CommonServices.CommentInsert1 = "No Channel Definition to establish connection";
                    base.FFST("%Z% %W% %I% %E% %U%", "%C%", method, 1, 0x20009519, 0);
                    NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x893, null);
                    throw exception;
                }
                if (mqcd.TransportType == 2)
                {
                    connection = new MQTCPConnection(base.env, this, fap, mqcd, sslConfigOptions, this.GetConnectOptions(connectOptions));
                }
                else
                {
                    string[] inserts = new string[3];
                    inserts[2] = mqcd.TransportType.ToString();
                    NmqiException exception2 = new NmqiException(base.env, 0x26bb, inserts, 2, 0x80b, null);
                    throw exception2;
                }
                this.connectionsLock.Acquire();
                this.connectingConnections++;
                try
                {
                    MQChannelDefinition definition = connection.ClientConn.Clone();
                    definition.Version           = 11;
                    connection.NegotiatedChannel = definition;
                }
                catch (Exception exception3)
                {
                    base.TrException(method, exception3, 1);
                    NmqiException exception4 = new NmqiException(base.env, -1, null, 2, 0x8e5, null);
                    throw exception4;
                }
                connection.InitSecurityExits();
                try
                {
                    connection.Connect(mqcsp);
                }
                catch (Exception exception5)
                {
                    base.TrException(method, exception5, 2);
                    connection = null;
                    throw exception5;
                }
            }
            finally
            {
                this.connectingConnections--;
                this.connectionsLock.Release();
                this.connectionsLock.PulseAll();
                base.TrExit(method);
            }
            return(connection);
        }
Esempio n. 21
0
        internal MQTSH ExchangeTSH(MQTSH requestTsh)
        {
            uint method = 0x622;

            this.TrEntry(method, new object[] { requestTsh });
            MQTSH result = null;

            try
            {
                MQRequestEntry entry2;
                if (this.disconnected)
                {
                    NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                    base.TrException(method, ex);
                    this.connectionBroken = true;
                    this.hconn.RaiseEvent(0x7d9);
                }
                MQRequestEntry entry = this.AllocateRequestEntry();
                requestTsh.SetRequestId(entry.RequestID);
                byte[] bytes = BitConverter.GetBytes(IPAddress.NetworkToHostOrder(entry.RequestID));
                for (int i = 12; i < 0x10; i++)
                {
                    requestTsh.TshBuffer[i] = bytes[i - 12];
                }
                requestTsh.ControlFlags1 = (byte)(requestTsh.ControlFlags1 | 1);
                this.SendData(requestTsh.TshBuffer, 0, requestTsh.Length, requestTsh.SegmentType, 1);
                Monitor.Enter(entry2 = entry);
                try
                {
                    while (entry.Reply == null)
                    {
                        Monitor.Wait(entry, this.rmtReqEntMaxPollTime, true);
                        if ((this.asyncFailure != null) || !this.Connection.IsConnected)
                        {
                            NmqiException exception2 = new NmqiException(base.env, -1, null, 2, 0x7d9, this.asyncFailure);
                            base.TrException(method, exception2);
                            throw exception2;
                        }
                    }
                }
                catch (ThreadInterruptedException exception3)
                {
                    string str = "Interrupted while waiting for exchange reply";
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = (uint)this.conversationId;
                    CommonServices.ArithInsert2   = (uint)entry.RequestID;
                    CommonServices.CommentInsert1 = str;
                    base.FFST("%Z% %W% %I% %E% %U%", "%C%", method, 1, 0x8e1, 0);
                    NmqiException exception4 = new NmqiException(base.env, -1, null, 2, 0x893, exception3);
                    base.TrException(method, exception4);
                    throw exception4;
                }
                finally
                {
                    Monitor.Exit(entry2);
                }
                result = entry.Reply;
                this.ReleaseRequestEntry(entry);
            }
            finally
            {
                base.TrExit(method, result);
            }
            return(result);
        }
Esempio n. 22
0
        internal void StartConversation()
        {
            uint method = 0x621;

            this.TrEntry(method);
            MQSOCKACT mqsockact   = new MQSOCKACT();
            int       translength = 0x1c + mqsockact.GetLength();
            bool      flag        = CommonServices.TraceEnabled();
            MQTSH     rTSH        = null;

            try
            {
                MQTSH tsh = this.AllocateTSH(2, 12, 0, true, translength);
                mqsockact.Type           = 1;
                mqsockact.ConversationID = this.conversationId;
                mqsockact.RequestID      = 0;
                mqsockact.Parm1          = Thread.CurrentThread.ManagedThreadId;
                mqsockact.Parm2          = this.traceIdentifier;
                tsh.Offset = tsh.WriteStruct(tsh.TshBuffer, tsh.Offset);
                tsh.Offset = mqsockact.WriteStruct(tsh.TshBuffer, tsh.Offset);
                tsh.Offset = 0;
                if (flag)
                {
                    base.TrAPI(method, "__________");
                    base.TrAPI(method, "START CONVERSATION FLOW >>");
                    base.TrData(method, 0, "Conversation Id", BitConverter.GetBytes(this.ConversationId));
                    base.TrData(method, 0, "Buffer", tsh.Offset, tsh.Length, tsh.TshBuffer);
                    base.TrAPIOutput(method, "CompCode");
                    base.TrAPIOutput(method, "Reason");
                }
                try
                {
                    try
                    {
                        this.parentConnection.RequestSendLock();
                        this.Connection.SendTSH(tsh);
                    }
                    finally
                    {
                        this.parentConnection.ReleaseSendLock();
                    }
                    rTSH = this.ReceiveTSH(null);
                    if ((rTSH.ControlFlags1 & 8) != 0)
                    {
                        NmqiException exception = new NmqiException(base.env, -1, null, 2, 0x80b, null);
                        base.TrException(method, exception);
                        throw exception;
                    }
                    switch (rTSH.SegmentType)
                    {
                    case 5:
                        if ((rTSH.ControlFlags1 & 2) != 0)
                        {
                            NmqiException exception2 = new NmqiException(base.env, -1, null, 2, 0x8e1, null);
                            base.TrException(method, exception2);
                            throw exception2;
                        }
                        return;

                    case 12:
                        mqsockact.ReadStruct(rTSH.TshBuffer, rTSH.Offset);
                        return;
                    }
                    CommonServices.SetValidInserts();
                    CommonServices.ArithInsert1   = (uint)this.conversationId;
                    CommonServices.ArithInsert2   = (uint)mqsockact.Type;
                    CommonServices.CommentInsert1 = "Start Conversation Request has been refused by QMgr";
                    CommonServices.CommentInsert2 = "Unknown SockACT from server for START_CONV";
                    base.FFST("%Z% %W% %I% %E% %U%", "%C%", method, 1, 0x8e1, 0);
                    NmqiException ex = new NmqiException(base.env, -1, null, 2, 0x8e1, null);
                    base.TrException(method, ex);
                    throw ex;
                }
                finally
                {
                    if (flag)
                    {
                        base.TrAPI(method, "__________");
                        base.TrAPI(method, "START CONVERSATION FLOW <<");
                        base.TrData(method, 0, "Name", BitConverter.GetBytes(this.ConversationId));
                    }
                    this.ReleaseReceivedTSH(rTSH);
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 23
0
        private void SetValue(string rawsymbol, string value)
        {
            uint method = 0x63e;

            this.TrEntry(method);
            try
            {
                string str = rawsymbol.ToUpper();
                base.TrText(method, "RawSymbol =" + str);
                if (str.Equals("CN"))
                {
                    if (this.CN != null)
                    {
                        string[] inserts = new string[5];
                        inserts[2] = this.owningConnection.ChannelName;
                        inserts[4] = "CN (x2)";
                        NmqiException ex = new NmqiException(this.env, 0x25a8, inserts, 2, 0x95f, null);
                        base.TrException(method, ex);
                        throw ex;
                    }
                    this.CN = value.ToUpper();
                    base.TrText(method, "CN=" + this.CN);
                }
                else if (str.Equals("T"))
                {
                    if (this.T != null)
                    {
                        string[] strArray2 = new string[5];
                        strArray2[2] = this.owningConnection.ChannelName;
                        strArray2[4] = "T (x2)";
                        NmqiException exception2 = new NmqiException(this.env, 0x25a8, strArray2, 2, 0x95f, null);
                        base.TrException(method, exception2);
                        throw exception2;
                    }
                    this.T = value.ToUpper();
                    base.TrText(method, "T=" + this.T);
                }
                else if (str.Equals("O"))
                {
                    if (this.O != null)
                    {
                        string[] strArray3 = new string[5];
                        strArray3[2] = this.owningConnection.ChannelName;
                        strArray3[4] = "O (x2)";
                        NmqiException exception3 = new NmqiException(this.env, 0x25a8, strArray3, 2, 0x95f, null);
                        base.TrException(method, exception3);
                        throw exception3;
                    }
                    this.O = value.ToUpper();
                    base.TrText(method, "O=" + this.O);
                }
                else if (str.Equals("L"))
                {
                    if (this.L != null)
                    {
                        string[] strArray4 = new string[5];
                        strArray4[2] = this.owningConnection.ChannelName;
                        strArray4[4] = "L (x2)";
                        NmqiException exception4 = new NmqiException(this.env, 0x25a8, strArray4, 2, 0x95f, null);
                        base.TrException(method, exception4);
                        throw exception4;
                    }
                    this.L = value.ToUpper();
                    base.TrText(method, "L=" + this.L);
                }
                else if ((str.Equals("ST") || str.Equals("SP")) || str.Equals("S"))
                {
                    if (this.ST != null)
                    {
                        string[] strArray5 = new string[5];
                        strArray5[2] = this.owningConnection.ChannelName;
                        strArray5[4] = str + " (x2)";
                        NmqiException exception5 = new NmqiException(this.env, 0x25a8, strArray5, 2, 0x95f, null);
                        base.TrException(method, exception5);
                        throw exception5;
                    }
                    this.ST = value.ToUpper();
                    base.TrText(method, "ST=" + this.ST);
                }
                else if (str.Equals("C"))
                {
                    if (this.C != null)
                    {
                        string[] strArray6 = new string[5];
                        strArray6[2] = this.owningConnection.ChannelName;
                        strArray6[4] = "C (x2)";
                        NmqiException exception6 = new NmqiException(this.env, 0x25a8, strArray6, 2, 0x95f, null);
                        base.TrException(method, exception6);
                        throw exception6;
                    }
                    this.C = value.ToUpper();
                    base.TrText(method, "C=" + this.C);
                }
                else if (str.Equals("SERIALNUMBER"))
                {
                    if (this.SERIALNUMBER != null)
                    {
                        string[] strArray7 = new string[5];
                        strArray7[2] = this.owningConnection.ChannelName;
                        strArray7[4] = str + " (x2)";
                        NmqiException exception7 = new NmqiException(this.env, 0x25a8, strArray7, 2, 0x95f, null);
                        base.TrException(method, exception7);
                        throw exception7;
                    }
                    this.SERIALNUMBER = value.ToUpper();
                    base.TrText(method, "SERIALNUMBER=" + this.SERIALNUMBER);
                }
                else if (str.Equals("MAIL"))
                {
                    if (this.MAIL != null)
                    {
                        string[] strArray8 = new string[5];
                        strArray8[2] = this.owningConnection.ChannelName;
                        strArray8[4] = str + " (x2)";
                        NmqiException exception8 = new NmqiException(this.env, 0x25a8, strArray8, 2, 0x95f, null);
                        base.TrException(method, exception8);
                        throw exception8;
                    }
                    this.MAIL = value.ToUpper();
                    base.TrText(method, "MAIL=" + this.MAIL);
                }
                else if (str.Equals("E"))
                {
                    if (this.E != null)
                    {
                        string[] strArray9 = new string[5];
                        strArray9[2] = this.owningConnection.ChannelName;
                        strArray9[4] = str + " (x2)";
                        NmqiException exception9 = new NmqiException(this.env, 0x25a8, strArray9, 2, 0x95f, null);
                        base.TrException(method, exception9);
                        throw exception9;
                    }
                    this.E = value.ToUpper();
                    base.TrText(method, "E=" + this.E);
                }
                else if (str.Equals("UID") || str.Equals("USERID"))
                {
                    if (this.UID != null)
                    {
                        string[] strArray10 = new string[5];
                        strArray10[2] = this.owningConnection.ChannelName;
                        strArray10[4] = str + " (x2)";
                        NmqiException exception10 = new NmqiException(this.env, 0x25a8, strArray10, 2, 0x95f, null);
                        base.TrException(method, exception10);
                        throw exception10;
                    }
                    this.UID = value.ToUpper();
                    base.TrText(method, "UID=" + this.UID);
                }
                else if (str.Equals("STREET"))
                {
                    if (this.STREET != null)
                    {
                        string[] strArray11 = new string[5];
                        strArray11[2] = this.owningConnection.ChannelName;
                        strArray11[4] = str + " (x2)";
                        NmqiException exception11 = new NmqiException(this.env, 0x25a8, strArray11, 2, 0x95f, null);
                        base.TrException(method, exception11);
                        throw exception11;
                    }
                    this.STREET = value.ToUpper();
                    base.TrText(method, "STREET=" + this.STREET);
                }
                else if (str.Equals("PC") || str.Equals("POSTALCODE"))
                {
                    if (this.PC != null)
                    {
                        string[] strArray12 = new string[5];
                        strArray12[2] = this.owningConnection.ChannelName;
                        strArray12[4] = str + " (x2)";
                        NmqiException exception12 = new NmqiException(this.env, 0x25a8, strArray12, 2, 0x95f, null);
                        base.TrException(method, exception12);
                        throw exception12;
                    }
                    this.PC = value.ToUpper();
                    base.TrText(method, "PC=" + this.PC);
                }
                else if (str.Equals("UNSTRUCTUREDNAME"))
                {
                    if (this.UNSTRUCTUREDNAME != null)
                    {
                        string[] strArray13 = new string[5];
                        strArray13[2] = this.owningConnection.ChannelName;
                        strArray13[4] = str + " (x2)";
                        NmqiException exception13 = new NmqiException(this.env, 0x25a8, strArray13, 2, 0x95f, null);
                        base.TrException(method, exception13);
                        throw exception13;
                    }
                    this.UNSTRUCTUREDNAME = value.ToUpper();
                    base.TrText(method, "UNSTRUCTUREDNAME=" + this.UNSTRUCTUREDNAME);
                }
                else if (str.Equals("UNSTRUCTUREDADDRESS"))
                {
                    if (this.UNSTRUCTUREDADDRESS != null)
                    {
                        string[] strArray14 = new string[5];
                        strArray14[2] = this.owningConnection.ChannelName;
                        strArray14[4] = str + " (x2)";
                        NmqiException exception14 = new NmqiException(this.env, 0x25a8, strArray14, 2, 0x95f, null);
                        base.TrException(method, exception14);
                        throw exception14;
                    }
                    this.UNSTRUCTUREDADDRESS = value.ToUpper();
                    base.TrText(method, "UNSTRUCTUREDADDRESS=" + this.UNSTRUCTUREDADDRESS);
                }
                else if (str.Equals("DNQ"))
                {
                    if (this.DNQ != null)
                    {
                        string[] strArray15 = new string[5];
                        strArray15[2] = this.owningConnection.ChannelName;
                        strArray15[4] = str + " (x2)";
                        NmqiException exception15 = new NmqiException(this.env, 0x25a8, strArray15, 2, 0x95f, null);
                        base.TrException(method, exception15);
                        throw exception15;
                    }
                    this.DNQ = value.ToUpper();
                    base.TrText(method, "DNQ=" + this.DNQ);
                }
                else if (str.Equals("OU"))
                {
                    this.OU.Add(value.ToUpper());
                    base.TrText(method, "OU=" + this.OU);
                }
                else if (str.Equals("DC"))
                {
                    this.DC.Add(value.ToUpper());
                    base.TrText(method, "OU=" + this.OU);
                }
                else if (this.matcher)
                {
                    string[] strArray16 = new string[5];
                    strArray16[2] = this.owningConnection.ChannelName;
                    strArray16[4] = str + " (x2)";
                    NmqiException exception16 = new NmqiException(this.env, 0x25a8, strArray16, 2, 0x95f, null);
                    base.TrException(method, exception16);
                    throw exception16;
                }
            }
            finally
            {
                base.TrExit(method);
            }
        }
Esempio n. 24
0
        private void ParseDN(string DN)
        {
            uint method = 0x63d;

            this.TrEntry(method);
            int    dNCLEAR   = DNCLEAR;
            string rawsymbol = "";
            string str2      = "";

            base.TrText(method, "DN String = " + DN);
            if ((DN != null) && DN.Equals(""))
            {
                dNCLEAR = DNFINISHED;
                base.TrText(method, "State=" + dNCLEAR);
            }
            try
            {
                for (int i = 0; i < DN.Length; i++)
                {
                    char ch = DN.ToCharArray()[i];
                    if (dNCLEAR == DNCLEAR)
                    {
                        switch (ch)
                        {
                        case '"':
                        case ',':
                        case ';':
                        case '=':
                        {
                            string[] inserts = new string[5];
                            inserts[2] = this.owningConnection.ChannelName;
                            inserts[4] = Convert.ToString(ch);
                            NmqiException ex = new NmqiException(this.env, 0x25a8, inserts, 2, 0x95f, null);
                            base.TrException(method, ex);
                            throw ex;
                        }
                        }
                        if ((ch != ' ') && (ch != '\t'))
                        {
                            rawsymbol = rawsymbol + ch;
                            dNCLEAR   = DNSYMBOL;
                            base.TrText(method, "State=" + dNCLEAR);
                        }
                    }
                    else if (dNCLEAR == DNSYMBOL)
                    {
                        switch (ch)
                        {
                        case ' ':
                        case '"':
                        {
                            string[] strArray2 = new string[5];
                            strArray2[2] = this.owningConnection.ChannelName;
                            strArray2[4] = Convert.ToString(ch);
                            NmqiException exception2 = new NmqiException(this.env, 0x25a8, strArray2, 2, 0x95f, null);
                            base.TrException(method, exception2);
                            throw exception2;
                        }
                        }
                        if (ch == '=')
                        {
                            str2 = "";
                            if ((i + 1) >= DN.Length)
                            {
                                dNCLEAR = DNVALUE;
                                base.TrText(method, "State=" + dNCLEAR);
                            }
                            else if (DN.ToCharArray()[i + 1] == '"')
                            {
                                i++;
                                dNCLEAR = DNQVALUE;
                                base.TrText(method, "State=" + dNCLEAR);
                            }
                            else
                            {
                                dNCLEAR = DNVALUE;
                                base.TrText(method, "State=" + dNCLEAR);
                            }
                        }
                        else
                        {
                            rawsymbol = rawsymbol + ch;
                        }
                    }
                    else if (dNCLEAR == DNVALUE)
                    {
                        if (((ch == ',') || (ch == ';')) && ((i == 0) || (DN.ToCharArray()[i - 1] != '\\')))
                        {
                            dNCLEAR = DNCLEAR;
                            base.TrText(method, "State=" + dNCLEAR);
                            this.SetValue(rawsymbol, str2.Trim());
                            rawsymbol = "";
                        }
                        else
                        {
                            str2 = str2 + ch;
                            base.TrText(method, "State=" + dNCLEAR);
                        }
                    }
                    else if (dNCLEAR == DNQVALUE)
                    {
                        if ((ch == '"') && ((i == 0) || (DN.ToCharArray()[i - 1] != '\\')))
                        {
                            dNCLEAR = DNFINISHED;
                            base.TrText(method, "State=" + dNCLEAR);
                            this.SetValue(rawsymbol, str2);
                            rawsymbol = "";
                        }
                        else
                        {
                            str2 = str2 + ch;
                        }
                    }
                    else if (dNCLEAR == DNFINISHED)
                    {
                        if ((ch == ',') || (ch == ';'))
                        {
                            dNCLEAR = DNCLEAR;
                            base.TrText(method, "State=" + dNCLEAR);
                        }
                        else if ((ch != ' ') && (ch != '\t'))
                        {
                            string[] strArray3 = new string[5];
                            strArray3[2] = this.owningConnection.ChannelName;
                            strArray3[4] = Convert.ToString(ch);
                            NmqiException exception3 = new NmqiException(this.env, 0x25a8, strArray3, 2, 0x95f, null);
                            base.TrException(method, exception3);
                            throw exception3;
                        }
                    }
                }
                if (dNCLEAR == DNVALUE)
                {
                    base.TrText(method, "State=" + dNCLEAR);
                    this.SetValue(rawsymbol, str2.Trim());
                }
                if ((dNCLEAR == DNSYMBOL) || (dNCLEAR == DNCLEAR))
                {
                    string[] strArray4 = new string[5];
                    strArray4[2] = this.owningConnection.ChannelName;
                    strArray4[4] = rawsymbol;
                    NmqiException exception4 = new NmqiException(this.env, 0x25a8, strArray4, 2, 0x95f, null);
                    base.TrException(method, exception4);
                    throw exception4;
                }
            }
            catch (MQException exception5)
            {
                base.TrException(method, exception5);
                throw exception5;
            }
            finally
            {
                base.TrExit(method);
            }
        }