Exemplo n.º 1
0
 public bool IsNotSeenBefore(Message message, out byte[] id, out int cacheHit)
 {
     cacheHit = -1;
     id       = PeerNodeImplementation.DefaultId;
     if (message is SecurityVerifiedMessage)
     {
         id = (message as SecurityVerifiedMessage).PrimarySignatureValue;
     }
     else
     {
         System.Xml.UniqueId messageId = PeerMessageHelpers.GetHeaderUniqueId(message.Headers, PeerStrings.MessageId, PeerStrings.Namespace);
         if (messageId == null)
         {
             return(false);
         }
         if (messageId.IsGuid)
         {
             id = new byte[16];
             messageId.TryGetGuid(id, 0);
         }
         else
         {
             return(false);
         }
     }
     cacheHit = messageIds.AddForLookup(id);
     if (cacheHit == -1)
     {
         return(true);
     }
     return(false);
 }
        private int UpdateHopCount(Message message, out MessageHeader hopHeader, out ulong currentValue)
        {
            int index = -1;

            currentValue = ulong.MaxValue;
            hopHeader    = null;
            try
            {
                index = message.Headers.FindHeader("Hops", "http://schemas.microsoft.com/net/2006/05/peer/HopCount");
                if (index != -1)
                {
                    ulong num2;
                    currentValue = PeerMessageHelpers.GetHeaderULong(message.Headers, index);
                    currentValue = num2 = (ulong)(currentValue - 1L);
                    hopHeader    = MessageHeader.CreateHeader("Hops", "http://schemas.microsoft.com/net/2006/05/peer/HopCount", num2, false);
                }
            }
            catch (MessageHeaderException exception)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
            }
            catch (CommunicationException exception2)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
            }
            catch (SerializationException exception3)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
            }
            catch (XmlException exception4)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning);
            }
            return(index);
        }
Exemplo n.º 3
0
        int UpdateHopCount(Message message, out MessageHeader hopHeader, out ulong currentValue)
        {
            int index = -1;

            currentValue = PeerTransportConstants.MaxHopCount;
            hopHeader    = null;
            try
            {
                // If a message contains multiple Hopcounts with our name and namespace or the message can't deserialize to a ulong then ignore the HopCount
                index = message.Headers.FindHeader(PeerStrings.HopCountElementName, PeerStrings.HopCountElementNamespace);
                if (index != -1)
                {
                    currentValue = PeerMessageHelpers.GetHeaderULong(message.Headers, index);
                    hopHeader    = MessageHeader.CreateHeader(PeerStrings.HopCountElementName, PeerStrings.HopCountElementNamespace, --currentValue, false);
                }
            }
            catch (MessageHeaderException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
            }
            catch (CommunicationException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
            }
            catch (SerializationException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
            }
            catch (XmlException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
            }
            Fx.Assert((index == -1) || (hopHeader != null), "Could not successfully create new HopCount Header!");
            return(index);
        }
Exemplo n.º 4
0
 public bool IsNotSeenBefore(Message message, out byte[] id, out int cacheHit)
 {
     cacheHit = -1;
     id       = PeerNodeImplementation.DefaultId;
     if (message is SecurityVerifiedMessage)
     {
         id = (message as SecurityVerifiedMessage).PrimarySignatureValue;
     }
     else
     {
         UniqueId id2 = PeerMessageHelpers.GetHeaderUniqueId(message.Headers, "MessageID", "http://schemas.microsoft.com/net/2006/05/peer");
         if ((id2 != null) && id2.IsGuid)
         {
             id = new byte[0x10];
             id2.TryGetGuid(id, 0);
         }
         else
         {
             return(false);
         }
     }
     cacheHit = this.messageIds.AddForLookup(id);
     return(cacheHit == -1);
 }
Exemplo n.º 5
0
        public string SelectOperation(ref Message message)
        {
            string action = message.Headers.Action;
            string str2   = null;

            byte[] defaultId             = PeerNodeImplementation.DefaultId;
            string str3                  = PeerStrings.FindAction(action);
            Uri    via                   = null;
            Uri    uri2                  = null;
            bool   flag                  = false;
            PeerMessageProperty property = new PeerMessageProperty();

            if (str3 != null)
            {
                return(str3);
            }
            try
            {
                str2 = PeerMessageHelpers.GetHeaderString(message.Headers, "FloodMessage", "http://schemas.microsoft.com/net/2006/05/peer");
                via  = PeerMessageHelpers.GetHeaderUri(message.Headers, "PeerVia", "http://schemas.microsoft.com/net/2006/05/peer");
                uri2 = PeerMessageHelpers.GetHeaderUri(message.Headers, "PeerTo", "http://schemas.microsoft.com/net/2006/05/peer");
            }
            catch (MessageHeaderException exception)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
                return("Fault");
            }
            catch (SerializationException exception2)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning);
                return("Fault");
            }
            catch (XmlException exception3)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning);
                return("Fault");
            }
            property.PeerVia = via;
            property.PeerTo  = uri2;
            message.Properties.Add("PeerProperty", property);
            if (!(str2 == "PeerFlooder"))
            {
                return(null);
            }
            try
            {
                if (!this.messageHandler.ValidateIncomingMessage(ref message, via))
                {
                    property.SkipLocalChannels = true;
                    flag = true;
                    TurnOffSecurityHeader(message);
                }
                if (this.messageHandler.IsNotSeenBefore(message, out defaultId, out property.CacheMiss))
                {
                    property.MessageVerified = true;
                }
                else if (!flag)
                {
                    property.SkipLocalChannels = true;
                }
                if (defaultId == PeerNodeImplementation.DefaultId)
                {
                    return("Fault");
                }
            }
            catch (MessageHeaderException exception4)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning);
                return("Fault");
            }
            catch (SerializationException exception5)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception5, TraceEventType.Warning);
                return("Fault");
            }
            catch (XmlException exception6)
            {
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception6, TraceEventType.Warning);
                return("Fault");
            }
            catch (MessageSecurityException exception7)
            {
                if (!exception7.ReplayDetected)
                {
                    return("Fault");
                }
                System.ServiceModel.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception7, TraceEventType.Information);
            }
            return("FloodMessage");
        }
