public static EndpointAddress ReadEndpointAddress(DiscoveryVersion discoveryVersion, XmlReader reader) { Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null"); Fx.Assert(reader != null, "The reader must be non null"); if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1) { EndpointAddressAugust2004 endpoint = discoveryVersion.Implementation.EprSerializer.ReadObject(reader) as EndpointAddressAugust2004; if (endpoint == null) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlEndpointNull)); } return(endpoint.ToEndpointAddress()); } else if (discoveryVersion == DiscoveryVersion.WSDiscovery11) { EndpointAddress10 endpoint = discoveryVersion.Implementation.EprSerializer.ReadObject(reader) as EndpointAddress10; if (endpoint == null) { throw FxTrace.Exception.AsError(new XmlException(SR2.DiscoveryXmlEndpointNull)); } return(endpoint.ToEndpointAddress()); } else { Fx.Assert("The discoveryVersion parameter cannot be null."); return(null); } }
public void Serialize() { var serializer = new XmlSerializer(typeof(SubscribeRequestMessageBody)); var message = new SubscribeRequestMessageBody(); // Supply mock Delivery var delivery = new Mock <Delivery>(MockBehavior.Strict); delivery.As <IXmlSerializable>().Setup(item => item.WriteXml(It.IsAny <XmlWriter>())); message.Delivery = delivery.Object; message.EndTo = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://tempuri.org/endTo")); // Supply mock Expires var expires = new Mock <Expires>(MockBehavior.Strict); expires.As <IXmlSerializable>().Setup(item => item.WriteXml(It.IsAny <XmlWriter>())); message.Expires = expires.Object; message.Filter = new XPathMessageFilter(@"/foo"); XElement xml; using (var stream = new MemoryStream()) { serializer.Serialize(stream, message); stream.Position = 0; xml = XElement.Load(stream); } var areEqual = XNode.DeepEquals(XElement.Parse("<wse:Subscribe xmlns:wse='http://schemas.xmlsoap.org/ws/2004/08/eventing'><wse:EndTo><Address xmlns='http://schemas.xmlsoap.org/ws/2004/08/addressing'>http://tempuri.org/endTo</Address></wse:EndTo><wse:Filter>/foo</wse:Filter></wse:Subscribe>"), xml.FirstNode); Assert.IsTrue(areEqual); }
void IXmlSerializable.ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } if (reader.IsStartElement("Delivery", Constants.WsEventing.Namespace) == false) { throw new XmlException("Invalid Element, it must be 'Delivery'"); } String modeAsString = reader.GetAttribute("Mode", Constants.WsEventing.Namespace); this.DeliveryMode = String.IsNullOrEmpty(modeAsString) ? DeliveryMode = new Uri(Constants.WsEventing.DeliverModes.Push) : new Uri(modeAsString); reader.ReadToDescendant("NotifyTo", Constants.WsEventing.Namespace); this.NotifyTo = EndpointAddressAugust2004.FromEndpointAddress(EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader)); if (this.NotifyTo == null) { throw new XmlException("Missing element 'NotifyTo'"); } while (reader.NodeType != XmlNodeType.EndElement) { var additionalElement = XElement.Parse(reader.ReadOuterXml()); this.additionalElements.Add(additionalElement); } reader.ReadEndElement(); }
/// <summary> /// Replaces the <see cref="Identifier"/> value, if any, with the supplied <paramref name="id"/>, if any. /// </summary> /// <param name="id">The new identifier value to use, or clear if null.</param> public void CreateIdentifierHeader(Guid?id) { var builder = new EndpointAddressBuilder(this.EndpointAddress.ToEndpointAddress()); var header = builder.Headers.FirstOrDefault(a => a.Name == "Identifier" && a.Namespace == Constants.WsEventing.Namespace); if (id == null) { if (header == null) { return; } var wasRemoved = builder.Headers.Remove(header); Debug.Assert(wasRemoved); } else { if (header != null) { var wasRemoved = builder.Headers.Remove(header); Debug.Assert(wasRemoved); } var uuid = new UniqueId(id.Value); header = AddressHeader.CreateAddressHeader("Identifier", Constants.WsEventing.Namespace, uuid.ToString()); builder.Headers.Add(header); } this.epa = EndpointAddressAugust2004.FromEndpointAddress(builder.ToEndpointAddress()); }
private static EndpointAddress ProcessAppliesToElement(XmlReader xr) { if (xr == null) { throw new ArgumentNullException("xr"); } if (xr.IsEmptyElement) { throw new ArgumentException("wsp:AppliesTo element was empty. Unable to create EndpointAddress object"); } int depth = xr.Depth; EndpointAddress result = null; while (xr.Read()) { if ("EndpointReference" == xr.LocalName && "http://www.w3.org/2005/08/addressing" == xr.NamespaceURI && !xr.IsEmptyElement && XmlNodeType.Element == xr.NodeType) { DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(EndpointAddress10)); EndpointAddress10 endpointAddress = (EndpointAddress10)dataContractSerializer.ReadObject(xr, false); result = endpointAddress.ToEndpointAddress(); } else if ("EndpointReference" == xr.LocalName && "http://schemas.xmlsoap.org/ws/2004/08/addressing" == xr.NamespaceURI && !xr.IsEmptyElement && XmlNodeType.Element == xr.NodeType) { DataContractSerializer dataContractSerializer2 = new DataContractSerializer(typeof(EndpointAddressAugust2004)); EndpointAddressAugust2004 endpointAddressAugust = (EndpointAddressAugust2004)dataContractSerializer2.ReadObject(xr, false); result = endpointAddressAugust.ToEndpointAddress(); } if ("AppliesTo" == xr.LocalName && "http://schemas.xmlsoap.org/ws/2004/09/policy" == xr.NamespaceURI && xr.Depth == depth && XmlNodeType.EndElement == xr.NodeType) { break; } } return(result); }
/// <summary> /// Converts and EndpointReferenceType to an EndpointAddressAugust2004 /// </summary> /// <returns>Returns an EndpointAddressAugust2004 object</returns> public EndpointAddressAugust2004 ToEndpointReference() { var builder = new StringBuilder(); using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(builder, new XmlWriterSettings() { Indent = false, OmitXmlDeclaration = true }))) { XmlSerializer serializer = new XmlSerializer(typeof(EndpointReferenceType)); serializer.Serialize(writer, this); } using (var reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(builder.ToString()), new XmlReaderSettings() { IgnoreWhitespace = true }))) { builder.Clear(); var address = EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader); return(EndpointAddressAugust2004.FromEndpointAddress(address)); } }
public VolatileEnlistmentInDoubtRecordSchema10(Guid enlistmentId, EndpointAddress replyTo) : base(enlistmentId) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/VolatileEnlistmentInDoubtTraceRecord"; if (replyTo != null) { this.replyTo = EndpointAddressAugust2004.FromEndpointAddress(replyTo); } }
public RegistrationCoordinatorResponseInvalidMetadataSchema10(CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService) : base(context, protocol) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RegistrationCoordinatorResponseInvalidMetadataTraceRecord"; if (coordinatorService != null) { this.coordinatorService = EndpointAddressAugust2004.FromEndpointAddress(coordinatorService); } }
public RecoverCoordinatorRecordSchema10(string transactionId, EndpointAddress coordinatorService) : base(transactionId) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RecoverCoordinatorTraceRecord"; if (coordinatorService != null) { this.coordinatorService = EndpointAddressAugust2004.FromEndpointAddress(coordinatorService); } }
/// <summary> /// Initializes a new instance of the <see cref="SubscriptionManager"/> class from the supplied <paramref name="address"/> and <paramref name="id"/>. /// </summary> /// <remarks> /// This overload is used in similar fashion to <see cref="SubscriptionManager(Uri, WsEventing.Identifier)">this constructor</see> with the /// variation of supplying a full set of WSA reference parameters in the created EPA. This can be used to perform the direct creation or /// manipulation of the EPA (including the presence of an <see cref="WsEventing.Identifier"/> element). /// </remarks> /// <param name="address">The endpoint address of the subscription manager used by the event sink to manage subscriptions for this event source.</param> /// <param name="headers">A collection of <see cref="AddressHeader">headers</see> that re contained as part of the WSA reference parameters in the created EPA.</param> public SubscriptionManager(Uri address, IEnumerable <AddressHeader> headers) { Contract.Requires(address != null, "address"); Contract.Requires(headers != null, "headers"); Contract.Requires(Contract.ForAll(headers, item => item != null)); this.epa = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress(address, headers.ToArray())); }
public RegisterFailureRecordSchema10(string transactionId, ControlProtocol protocol, EndpointAddress protocolService, string reason) : base(transactionId, protocol, reason) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RegisterFailureTraceRecord"; if (protocolService != null) { this.protocolService = EndpointAddressAugust2004.FromEndpointAddress(protocolService); } }
public RegisterParticipantRecordSchema10(string transactionId, Guid enlistmentId, ControlProtocol protocol, EndpointAddress participantService) : base(transactionId, enlistmentId, protocol) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RegisterParticipantTraceRecord"; if (participantService != null) { this.participantService = EndpointAddressAugust2004.FromEndpointAddress(participantService); } }
/// <summary> /// Initializes a new instance of the <see cref="Delivery"/> class with the suppleid <paramref name="mode"/> and <paramref name="notifyTo"/> <see cref="Uri"/> parameter values. /// </summary> /// <param name="mode">A <see cref="Uri"/> containing the <see cref="DeliveryMode"/> value.</param> /// <param name="notifyTo">An <see cref="EndpointAddress"/> containing the location to notify an event message to.</param> public Delivery(Uri mode, EndpointAddress notifyTo) { Contract.Requires <ArgumentNullException>(mode != null, "mode"); Contract.Requires <ArgumentNullException>(notifyTo != null, "notifyTo"); this.mode = mode; this.notifyTo = EndpointAddressAugust2004.FromEndpointAddress(notifyTo); this.additionalElements = new Collection <XElement>(); }
void IXmlSerializable.ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } this.epa = EndpointAddressAugust2004.FromEndpointAddress(System.ServiceModel.EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader, "SubscriptionManager", Constants.WsEventing.Namespace)); }
public static XmlQualifiedName EnsureProbeMatchSchema(DiscoveryVersion discoveryVersion, XmlSchemaSet schemaSet) { Fx.Assert(schemaSet != null, "The schemaSet must be non null."); Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null."); // ensure that EPR is added to the schema. if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1) { EndpointAddressAugust2004.GetSchema(schemaSet); } else if (discoveryVersion == DiscoveryVersion.WSDiscovery11) { EndpointAddress10.GetSchema(schemaSet); } else { Fx.Assert("The discoveryVersion is not supported."); } // do not add/find Probe related schema items SchemaTypes typesFound = SchemaTypes.ProbeType | SchemaTypes.ResolveType; SchemaElements elementsFound = SchemaElements.None; XmlSchema discoverySchema = null; ICollection discoverySchemas = schemaSet.Schemas(discoveryVersion.Namespace); if ((discoverySchemas == null) || (discoverySchemas.Count == 0)) { discoverySchema = CreateSchema(discoveryVersion); AddImport(discoverySchema, discoveryVersion.Implementation.WsaNamespace); schemaSet.Add(discoverySchema); } else { foreach (XmlSchema schema in discoverySchemas) { discoverySchema = schema; if (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ProbeMatchType)) { typesFound |= SchemaTypes.ProbeMatchType; break; } LocateSchemaTypes(discoveryVersion, schema, ref typesFound); LocateSchemaElements(discoveryVersion, schema, ref elementsFound); } } if ((typesFound & SchemaTypes.ProbeMatchType) != SchemaTypes.ProbeMatchType) { AddSchemaTypes(discoveryVersion, typesFound, discoverySchema); AddElements(discoveryVersion, elementsFound, discoverySchema); schemaSet.Reprocess(discoverySchema); } return(discoveryVersion.Implementation.QualifiedNames.ProbeMatchType); }
/// <summary> /// Initializes a new instance of the <see cref="SubscribeRequestMessageBody"/> class with the supplied <paramref name="delivery"/> and optional <see cref="EndpointAddress"/> to send a notice if a subscription is terminated. /// </summary> /// <param name="delivery">The <see cref="Delivery"/> value.</param> /// <param name="endTo">An optional <see cref="EndpointAddress"/> containing the EPR that should be used when to send a notice if a subscription is terminated.</param> public SubscribeRequestMessageBody(Delivery delivery, EndpointAddress endTo = null) { Contract.Requires <ArgumentNullException>(delivery != null, "delivery"); this.delivery = delivery; if (endTo == null) { return; } this.endTo = EndpointAddressAugust2004.FromEndpointAddress(endTo); }
public void ReadFromAugust2004Error2() { //Missing <Address> element string xml = @"<a:ReplyTo xmlns:a='http://schemas.xmlsoap.org/ws/2004/08/addressing'>http://www.w3.org/2005/08/addressing/anonymous</a:ReplyTo>"; XmlReader src = XmlReader.Create(new StringReader(xml)); XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(src); EndpointAddressAugust2004 e2k4 = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://test")); ((IXmlSerializable)e2k4).ReadXml(reader); }
public void ReadFromAugust2004Error() { //Reading address from EndpointAddress10 namespace with EndpointAddressAugust2004 string xml = @"<a:ReplyTo xmlns:a='http://www.w3.org/2005/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>"; XmlReader src = XmlReader.Create(new StringReader(xml)); XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(src); EndpointAddressAugust2004 e2k4 = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://test")); ((IXmlSerializable)e2k4).ReadXml(reader); }
/// <summary> /// Adds an <see cref="XmlSchema"/> instance for this type to the supplied <see cref="XmlSchemaSet"/>. /// </summary> /// <param name="xs">The <see cref="XmlSchemaSet"/> to add an <see cref="XmlSchema"/> to.</param> /// <returns>An <see cref="XmlQualifiedName"/> for the current object.</returns> public static XmlQualifiedName AcquireSchema(XmlSchemaSet xs) { if (xs == null) { throw new ArgumentNullException("xs"); } using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("CommonContracts.WsEventing.DeliveryType.xsd")) { Debug.Assert(stream != null, "Resource Stream 'CommonContracts.WsEventing.DeliveryType.xsd' was not able to be opened"); var schema = XmlSchema.Read(stream, null); xs.Add(schema); } EndpointAddressAugust2004.GetSchema(xs); return(new XmlQualifiedName("DeliveryType", Constants.WsEventing.Namespace)); }
void IXmlSerializable.ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } if (reader.IsStartElement("Subscribe", Constants.WsEventing.Namespace) == false) { throw new XmlException("Invalid Element, it must be 'Subscribe'"); } reader.ReadStartElement("Subscribe", Constants.WsEventing.Namespace); while (reader.NodeType != XmlNodeType.EndElement) { if (reader.IsStartElement("EndTo", Constants.WsEventing.Namespace)) { this.EndTo = EndpointAddressAugust2004.FromEndpointAddress(EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, reader)); } else if (reader.IsStartElement("Delivery", Constants.WsEventing.Namespace)) { this.Delivery = new Delivery(reader); } else if (reader.IsStartElement("Expires", Constants.WsEventing.Namespace)) { this.Expires = new Expires(reader); } else if (reader.IsStartElement("Filter", Constants.WsEventing.Namespace)) { String dialect = reader.GetAttribute("Dialect"); if (String.IsNullOrEmpty(dialect) || dialect == Constants.WsEventing.Dialects.XPath) { this.Filter = new XPathMessageFilter(reader); this.filterDialect = Constants.WsEventing.Dialects.XPath; } else { reader.Skip(); this.filterDialect = dialect; } } reader.MoveToContent(); } reader.ReadEndElement(); }
public void ReadFromAugust2004() { string xml = @"<a:ReplyTo xmlns:a='http://schemas.xmlsoap.org/ws/2004/08/addressing'><a:Address>http://www.w3.org/2005/08/addressing/anonymous</a:Address></a:ReplyTo>"; XmlReader src = XmlReader.Create(new StringReader(xml)); XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(src); EndpointAddressAugust2004 e2k4 = EndpointAddressAugust2004.FromEndpointAddress(new EndpointAddress("http://test")); ((IXmlSerializable)e2k4).ReadXml(reader); Console.WriteLine(e2k4.ToEndpointAddress().Uri.AbsoluteUri); EndpointAddress a = e2k4.ToEndpointAddress(); Assert.AreEqual("http://www.w3.org/2005/08/addressing/anonymous", a.Uri.AbsoluteUri, "#1"); Assert.IsFalse(a.IsAnonymous, "#2"); }
public static void WriteEndPointAddress(DiscoveryVersion discoveryVersion, EndpointAddress endpointAddress, XmlWriter writer) { Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null"); Fx.Assert(writer != null, "The writer must be non null"); if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1) { EndpointAddressAugust2004 endpoint = EndpointAddressAugust2004.FromEndpointAddress(endpointAddress); discoveryVersion.Implementation.EprSerializer.WriteObject(writer, endpoint); } else if (discoveryVersion == DiscoveryVersion.WSDiscovery11) { EndpointAddress10 endpoint = EndpointAddress10.FromEndpointAddress(endpointAddress); discoveryVersion.Implementation.EprSerializer.WriteObject(writer, endpoint); } else { Fx.Assert("The discoveryVersion parameter cannot be null."); } }
void AddEndpointAddressHeader(string name, string ns, EndpointAddress address) { if (address == null) { return; } if (MessageVersion.Addressing.Equals(AddressingVersion.WSAddressing10)) { Add(MessageHeader.CreateHeader(name, ns, EndpointAddress10.FromEndpointAddress(address))); } #if !MOBILE else if (MessageVersion.Addressing.Equals(AddressingVersion.WSAddressingAugust2004)) { Add(MessageHeader.CreateHeader(name, ns, EndpointAddressAugust2004.FromEndpointAddress(address))); } #endif else { throw new InvalidOperationException("WS-Addressing header is not allowed for AddressingVersion.None"); } }
public static void Main() { // <Snippet1> // Create an EndpointAddress with a specified address. EndpointAddress epa1 = new EndpointAddress("http://localhost/ServiceModelSamples"); Console.WriteLine("The URI of the EndpointAddress is {0}:", epa1.Uri); Console.WriteLine(); //Initialize an EndpointAddressAugust2004 from the endpointAddress. EndpointAddressAugust2004 epaA4 = EndpointAddressAugust2004.FromEndpointAddress(epa1); //Serialize and then deserializde the EndpointAugust2004 type. //Convert the EndpointAugust2004 back into an EndpointAddress. EndpointAddress epa2 = epaA4.ToEndpointAddress(); Console.WriteLine("The URI of the EndpointAddress is still {0}:", epa2.Uri); Console.WriteLine(); // </Snippet1> }
void AddEndpointAddressHeader(string name, string ns, EndpointAddress address) { RemoveAll("FaultTo", Constants.WsaNamespace); if (address == null) { return; } if (MessageVersion.Addressing.Equals(AddressingVersion.WSAddressing10)) { Add(MessageHeader.CreateHeader(name, ns, EndpointAddress10.FromEndpointAddress(address))); } #if !NET_2_1 else if (MessageVersion.Addressing.Equals(AddressingVersion.WSAddressingAugust2004)) { Add(MessageHeader.CreateHeader(name, ns, EndpointAddressAugust2004.FromEndpointAddress(address))); } #endif else { throw new InvalidOperationException("WS-Addressing header is not allowed for AddressingVersion.None"); } }
/// <summary> /// Converts and EndpointAddressAugust2004 to an EndpointReferenceType. /// </summary> /// <returns>Returns an EndpointReferenceType object</returns> public static EndpointReferenceType FromEndpointReference(EndpointAddressAugust2004 epr) { var builder = new StringBuilder(); using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(builder, new XmlWriterSettings() { Indent = false, OmitXmlDeclaration = true }))) { epr.ToEndpointAddress().WriteTo(AddressingVersion.WSAddressingAugust2004, writer); } using (var reader = XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(new StringReader(builder.ToString()), new XmlReaderSettings() { IgnoreWhitespace = true }))) { builder.Clear(); var serializer = new XmlSerializer(typeof(EndpointReferenceType)); return((EndpointReferenceType)serializer.Deserialize(reader)); } }
/// <summary> /// Reads a wsp:AppliesTo element /// </summary> /// <param name="xr">An XmlReader positioned on the start tag of wsp:AppliesTo</param> /// <returns>An EndpointAddress</returns> private static EndpointAddress ProcessAppliesToElement(XmlReader xr) { // If provided XmlReader is null, throw an exception if (xr == null) { throw new ArgumentNullException("xr"); } // If the wsp:AppliesTo element is empty, then throw an exception. if (xr.IsEmptyElement) { throw new ArgumentException("wsp:AppliesTo element was empty. Unable to create EndpointAddress object"); } // Store the initial depth so we can exit this function when we reach the corresponding end-tag int initialDepth = xr.Depth; // Set our return value to null EndpointAddress ea = null; // Enter a read loop... while (xr.Read()) { // Look for a WS-Addressing 1.0 Endpoint Reference... if (Constants.Addressing.Elements.EndpointReference == xr.LocalName && Constants.Addressing.NamespaceUri == xr.NamespaceURI && !xr.IsEmptyElement && XmlNodeType.Element == xr.NodeType) { // Create a DataContractSerializer for an EndpointAddress10 DataContractSerializer dcs = new DataContractSerializer(typeof(EndpointAddress10)); // Read the EndpointAddress10 from the DataContractSerializer EndpointAddress10 ea10 = (EndpointAddress10)dcs.ReadObject(xr, false); // Convert the EndpointAddress10 into an EndpointAddress ea = ea10.ToEndpointAddress(); } // Look for a WS-Addressing 2004/08 Endpoint Reference... else if (Constants.Addressing.Elements.EndpointReference == xr.LocalName && Constants.Addressing.NamespaceUriAugust2004 == xr.NamespaceURI && !xr.IsEmptyElement && XmlNodeType.Element == xr.NodeType) { // Create a DataContractSerializer for an EndpointAddressAugust2004 DataContractSerializer dcs = new DataContractSerializer(typeof(EndpointAddressAugust2004)); // Read the EndpointAddressAugust2004 from the DataContractSerializer EndpointAddressAugust2004 eaAugust2004 = (EndpointAddressAugust2004)dcs.ReadObject(xr, false); // Convert the EndpointAddressAugust2004 into an EndpointAddress ea = eaAugust2004.ToEndpointAddress(); } // Look for the end-tag that corresponds to the start-tag the reader was positioned // on when the method was called. When we find it, break out of the read loop. if (Constants.Policy.Elements.AppliesTo == xr.LocalName && Constants.Policy.NamespaceUri == xr.NamespaceURI && xr.Depth == initialDepth && XmlNodeType.EndElement == xr.NodeType) { break; } } // Return the EndpointAddress return(ea); }
private async ValueTask <BodyWriter> ProcessNegotiationAsync(SspiNegotiationTokenAuthenticatorState negotiationState, Message incomingMessage, BinaryNegotiation incomingNego) { ISspiNegotiation sspiNegotiation = negotiationState.SspiNegotiation; byte[] outgoingBlob = sspiNegotiation.GetOutgoingBlob(incomingNego.GetNegotiationData(), SecurityUtils.GetChannelBindingFromMessage(incomingMessage), ExtendedProtectionPolicy); if (sspiNegotiation.IsValidContext == false) { throw TraceUtility.ThrowHelperError(new SecurityNegotiationException(SR.Format(SR.InvalidSspiNegotiation)), incomingMessage); } // if there is no blob to send back the nego must be complete from the server side if (outgoingBlob == null && sspiNegotiation.IsCompleted == false) { throw TraceUtility.ThrowHelperError(new SecurityNegotiationException(SR.Format(SR.NoBinaryNegoToSend)), incomingMessage); } BinaryNegotiation outgoingBinaryNegotiation; if (outgoingBlob != null) { outgoingBinaryNegotiation = GetOutgoingBinaryNegotiation(sspiNegotiation, outgoingBlob); } else { outgoingBinaryNegotiation = null; } BodyWriter replyBody; if (sspiNegotiation.IsCompleted) { ReadOnlyCollection <IAuthorizationPolicy> authorizationPolicies = await ValidateSspiNegotiationAsync(sspiNegotiation); SecurityContextSecurityToken serviceToken; WrappedKeySecurityToken proofToken; int issuedKeySize; IssueServiceToken(negotiationState, authorizationPolicies, out serviceToken, out proofToken, out issuedKeySize); negotiationState.SetServiceToken(serviceToken); SecurityKeyIdentifierClause externalTokenReference = IssuedSecurityTokenParameters.CreateKeyIdentifierClause(serviceToken, SecurityTokenReferenceStyle.External); SecurityKeyIdentifierClause internalTokenReference = IssuedSecurityTokenParameters.CreateKeyIdentifierClause(serviceToken, SecurityTokenReferenceStyle.Internal); RequestSecurityTokenResponse dummyRstr = new RequestSecurityTokenResponse(StandardsManager) { Context = negotiationState.Context, KeySize = issuedKeySize, TokenType = SecurityContextTokenUri }; if (outgoingBinaryNegotiation != null) { dummyRstr.SetBinaryNegotiation(outgoingBinaryNegotiation); } dummyRstr.RequestedUnattachedReference = externalTokenReference; dummyRstr.RequestedAttachedReference = internalTokenReference; dummyRstr.SetLifetime(serviceToken.ValidFrom, serviceToken.ValidTo); if (negotiationState.AppliesTo != null) { if (incomingMessage.Version.Addressing == AddressingVersion.WSAddressing10) { dummyRstr.SetAppliesTo <EndpointAddress10>(EndpointAddress10.FromEndpointAddress( negotiationState.AppliesTo), negotiationState.AppliesToSerializer); } else if (incomingMessage.Version.Addressing == AddressingVersion.WSAddressingAugust2004) { dummyRstr.SetAppliesTo <EndpointAddressAugust2004>(EndpointAddressAugust2004.FromEndpointAddress( negotiationState.AppliesTo), negotiationState.AppliesToSerializer); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.Format(SR.AddressingVersionNotSupported, incomingMessage.Version.Addressing))); } } dummyRstr.MakeReadOnly(); AddToDigest(negotiationState, dummyRstr, false); RequestSecurityTokenResponse negotiationRstr = new RequestSecurityTokenResponse(StandardsManager) { RequestedSecurityToken = serviceToken, RequestedProofToken = proofToken, Context = negotiationState.Context, KeySize = issuedKeySize, TokenType = SecurityContextTokenUri }; if (outgoingBinaryNegotiation != null) { negotiationRstr.SetBinaryNegotiation(outgoingBinaryNegotiation); } negotiationRstr.RequestedAttachedReference = internalTokenReference; negotiationRstr.RequestedUnattachedReference = externalTokenReference; if (negotiationState.AppliesTo != null) { if (incomingMessage.Version.Addressing == AddressingVersion.WSAddressing10) { negotiationRstr.SetAppliesTo <EndpointAddress10>( EndpointAddress10.FromEndpointAddress(negotiationState.AppliesTo), negotiationState.AppliesToSerializer); } else if (incomingMessage.Version.Addressing == AddressingVersion.WSAddressingAugust2004) { negotiationRstr.SetAppliesTo <EndpointAddressAugust2004>( EndpointAddressAugust2004.FromEndpointAddress(negotiationState.AppliesTo), negotiationState.AppliesToSerializer); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.Format(SR.AddressingVersionNotSupported, incomingMessage.Version.Addressing))); } } negotiationRstr.MakeReadOnly(); byte[] authenticator = ComputeAuthenticator(negotiationState, serviceToken.GetKeyBytes()); RequestSecurityTokenResponse authenticatorRstr = new RequestSecurityTokenResponse(StandardsManager) { Context = negotiationState.Context }; authenticatorRstr.SetAuthenticator(authenticator); authenticatorRstr.MakeReadOnly(); List <RequestSecurityTokenResponse> rstrList = new List <RequestSecurityTokenResponse>(2) { negotiationRstr, authenticatorRstr }; replyBody = new RequestSecurityTokenResponseCollection(rstrList, StandardsManager); } else { RequestSecurityTokenResponse rstr = new RequestSecurityTokenResponse(StandardsManager) { Context = negotiationState.Context }; rstr.SetBinaryNegotiation(outgoingBinaryNegotiation); rstr.MakeReadOnly(); AddToDigest(negotiationState, rstr, false); replyBody = rstr; } return(replyBody); }
protected override BodyWriter GetFirstOutgoingMessageBody(FederatedTokenProviderState negotiationState, out MessageProperties messageProperties) { messageProperties = null; RequestSecurityToken rst = new RequestSecurityToken(this.StandardsManager); if (this.addTargetServiceAppliesTo) { if (this.MessageVersion.Addressing == AddressingVersion.WSAddressing10) { rst.SetAppliesTo <EndpointAddress10>( EndpointAddress10.FromEndpointAddress(negotiationState.TargetAddress), DataContractSerializerDefaults.CreateSerializer(typeof(EndpointAddress10), DataContractSerializerDefaults.MaxItemsInObjectGraph)); } else if (this.MessageVersion.Addressing == AddressingVersion.WSAddressingAugust2004) { rst.SetAppliesTo <EndpointAddressAugust2004>( EndpointAddressAugust2004.FromEndpointAddress(negotiationState.TargetAddress), DataContractSerializerDefaults.CreateSerializer(typeof(EndpointAddressAugust2004), DataContractSerializerDefaults.MaxItemsInObjectGraph)); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, this.MessageVersion.Addressing))); } } rst.Context = negotiationState.Context; if (!this.isKeySizePresentInRstProperties) { rst.KeySize = this.keySize; } Collection <XmlElement> newRequestProperties = new Collection <XmlElement>(); if (this.requestProperties != null) { for (int i = 0; i < this.requestProperties.Count; ++i) { newRequestProperties.Add(this.requestProperties[i]); } } if (!isKeyTypePresentInRstProperties) { XmlElement keyTypeElement = this.StandardsManager.TrustDriver.CreateKeyTypeElement(this.keyType); newRequestProperties.Insert(0, keyTypeElement); } if (this.keyType == SecurityKeyType.SymmetricKey) { byte[] requestorEntropy = negotiationState.GetRequestorEntropy(); rst.SetRequestorEntropy(requestorEntropy); } else if (this.keyType == SecurityKeyType.AsymmetricKey) { RsaKeyIdentifierClause rsaClause = new RsaKeyIdentifierClause(negotiationState.Rsa); SecurityKeyIdentifier keyIdentifier = new SecurityKeyIdentifier(rsaClause); newRequestProperties.Add(this.StandardsManager.TrustDriver.CreateUseKeyElement(keyIdentifier, this.StandardsManager)); RsaSecurityTokenParameters rsaParameters = new RsaSecurityTokenParameters(); rsaParameters.InclusionMode = SecurityTokenInclusionMode.Never; rsaParameters.RequireDerivedKeys = false; SupportingTokenSpecification rsaSpec = new SupportingTokenSpecification(negotiationState.RsaSecurityToken, EmptyReadOnlyCollection <IAuthorizationPolicy> .Instance, SecurityTokenAttachmentMode.Endorsing, rsaParameters); messageProperties = new MessageProperties(); SecurityMessageProperty security = new SecurityMessageProperty(); security.OutgoingSupportingTokens.Add(rsaSpec); messageProperties.Security = security; } if (this.keyType == SecurityKeyType.SymmetricKey && this.KeyEntropyMode == SecurityKeyEntropyMode.CombinedEntropy) { newRequestProperties.Add(this.StandardsManager.TrustDriver.CreateComputedKeyAlgorithmElement(this.StandardsManager.TrustDriver.ComputedKeyAlgorithm)); } rst.RequestProperties = newRequestProperties; rst.MakeReadOnly(); return(rst); }
protected override BodyWriter ProcessRequestSecurityToken(Message request, RequestSecurityToken requestSecurityToken, out NegotiationTokenAuthenticatorState negotiationState) { if (request == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("request"); } if (requestSecurityToken == null) { throw TraceUtility.ThrowHelperArgumentNull("requestSecurityToken", request); } try { if (requestSecurityToken.RequestType != null && requestSecurityToken.RequestType != this.StandardsManager.TrustDriver.RequestTypeIssue) { throw TraceUtility.ThrowHelperWarning(new SecurityNegotiationException(SR.GetString(SR.InvalidRstRequestType, requestSecurityToken.RequestType)), request); } if (requestSecurityToken.TokenType != null && requestSecurityToken.TokenType != this.SecurityContextTokenUri) { throw TraceUtility.ThrowHelperWarning(new SecurityNegotiationException(SR.GetString(SR.CannotIssueRstTokenType, requestSecurityToken.TokenType)), request); } EndpointAddress appliesTo; DataContractSerializer appliesToSerializer; string appliesToName; string appliesToNamespace; requestSecurityToken.GetAppliesToQName(out appliesToName, out appliesToNamespace); if (appliesToName == AddressingStrings.EndpointReference && appliesToNamespace == request.Version.Addressing.Namespace) { if (request.Version.Addressing == AddressingVersion.WSAddressing10) { appliesToSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(EndpointAddress10), DataContractSerializerDefaults.MaxItemsInObjectGraph); appliesTo = requestSecurityToken.GetAppliesTo <EndpointAddress10>(appliesToSerializer).ToEndpointAddress(); } else if (request.Version.Addressing == AddressingVersion.WSAddressingAugust2004) { appliesToSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(EndpointAddressAugust2004), DataContractSerializerDefaults.MaxItemsInObjectGraph); appliesTo = requestSecurityToken.GetAppliesTo <EndpointAddressAugust2004>(appliesToSerializer).ToEndpointAddress(); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, request.Version.Addressing))); } } else { appliesTo = null; appliesToSerializer = null; } if (this.shouldMatchRstWithEndpointFilter) { SecurityUtils.MatchRstWithEndpointFilter(request, this.EndpointFilterTable, this.ListenUri); } int issuedKeySize; byte[] issuerEntropy; byte[] proofKey; SecurityToken proofToken; WSTrust.Driver.ProcessRstAndIssueKey(requestSecurityToken, null, this.KeyEntropyMode, this.SecurityAlgorithmSuite, out issuedKeySize, out issuerEntropy, out proofKey, out proofToken); UniqueId contextId = SecurityUtils.GenerateUniqueId(); string id = SecurityUtils.GenerateId(); DateTime effectiveTime = DateTime.UtcNow; DateTime expirationTime = TimeoutHelper.Add(effectiveTime, this.ServiceTokenLifetime); // ensure that a SecurityContext is present in the message SecurityMessageProperty securityProperty = request.Properties.Security; ReadOnlyCollection <IAuthorizationPolicy> authorizationPolicies; if (securityProperty != null) { authorizationPolicies = SecuritySessionSecurityTokenAuthenticator.CreateSecureConversationPolicies(securityProperty, expirationTime); } else { authorizationPolicies = EmptyReadOnlyCollection <IAuthorizationPolicy> .Instance; } SecurityContextSecurityToken serviceToken = this.IssueSecurityContextToken(contextId, id, proofKey, effectiveTime, expirationTime, authorizationPolicies, this.EncryptStateInServiceToken); if (this.preserveBootstrapTokens) { serviceToken.BootstrapMessageProperty = (securityProperty == null) ? null : (SecurityMessageProperty)securityProperty.CreateCopy(); SecurityUtils.ErasePasswordInUsernameTokenIfPresent(serviceToken.BootstrapMessageProperty); } RequestSecurityTokenResponse rstr = new RequestSecurityTokenResponse(this.StandardsManager); rstr.Context = requestSecurityToken.Context; rstr.KeySize = issuedKeySize; rstr.RequestedUnattachedReference = this.IssuedSecurityTokenParameters.CreateKeyIdentifierClause(serviceToken, SecurityTokenReferenceStyle.External); rstr.RequestedAttachedReference = this.IssuedSecurityTokenParameters.CreateKeyIdentifierClause(serviceToken, SecurityTokenReferenceStyle.Internal); rstr.TokenType = this.SecurityContextTokenUri; rstr.RequestedSecurityToken = serviceToken; if (issuerEntropy != null) { rstr.SetIssuerEntropy(issuerEntropy); rstr.ComputeKey = true; } if (proofToken != null) { rstr.RequestedProofToken = proofToken; } if (appliesTo != null) { if (request.Version.Addressing == AddressingVersion.WSAddressing10) { rstr.SetAppliesTo <EndpointAddress10>(EndpointAddress10.FromEndpointAddress(appliesTo), appliesToSerializer); } else if (request.Version.Addressing == AddressingVersion.WSAddressingAugust2004) { rstr.SetAppliesTo <EndpointAddressAugust2004>(EndpointAddressAugust2004.FromEndpointAddress(appliesTo), appliesToSerializer); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, request.Version.Addressing))); } } rstr.MakeReadOnly(); negotiationState = new NegotiationTokenAuthenticatorState(); negotiationState.SetServiceToken(serviceToken); if (this.StandardsManager.MessageSecurityVersion.SecureConversationVersion == SecureConversationVersion.WSSecureConversationFeb2005) { return(rstr); } else if (this.StandardsManager.MessageSecurityVersion.SecureConversationVersion == SecureConversationVersion.WSSecureConversation13) { List <RequestSecurityTokenResponse> rstrList = new List <RequestSecurityTokenResponse>(1); rstrList.Add(rstr); RequestSecurityTokenResponseCollection rstrCollection = new RequestSecurityTokenResponseCollection(rstrList, this.StandardsManager); return(rstrCollection); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException()); } } finally { SecuritySessionSecurityTokenAuthenticator.RemoveCachedTokensIfRequired(request.Properties.Security); } }