static public bool TryCreateFault(Message message, MessageFault fault, out MakeConnectionMessageFault wsmcFault)
        {
            // all WS-MakeConnection faults are receiver faults
            if (!fault.Code.IsReceiverFault)
            {
                wsmcFault = null;
                return(false);
            }

            if ((fault.Code.SubCode == null) ||
                (fault.Code.SubCode.Namespace != MakeConnectionConstants.Namespace))
            {
                wsmcFault = null;
                return(false);
            }

            XmlDictionaryReader detailReader = null;
            string subcodeName = fault.Code.SubCode.Name;

            if (fault.HasDetail)
            {
                detailReader = fault.GetReaderAtDetailContents();
            }

            wsmcFault = CreateMakeConnectionFault(message, fault.Code, subcodeName, fault.Reason, detailReader);
            return(wsmcFault != null);
        }
        MakeConnectionMessageFault VerifyProtocolElements(MakeConnectionMessageInfo info)
        {
            if (!string.IsNullOrEmpty(info.UnknownSelection) || info.Identifier != null)
            {
                return(MakeConnectionMessageFault.CreateUnsupportedSelectionFault(this.RequestMessage, info.UnknownSelection));
            }
            else if (info.Address == null)
            {
                return(MakeConnectionMessageFault.CreateMissingSelectionFault(this.RequestMessage));
            }

            return(null);
        }
Пример #3
0
        void EndPoll(IAsyncResult result)
        {
            Message message = null;

            try
            {
                this.outstandingPoll = null;
                message = PollAsyncResult <TChannel> .End(result);

                if (message != null && message.IsFault)
                {
                    MessageFault fault = MessageFault.CreateFault(message, MakeConnectionConstants.Defaults.MaxFaultSize);
                    MakeConnectionMessageFault wsmcFault;

                    if (MakeConnectionMessageFault.TryCreateFault(message, fault, out wsmcFault))
                    {
                        throw MakeConnectionMessageFault.CreateException(wsmcFault);
                    }
                }
            }
            catch (TimeoutException)
            {
            }
            catch (Exception e)
            {
                EnqueueException(e);
            }

            if (message != null)
            {
                MakeConnectionDuplexClientChannel <TChannel> channelToDispatch = this.channel;
                if (channelToDispatch != null)
                {
                    channelToDispatch.EnqueueAndDispatch(message, null, false);
                }
            }

            lock (ThisLock)
            {
                polling = false;

                if (this.channel != null && !stopPolling)
                {
                    ThreadPool.QueueUserWorkItem(onEnsurePollingLater, this);
                }
                else
                {
                    this.pollingComplete.Set();
                }
            }
        }
        EndpointAddress GetAddress()
        {
            EndpointAddress address = null;

            if (this.IsMakeConnectionPollingMessage)
            {
                MakeConnectionMessageInfo  info  = MakeConnectionMessageInfo.ReadMessage(this.RequestMessage);
                MakeConnectionMessageFault fault = VerifyProtocolElements(info);

                if (fault == null)
                {
                    address = new EndpointAddress(info.Address);
                }
                else
                {
                    this.isFaulting = true;
                    IAsyncResult result = BeginReply(fault.CreateMessage(RequestMessage.Version), onFaultCompleted, this);
                    if (result.CompletedSynchronously)
                    {
                        OnFaultCompletedCore(result);
                    }
                }
            }
            else
            {
                // normal message, grab the reply-to
                address = this.RequestMessage.Headers.ReplyTo;
            }

            if (address != null)
            {
                this.addressIsAnonymousUri = MakeConnectionUtility.IsAnonymousUri(address.Uri);
            }

            return(address);
        }
 public static CommunicationException CreateException(MakeConnectionMessageFault fault)
 {
     return(fault.CreateException());
 }
 public static CommunicationException CreateException(MakeConnectionMessageFault fault)
 {
     return fault.CreateException();
 }
        public static bool TryCreateFault(Message message, MessageFault fault, out MakeConnectionMessageFault wsmcFault)
        {
            // all WS-MakeConnection faults are receiver faults
            if (!fault.Code.IsReceiverFault)
            {
                wsmcFault = null;
                return false;
            }

            if ((fault.Code.SubCode == null)
                || (fault.Code.SubCode.Namespace != MakeConnectionConstants.Namespace))
            {
                wsmcFault = null;
                return false;
            }

            XmlDictionaryReader detailReader = null;
            string subcodeName = fault.Code.SubCode.Name;
            if (fault.HasDetail)
            {
                detailReader = fault.GetReaderAtDetailContents();
            }

            wsmcFault = CreateMakeConnectionFault(message, fault.Code, subcodeName, fault.Reason, detailReader);
            return (wsmcFault != null);
        }