Exemplo n.º 6
0
 //this method takes care of closing the message.
 void SendMessageToNeighbor(IPeerNeighbor neighbor, Message message, PeerMessageHelpers.CleanupCallback cleanupCallback)
 {
     bool fatal = false;
     try
     {
         neighbor.Send(message);
     }
     catch (Exception e)
     {
         if (Fx.IsFatal(e))
         {
             fatal = true;
             throw;
         }
         if (e is CommunicationException ||
             e is QuotaExceededException ||
             e is ObjectDisposedException ||
             e is TimeoutException)
         {
             DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
             // Message failed to transmit due to quota exceeding or channel failure
             if (cleanupCallback != null)
             {
                 cleanupCallback(neighbor, PeerCloseReason.InternalFailure, e);
             }
         }
         else
         {
             throw;
         }
     }
     finally
     {
         if (!fatal)
             message.Close();
     }
 }
 private void SendMessageToNeighbor(IPeerNeighbor neighbor, Message message, PeerMessageHelpers.CleanupCallback cleanupCallback)
 {
     bool flag = false;
     try
     {
         neighbor.Send(message);
     }
     catch (Exception exception)
     {
         if (Fx.IsFatal(exception))
         {
             flag = true;
             throw;
         }
         if ((!(exception is CommunicationException) && !(exception is QuotaExceededException)) && (!(exception is ObjectDisposedException) && !(exception is TimeoutException)))
         {
             throw;
         }
         DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information);
         if (cleanupCallback != null)
         {
             cleanupCallback(neighbor, PeerCloseReason.InternalFailure, exception);
         }
     }
     finally
     {
         if (!flag)
         {
             message.Close();
         }
     }
 }
        public string SelectOperation(ref Message message)
        {
            string action = message.Headers.Action;
            string demux  = null;

            byte[] id        = PeerNodeImplementation.DefaultId;
            string operation = PeerStrings.FindAction(action);
            Uri    via       = null;
            Uri    to        = null;
            bool   skipped   = false;
            PeerMessageProperty peerProperty = new PeerMessageProperty();

            if (operation != null)
            {
                return(operation);
            }
            try
            {
                demux = PeerMessageHelpers.GetHeaderString(message.Headers, PeerOperationNames.Flood, PeerStrings.Namespace);
                via   = PeerMessageHelpers.GetHeaderUri(message.Headers, PeerStrings.Via, PeerStrings.Namespace);
                to    = PeerMessageHelpers.GetHeaderUri(message.Headers, PeerOperationNames.PeerTo, PeerStrings.Namespace);
            }
            catch (MessageHeaderException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                return(PeerOperationNames.Fault);
            }
            catch (SerializationException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                return(PeerOperationNames.Fault);
            }
            catch (XmlException e)
            {
                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                return(PeerOperationNames.Fault);
            }
            peerProperty.PeerVia = via;
            peerProperty.PeerTo  = to;
            message.Properties.Add(PeerStrings.PeerProperty, peerProperty);
            if (demux == PeerOperationNames.Demuxer)
            {
                try
                {
                    if (!this.messageHandler.ValidateIncomingMessage(ref message, via))
                    {
                        peerProperty.SkipLocalChannels = true;
                        skipped = true;
                        TurnOffSecurityHeader(message);
                    }
                    if (this.messageHandler.IsNotSeenBefore(message, out id, out peerProperty.CacheMiss))
                    {
                        peerProperty.MessageVerified = true;
                    }
                    else
                    {
                        if (!skipped)
                        {
                            peerProperty.SkipLocalChannels = true;
                        }
                    }
                    //means that the message doesnt contain legal id
                    if (id == PeerNodeImplementation.DefaultId)
                    {
                        return(PeerOperationNames.Fault);
                    }
                }
                catch (MessageHeaderException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                    return(PeerOperationNames.Fault);
                }
                catch (SerializationException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                    return(PeerOperationNames.Fault);
                }
                catch (XmlException e)
                {
                    DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
                    return(PeerOperationNames.Fault);
                }
                catch (MessageSecurityException e)
                {
                    if (!e.ReplayDetected)
                    {
                        return(PeerOperationNames.Fault);
                    }
                    else
                    {
                        DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
                    }
                }
                return(PeerOperationNames.Flood);
            }
            else
            {
                return(null);
            }
        }