/// <summary>
/// Retrieves and imports meta data for a given WSDL document specified by
/// WsdlDocument property.
/// </summary>
/// <param name="options">The metadata resolving options.</param>
/// <returns>A collection of service metadata in XML form.</returns>
public static MetadataSet GetMetadataSet(MetadataResolverOptions options)
{
if (options == null)
{
throw new ArgumentException("options could not be null.");
}
if (string.IsNullOrEmpty(options.MetadataLocation))
{
throw new ArgumentException("MetadataLocation option could not be null or an empty string.");
}
try
{
// First download the contracts if they are accessed over the web.
DownloadContract(options);
// Try to run RPC2DocumentLiteral converter.
TryTranslateRpc2DocumentLiteral(options);
MetadataSet metadataSet = new MetadataSet();
XmlDocument doc = new XmlDocument();
doc.Load(options.MetadataLocation);
MetadataSection ms = new MetadataSection(null, null, doc);
metadataSet.MetadataSections.Add(ms);
ResolveImports(options, metadataSet);
return metadataSet;
}
catch (Exception ex)
{
// TODO: Log exception.
throw new MetadataResolveException("Could not resolve metadata", ex);
}
}
private static void AddDocumentToResults(object document, ICollection<MetadataSection> results)
{
ServiceDescription serviceDescription = document as ServiceDescription;
XmlSchema xmlSchema = document as XmlSchema;
XmlElement xmlElement = document as XmlElement;
if (serviceDescription != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
}
else if (xmlSchema != null)
{
results.Add(MetadataSection.CreateFromSchema(xmlSchema));
}
else if (xmlElement != null && (xmlElement.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/09/policy" || xmlElement.NamespaceURI == "http://www.w3.org/ns/ws-policy") && xmlElement.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlElement, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
results.Add(mexDoc);
}
}
private void AddDocumentToSet(MetadataSet metadataSet, object document)
{
System.Web.Services.Description.ServiceDescription serviceDescription = document as System.Web.Services.Description.ServiceDescription;
System.Xml.Schema.XmlSchema schema = document as System.Xml.Schema.XmlSchema;
XmlElement policy = document as XmlElement;
if (serviceDescription != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
}
else if (schema != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
}
else if ((policy != null) && MetadataSection.IsPolicyElement(policy))
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(policy, null));
}
else
{
MetadataSection item = new MetadataSection {
Metadata = document
};
metadataSet.MetadataSections.Add(item);
}
}
public override MetadataSet GetGeneratedMetadata()
{
if (metadata != null)
{
return(metadata);
}
metadata = new MetadataSet();
foreach (WSServiceDescription sd in GeneratedWsdlDocuments)
{
metadata.MetadataSections.Add(
MetadataSection.CreateFromServiceDescription(sd));
}
foreach (XmlSchema xs in GeneratedXmlSchemas.Schemas())
{
if (xs.TargetNamespace != XmlSchema.Namespace)
{
metadata.MetadataSections.Add(
MetadataSection.CreateFromSchema(xs));
}
}
return(metadata);
}
public static MetadataSection CreateFromServiceDescription(WsdlNS.ServiceDescription serviceDescription)
{
if (serviceDescription == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription");
}
MetadataSection section = new MetadataSection();
section.Dialect = MetadataSection.ServiceDescriptionDialect;
section.Identifier = serviceDescription.TargetNamespace;
section.Metadata = serviceDescription;
return(section);
}
public static MetadataSection CreateFromSchema(XsdNS.XmlSchema schema)
{
if (schema == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("schema");
}
MetadataSection section = new MetadataSection();
section.Dialect = MetadataSection.XmlSchemaDialect;
section.Identifier = schema.TargetNamespace;
section.Metadata = schema;
return(section);
}
private XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var sb = new StringBuilder();
var w = new StringWriter(sb, CultureInfo.InvariantCulture);
var writer = XmlWriter.Create(w);
metadataSet.WriteTo(writer);
writer.Flush();
w.Flush();
var input = new StringReader(sb.ToString());
var reader = new XmlTextReader(input);
return XmlDictionaryReader.CreateDictionaryReader(reader);
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "Metadata" ||
reader.NamespaceURI != "http://schemas.xmlsoap.org/ws/2004/09/mex")
{
throw new InvalidOperationException(String.Format("Unexpected : <{0} ..", reader.LocalName));
}
/* Move to MetadataSections */
reader.Read();
MetadataSectionSerializer xs = new MetadataSectionSerializer();
while (reader.NodeType == XmlNodeType.Element && reader.LocalName == "MetadataSection" &&
reader.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/09/mex")
{
MetadataSection ms = (MetadataSection)xs.Deserialize(reader);
MetadataSections.Add(ms);
}
}
public static MetadataSection CreateFromPolicy(XmlElement policy, string identifier)
{
if (policy == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("policy");
}
if (!IsPolicyElement(policy))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("policy",
#pragma warning disable 56506 // chiomaos, policy cannot be null at this point since it has been validated above.
string.Format(SRServiceModel.SFxBadMetadataMustBePolicy, MetadataStrings.WSPolicy.NamespaceUri, MetadataStrings.WSPolicy.Elements.Policy, policy.NamespaceURI, policy.LocalName));
}
MetadataSection section = new MetadataSection();
section.Dialect = policy.NamespaceURI;
section.Identifier = identifier;
section.Metadata = policy;
return(section);
}
void HandleResult(IAsyncResult result)
{
IMetadataExchange metadataClient = (IMetadataExchange)result.AsyncState;
Message response = metadataClient.EndGet(result);
using (this.message)
{
if (response.IsFault)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxBadMetadataReference,
((IClientChannel)metadataClient).RemoteAddress.Uri.ToString())));
}
else
{
using (XmlReader reader = response.GetReaderAtBodyContents())
{
section = MetadataRetriever.CreateMetadataSection(reader, ((IClientChannel)metadataClient).RemoteAddress.Uri.ToString());
}
}
}
}
/// <summary>
/// Sign this information card and write it to a file.
/// </summary>
/// <param name="filename">Path to where this card should be stored.</param>
/// <param name="cert">Certificate to use for signing this card.</param>
public void SerializeAndSign( string filename, X509Certificate2 cert )
{
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create( stream );
writer.WriteStartElement( XmlNames.WSIdentity.InfoCardElement, XmlNames.WSIdentity.Namespace );
//
// write the InformationCardReference element
//
writer.WriteAttributeString( XmlNames.Xml.Language, XmlNames.Xml.Namespace, m_language );
writer.WriteStartElement( XmlNames.WSIdentity.InfoCardRefElement, XmlNames.WSIdentity.Namespace );
writer.WriteElementString( XmlNames.WSIdentity.CardIdElement, XmlNames.WSIdentity.Namespace, m_cardId );
writer.WriteElementString( XmlNames.WSIdentity.CardVersionElement, XmlNames.WSIdentity.Namespace, m_cardVersion );
writer.WriteEndElement();
//
// card name
//
if( !String.IsNullOrEmpty( m_cardName ) )
{
writer.WriteStartElement( XmlNames.WSIdentity.CardNameElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_cardName );
writer.WriteEndElement();
}
//
// card image
//
if( null != m_logo && 0 != m_logo.Length )
{
writer.WriteStartElement( XmlNames.WSIdentity.CardImageElement, XmlNames.WSIdentity.Namespace );
if( !String.IsNullOrEmpty( m_mimeType ) )
{
writer.WriteAttributeString( XmlNames.WSIdentity.MimeTypeAttribute, m_mimeType );
}
string val = Convert.ToBase64String( m_logo );
writer.WriteString( val );
writer.WriteEndElement();
}
//
// card issuer uri
//
writer.WriteStartElement( XmlNames.WSIdentity.IssuerElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_issuerId );
writer.WriteEndElement();
//
// issue time
//
writer.WriteStartElement( XmlNames.WSIdentity.TimeIssuedElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( XmlConvert.ToString( m_issuedOn, XmlDateTimeSerializationMode.Utc ) );
writer.WriteEndElement();
//
// expiry time
//
writer.WriteStartElement( XmlNames.WSIdentity.TimeExpiresElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( XmlConvert.ToString( m_expiresOn, XmlDateTimeSerializationMode.Utc ) );
writer.WriteEndElement();
//
// Start the tokenservice list
//
writer.WriteStartElement( XmlNames.WSIdentity.TokenServiceListElement, XmlNames.WSIdentity.Namespace );
EndpointAddressBuilder eprBuilder = new EndpointAddressBuilder();
eprBuilder.Uri = new Uri( m_issuerId );
eprBuilder.Identity = new X509CertificateEndpointIdentity( cert );
if( null != m_mexUri )
{
MetadataReference mexRef = new MetadataReference();
mexRef.Address = new EndpointAddress( m_mexUri );
mexRef.AddressVersion = AddressingVersion.WSAddressing10;
MetadataSection mexSection = new MetadataSection();
mexSection.Metadata = mexRef;
MetadataSet mexSet = new MetadataSet();
mexSet.MetadataSections.Add( mexSection );
MemoryStream memStream = new MemoryStream();
XmlTextWriter writer1 = new XmlTextWriter( memStream, System.Text.Encoding.UTF8 );
mexSet.WriteTo( writer1 );
writer1.Flush();
memStream.Seek( 0, SeekOrigin.Begin );
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader( memStream, XmlDictionaryReaderQuotas.Max );
eprBuilder.SetMetadataReader( reader );
}
m_epr = eprBuilder.ToEndpointAddress();
writer.WriteStartElement( XmlNames.WSIdentity.TokenServiceElement, XmlNames.WSIdentity.Namespace );
//
// Write the EndPointReference
//
m_epr.WriteTo( AddressingVersion.WSAddressing10, writer );
//
// Write the UserCredential Element
//
writer.WriteStartElement( XmlNames.WSIdentity.UserCredentialElement, XmlNames.WSIdentity.Namespace );
//
// Write the hint
//
if( !String.IsNullOrEmpty( m_hint ) )
{
writer.WriteStartElement( XmlNames.WSIdentity.DisplayCredentialHintElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_hint );
writer.WriteEndElement();
}
switch( m_cardType )
{
case DefaultValues.CardType.UserNamePassword:
writer.WriteStartElement( XmlNames.WSIdentity.UserNamePasswordCredentialElement, XmlNames.WSIdentity.Namespace );
if( !string.IsNullOrEmpty( m_credentialIdentifier ) )
{
writer.WriteStartElement( XmlNames.WSIdentity.UserNameElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_credentialIdentifier );
writer.WriteEndElement();
}
writer.WriteEndElement();
break;
case DefaultValues.CardType.KerberosAuth:
writer.WriteStartElement( XmlNames.WSIdentity.KerberosV5CredentialElement, XmlNames.WSIdentity.Namespace );
writer.WriteEndElement();
break;
case DefaultValues.CardType.SelfIssuedAuth:
writer.WriteStartElement( XmlNames.WSIdentity.SelfIssuedCredentialElement, XmlNames.WSIdentity.Namespace );
if( !string.IsNullOrEmpty( m_credentialIdentifier ) )
{
writer.WriteStartElement( XmlNames.WSIdentity.PrivatePersonalIdentifierElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_credentialIdentifier );
writer.WriteEndElement();
}
else
{
throw new InvalidDataException( "No PPID was specified" );
}
writer.WriteEndElement();
break;
case DefaultValues.CardType.SmartCard:
writer.WriteStartElement( XmlNames.WSIdentity.X509V3CredentialElement, XmlNames.WSIdentity.Namespace );
writer.WriteStartElement( XmlNames.XmlDSig.X509DataElement, XmlNames.XmlDSig.Namespace );
if( !string.IsNullOrEmpty( m_credentialIdentifier ) )
{
writer.WriteStartElement( XmlNames.WSSecurityExt.KeyIdentifierElement, XmlNames.WSSecurityExt.Namespace );
writer.WriteAttributeString( XmlNames.WSSecurityExt.ValueTypeAttribute,
null,
XmlNames.WSSecurityExt.Sha1ThumbrpintKeyTypeValue );
writer.WriteString( m_credentialIdentifier );
writer.WriteEndElement();
}
else
{
throw new InvalidDataException( "No thumbprint was specified" );
}
writer.WriteEndElement();
writer.WriteEndElement();
break;
default:
break;
}
writer.WriteEndElement(); //end of user credential
writer.WriteEndElement(); // end of tokenservice
writer.WriteEndElement(); //end of tokenservice list
//
// tokentypes
//
writer.WriteStartElement( XmlNames.WSIdentity.SupportedTokenTypeListElement, XmlNames.WSIdentity.Namespace );
foreach( string type in m_tokenTypes )
{
writer.WriteElementString( XmlNames.WSTrust.TokenType,
XmlNames.WSTrust.Namespace,
type );
}
writer.WriteEndElement();
//
// claims
//
writer.WriteStartElement( XmlNames.WSIdentity.SupportedClaimTypeListElement, XmlNames.WSIdentity.Namespace );
foreach( ClaimInfo clm in m_supportedClaims )
{
writer.WriteStartElement( XmlNames.WSIdentity.SupportedClaimTypeElement, XmlNames.WSIdentity.Namespace );
writer.WriteAttributeString( XmlNames.WSIdentity.UriAttribute, clm.Id );
if( !String.IsNullOrEmpty( clm.DisplayTag ) )
{
writer.WriteElementString( XmlNames.WSIdentity.DisplayTagElement,
XmlNames.WSIdentity.Namespace,
clm.DisplayTag );
}
if( !String.IsNullOrEmpty( clm.Description ) )
{
writer.WriteElementString( XmlNames.WSIdentity.DescriptionElement,
XmlNames.WSIdentity.Namespace,
clm.Description );
}
writer.WriteEndElement();
}
writer.WriteEndElement();
//
// RequireAppliesTo
//
if( m_requireAppliesTo )
{
writer.WriteElementString( XmlNames.WSIdentity.RequireAppliesToElement, XmlNames.WSIdentity.Namespace, null );
}
//
// Privacy Notice
//
if( !String.IsNullOrEmpty( m_privacyNoticeAt ) )
{
writer.WriteStartElement( XmlNames.WSIdentity.PrivacyNoticeAtElement, XmlNames.WSIdentity.Namespace );
writer.WriteString( m_privacyNoticeAt );
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.Close();
//
// Sign the xml content
//
stream.Position = 0;
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = false;
doc.Load( stream );
SignedXml signed = new SignedXml();
signed.SigningKey = cert.PrivateKey;
signed.Signature.SignedInfo.CanonicalizationMethod
= SignedXml.XmlDsigExcC14NTransformUrl;
Reference reference = new Reference();
reference.Uri = "#_Object_InfoCard";
reference.AddTransform(
new XmlDsigExcC14NTransform() );
signed.AddReference( reference );
KeyInfo info = new KeyInfo();
KeyInfoX509Data data = new KeyInfoX509Data( cert,
X509IncludeOption.WholeChain );
info.AddClause( data );
signed.KeyInfo = info;
DataObject cardData = new DataObject( "_Object_InfoCard", null, null, doc.DocumentElement );
signed.AddObject( cardData );
signed.ComputeSignature();
XmlElement e = signed.GetXml();
XmlTextWriter fileWriter = new XmlTextWriter( filename, Encoding.UTF8 );
e.WriteTo( fileWriter );
fileWriter.Flush();
fileWriter.Close();
}
void AddDocumentToSet(MetadataSet metadataSet, object document)
{
WsdlNS.ServiceDescription wsdl = document as WsdlNS.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement xmlDoc = document as XmlElement;
if (wsdl != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
else if (schema != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && MetadataSection.IsPolicyElement(xmlDoc))
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
metadataSet.MetadataSections.Add(mexDoc);
}
}
public static MetadataSection CreateFromSchema(XsdNS.XmlSchema schema)
{
if (schema == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("schema");
}
MetadataSection section = new MetadataSection();
section.Dialect = MetadataSection.XmlSchemaDialect;
section.Identifier = schema.TargetNamespace;
section.Metadata = schema;
return section;
}
void AddDocumentToResults(object document, Collection<MetadataSection> results)
{
WsdlNS.ServiceDescription wsdl = document as WsdlNS.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement xmlDoc = document as XmlElement;
if (wsdl != null)
{
results.Add(MetadataSection.CreateFromServiceDescription(wsdl));
}
else if (schema != null)
{
results.Add(MetadataSection.CreateFromSchema(schema));
}
else if (xmlDoc != null && xmlDoc.LocalName == "Policy")
{
results.Add(MetadataSection.CreateFromPolicy(xmlDoc, null));
}
else
{
MetadataSection mexDoc = new MetadataSection();
mexDoc.Metadata = document;
results.Add(mexDoc);
}
}
void HandleResult(IAsyncResult result)
{
HttpWebRequest request = (HttpWebRequest)result.AsyncState;
using (XmlReader reader =
MetadataLocationRetriever.GetXmlReader((HttpWebResponse)request.EndGetResponse(result), this.maxMessageSize, this.readerQuotas))
{
section = MetadataRetriever.CreateMetadataSection(reader, request.Address.ToString());
}
}
void HandleWsdlImports(MetadataSection section)
{
WsdlNS.ServiceDescription wsdl = (WsdlNS.ServiceDescription)section.Metadata;
foreach (WsdlNS.Import import in wsdl.Imports)
{
if (!String.IsNullOrEmpty(import.Location))
{
EnqueueRetrieverIfShouldResolve(new MetadataLocationRetriever(this.CreateUri(section.SourceUrl, import.Location), this.resolver));
}
}
foreach (XsdNS.XmlSchema schema in wsdl.Types.Schemas)
{
MetadataSection schemaSection = new MetadataSection(null, null, schema);
schemaSection.SourceUrl = section.SourceUrl;
this.HandleSchemaImports(schemaSection);
}
}
private MetadataSection Read66_MetadataSection(bool isNullable, bool checkType)
{
XmlQualifiedName type = checkType ? base.GetXsiType() : null;
bool flag = false;
if (isNullable)
{
flag = base.ReadNull();
}
if ((checkType && (type != null)) && ((type.Name != this.id4_MetadataSection) || (type.Namespace != this.id2_Item)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(type));
}
if (flag)
{
return null;
}
MetadataSection o = new MetadataSection();
Collection<System.Xml.XmlAttribute> attributes = o.Attributes;
bool[] flagArray = new bool[4];
while (base.Reader.MoveToNextAttribute())
{
if ((!flagArray[1] && (base.Reader.LocalName == this.id5_Dialect)) && (base.Reader.NamespaceURI == this.id6_Item))
{
o.Dialect = base.Reader.Value;
flagArray[1] = true;
}
else
{
if ((!flagArray[2] && (base.Reader.LocalName == this.id7_Identifier)) && (base.Reader.NamespaceURI == this.id6_Item))
{
o.Identifier = base.Reader.Value;
flagArray[2] = true;
continue;
}
if (!base.IsXmlnsAttribute(base.Reader.Name))
{
System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) base.Document.ReadNode(base.Reader);
base.ParseWsdlArrayType(attr);
attributes.Add(attr);
}
}
}
base.Reader.MoveToElement();
if (base.Reader.IsEmptyElement)
{
base.Reader.Skip();
return o;
}
base.Reader.ReadStartElement();
base.Reader.MoveToContent();
int whileIterations = 0;
int readerCount = base.ReaderCount;
while ((base.Reader.NodeType != XmlNodeType.EndElement) && (base.Reader.NodeType != XmlNodeType.None))
{
if (base.Reader.NodeType == XmlNodeType.Element)
{
if ((!flagArray[3] && (base.Reader.LocalName == this.id1_Metadata)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = this.Read67_MetadataSet(false, true);
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id8_schema)) && (base.Reader.NamespaceURI == this.id9_Item))
{
o.Metadata = System.Xml.Schema.XmlSchema.Read(base.Reader, null);
if (base.Reader.NodeType == XmlNodeType.EndElement)
{
base.ReadEndElement();
}
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id10_definitions)) && (base.Reader.NamespaceURI == this.id11_Item))
{
o.Metadata = System.Web.Services.Description.ServiceDescription.Read(base.Reader);
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id12_MetadataReference)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = (MetadataReference) base.ReadSerializable((IXmlSerializable) Activator.CreateInstance(typeof(MetadataReference), BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new object[0], null));
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id13_Location)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = this.Read65_MetadataLocation(false, true);
flagArray[3] = true;
}
else
{
o.Metadata = (XmlElement) base.ReadXmlNode(false);
}
}
else
{
base.UnknownNode(o, "http://schemas.xmlsoap.org/ws/2004/09/mex:Metadata, http://www.w3.org/2001/XMLSchema:schema, http://schemas.xmlsoap.org/wsdl/:definitions, http://schemas.xmlsoap.org/ws/2004/09/mex:MetadataReference, http://schemas.xmlsoap.org/ws/2004/09/mex:Location");
}
base.Reader.MoveToContent();
base.CheckReaderCount(ref whileIterations, ref readerCount);
}
base.ReadEndElement();
return o;
}
private void HandleSchemaImports(MetadataSection section)
{
System.Xml.Schema.XmlSchema metadata = (System.Xml.Schema.XmlSchema) section.Metadata;
foreach (XmlSchemaExternal external in metadata.Includes)
{
if (!string.IsNullOrEmpty(external.SchemaLocation))
{
this.EnqueueRetrieverIfShouldResolve(new MetadataExchangeClient.MetadataLocationRetriever(this.CreateUri(section.SourceUrl, external.SchemaLocation), this.resolver));
}
}
}
internal static MetadataSection CreateMetadataSection(XmlReader reader, string sourceUrl)
{
MetadataSection section = null;
System.Type metadataType = null;
if (CanReadMetadataSet(reader))
{
MetadataSet metadata = MetadataSet.ReadFrom(reader);
section = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadata);
metadataType = typeof(MetadataSet);
}
else if (System.Web.Services.Description.ServiceDescription.CanRead(reader))
{
section = MetadataSection.CreateFromServiceDescription(System.Web.Services.Description.ServiceDescription.Read(reader));
metadataType = typeof(System.Web.Services.Description.ServiceDescription);
}
else if (CanReadSchema(reader))
{
section = MetadataSection.CreateFromSchema(System.Xml.Schema.XmlSchema.Read(reader, null));
metadataType = typeof(System.Xml.Schema.XmlSchema);
}
else
{
XmlDocument document = new XmlDocument();
document.Load(reader);
section = new MetadataSection(null, null, document.DocumentElement);
metadataType = typeof(XmlElement);
}
section.SourceUrl = sourceUrl;
MetadataExchangeClient.TraceReceiveReply(sourceUrl, metadataType);
return section;
}
private void HandleResult(IAsyncResult result)
{
IMetadataExchange asyncState = (IMetadataExchange) result.AsyncState;
System.ServiceModel.Channels.Message message = asyncState.EndGet(result);
using (this.message)
{
if (message.IsFault)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxBadMetadataReference", new object[] { ((IClientChannel) asyncState).RemoteAddress.Uri.ToString() })));
}
using (XmlReader reader = message.GetReaderAtBodyContents())
{
this.section = MetadataExchangeClient.MetadataRetriever.CreateMetadataSection(reader, ((IClientChannel) asyncState).RemoteAddress.Uri.ToString());
}
}
}
private MetadataSection Read66_MetadataSection(bool isNullable, bool checkType)
{
XmlQualifiedName type = checkType ? base.GetXsiType() : null;
bool flag = false;
if (isNullable)
{
flag = base.ReadNull();
}
if ((checkType && (type != null)) && ((type.Name != this.id4_MetadataSection) || (type.Namespace != this.id2_Item)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(type));
}
if (flag)
{
return(null);
}
MetadataSection o = new MetadataSection();
Collection <System.Xml.XmlAttribute> attributes = o.Attributes;
bool[] flagArray = new bool[4];
while (base.Reader.MoveToNextAttribute())
{
if ((!flagArray[1] && (base.Reader.LocalName == this.id5_Dialect)) && (base.Reader.NamespaceURI == this.id6_Item))
{
o.Dialect = base.Reader.Value;
flagArray[1] = true;
}
else
{
if ((!flagArray[2] && (base.Reader.LocalName == this.id7_Identifier)) && (base.Reader.NamespaceURI == this.id6_Item))
{
o.Identifier = base.Reader.Value;
flagArray[2] = true;
continue;
}
if (!base.IsXmlnsAttribute(base.Reader.Name))
{
System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute)base.Document.ReadNode(base.Reader);
base.ParseWsdlArrayType(attr);
attributes.Add(attr);
}
}
}
base.Reader.MoveToElement();
if (base.Reader.IsEmptyElement)
{
base.Reader.Skip();
return(o);
}
base.Reader.ReadStartElement();
base.Reader.MoveToContent();
int whileIterations = 0;
int readerCount = base.ReaderCount;
while ((base.Reader.NodeType != XmlNodeType.EndElement) && (base.Reader.NodeType != XmlNodeType.None))
{
if (base.Reader.NodeType == XmlNodeType.Element)
{
if ((!flagArray[3] && (base.Reader.LocalName == this.id1_Metadata)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = this.Read67_MetadataSet(false, true);
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id8_schema)) && (base.Reader.NamespaceURI == this.id9_Item))
{
o.Metadata = System.Xml.Schema.XmlSchema.Read(base.Reader, null);
if (base.Reader.NodeType == XmlNodeType.EndElement)
{
base.ReadEndElement();
}
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id10_definitions)) && (base.Reader.NamespaceURI == this.id11_Item))
{
o.Metadata = System.Web.Services.Description.ServiceDescription.Read(base.Reader);
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id12_MetadataReference)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = (MetadataReference)base.ReadSerializable((IXmlSerializable)Activator.CreateInstance(typeof(MetadataReference), BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, new object[0], null));
flagArray[3] = true;
}
else if ((!flagArray[3] && (base.Reader.LocalName == this.id13_Location)) && (base.Reader.NamespaceURI == this.id2_Item))
{
o.Metadata = this.Read65_MetadataLocation(false, true);
flagArray[3] = true;
}
else
{
o.Metadata = (XmlElement)base.ReadXmlNode(false);
}
}
else
{
base.UnknownNode(o, "http://schemas.xmlsoap.org/ws/2004/09/mex:Metadata, http://www.w3.org/2001/XMLSchema:schema, http://schemas.xmlsoap.org/wsdl/:definitions, http://schemas.xmlsoap.org/ws/2004/09/mex:MetadataReference, http://schemas.xmlsoap.org/ws/2004/09/mex:Location");
}
base.Reader.MoveToContent();
base.CheckReaderCount(ref whileIterations, ref readerCount);
}
base.ReadEndElement();
return(o);
}
public static MetadataSection CreateFromPolicy(XmlElement policy, string identifier)
{
if (policy == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("policy");
}
if (!IsPolicyElement(policy))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("policy",
#pragma warning suppress 56506 // [....], policy cannot be null at this point since it has been validated above.
SR.GetString(SR.SFxBadMetadataMustBePolicy, MetadataStrings.WSPolicy.NamespaceUri, MetadataStrings.WSPolicy.Elements.Policy, policy.NamespaceURI, policy.LocalName));
}
MetadataSection section = new MetadataSection();
section.Dialect = policy.NamespaceURI;
section.Identifier = identifier;
section.Metadata = policy;
return section;
}
public static MetadataSection CreateFromServiceDescription(WsdlNS.ServiceDescription serviceDescription)
{
if (serviceDescription == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription");
}
MetadataSection section = new MetadataSection();
section.Dialect = MetadataSection.ServiceDescriptionDialect;
section.Identifier = serviceDescription.TargetNamespace;
section.Metadata = serviceDescription;
return section;
}
internal void HandleSection(MetadataSection section)
{
if (section.Metadata is MetadataSet)
{
foreach (MetadataSection innerSection in ((MetadataSet)section.Metadata).MetadataSections)
{
innerSection.SourceUrl = section.SourceUrl;
this.HandleSection(innerSection);
}
}
else if (section.Metadata is MetadataReference)
{
if (this.resolveMetadataReferences)
{
EndpointAddress address = ((MetadataReference)section.Metadata).Address;
MetadataRetriever retriever = new MetadataReferenceRetriever(address, this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(retriever);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is MetadataLocation)
{
if (this.resolveMetadataReferences)
{
string location = ((MetadataLocation)section.Metadata).Location;
MetadataRetriever retriever = new MetadataLocationRetriever(this.CreateUri(section.SourceUrl, location), this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(retriever);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is WsdlNS.ServiceDescription)
{
if (this.resolveMetadataReferences)
{
this.HandleWsdlImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else if (section.Metadata is XsdNS.XmlSchema)
{
if (this.resolveMetadataReferences)
{
this.HandleSchemaImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
void HandleSchemaImports(MetadataSection section)
{
XsdNS.XmlSchema schema = (XsdNS.XmlSchema)section.Metadata;
foreach (XsdNS.XmlSchemaExternal external in schema.Includes)
{
if (!String.IsNullOrEmpty(external.SchemaLocation))
{
EnqueueRetrieverIfShouldResolve(
new MetadataLocationRetriever(
this.CreateUri(section.SourceUrl, external.SchemaLocation),
this.resolver));
}
}
}
void AddMetadataSection(string dialect, object metadata)
{
var metadataSection = new MetadataSection(dialect, EmptyMetadataIdentifier, metadata);
MetadataSections.Add(metadataSection);
}
static internal MetadataSection CreateMetadataSection(XmlReader reader, string sourceUrl)
{
MetadataSection section = null;
Type metadataType = null;
if (CanReadMetadataSet(reader))
{
MetadataSet newSet = MetadataSet.ReadFrom(reader);
section = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, newSet);
metadataType = typeof(MetadataSet);
}
else if (WsdlNS.ServiceDescription.CanRead(reader))
{
WsdlNS.ServiceDescription wsdl = WsdlNS.ServiceDescription.Read(reader);
section = MetadataSection.CreateFromServiceDescription(wsdl);
metadataType = typeof(WsdlNS.ServiceDescription);
}
else if (CanReadSchema(reader))
{
XsdNS.XmlSchema schema = XsdNS.XmlSchema.Read(reader, null);
section = MetadataSection.CreateFromSchema(schema);
metadataType = typeof(XsdNS.XmlSchema);
}
else
{
XmlDocument doc = new XmlDocument();
doc.Load(reader);
section = new MetadataSection(null, null, doc.DocumentElement);
metadataType = typeof(XmlElement);
}
section.SourceUrl = sourceUrl;
TraceReceiveReply(sourceUrl, metadataType);
return section;
}
/// <summary>
/// Create a reader to provide simulated Metadata endpoint configuration element
/// </summary>
/// <param name="activeSTSUrl">The active endpoint URL.</param>
static XmlDictionaryReader GetMetadataReader(string activeSTSUrl)
{
MetadataSet metadata = new MetadataSet();
MetadataReference mexReferece = new MetadataReference(new EndpointAddress(activeSTSUrl), AddressingVersion.WSAddressing10);
MetadataSection refSection = new MetadataSection(MetadataSection.ServiceDescriptionDialect, null, mexReferece);
metadata.MetadataSections.Add(refSection);
byte[] metadataSectionBytes;
StringBuilder stringBuilder = new StringBuilder();
using (StringWriter stringWriter = new StringWriter(stringBuilder))
{
using (XmlTextWriter textWriter = new XmlTextWriter(stringWriter))
{
metadata.WriteTo(textWriter);
textWriter.Flush();
stringWriter.Flush();
metadataSectionBytes = stringWriter.Encoding.GetBytes(stringBuilder.ToString());
}
}
return XmlDictionaryReader.CreateTextReader(metadataSectionBytes, XmlDictionaryReaderQuotas.Max);
}
private static XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var stringBuilder = new StringBuilder();
using(var stringWriter = new StringWriter(stringBuilder, CultureInfo.InvariantCulture))
{
var xmlWriter = XmlWriter.Create(stringWriter);
metadataSet.WriteTo(xmlWriter);
xmlWriter.Flush();
stringWriter.Flush();
var stringReader = new StringReader(stringBuilder.ToString());
var xmlTextReader = new XmlTextReader(stringReader);
var result = XmlDictionaryReader.CreateDictionaryReader(xmlTextReader);
return result;
}
}
private MetadataSection CreateMetadataSection(object document)
{
System.Web.Services.Description.ServiceDescription description =
document as System.Web.Services.Description.ServiceDescription;
XmlSchema schema = document as XmlSchema;
XmlElement element = document as XmlElement;
MetadataSection section;
if (description != null)
{
section = MetadataSection.CreateFromServiceDescription(description);
}
else if (schema != null)
{
section = MetadataSection.CreateFromSchema(schema);
}
else if ((element != null) && IsPolicyElement(element))
{
section = MetadataSection.CreateFromPolicy(element, null);
}
else
{
section = new MetadataSection();
section.Metadata = document;
}
return section;
}
internal void HandleSection(MetadataSection section)
{
if (section.Metadata is System.ServiceModel.Description.MetadataSet)
{
foreach (MetadataSection section2 in ((System.ServiceModel.Description.MetadataSet) section.Metadata).MetadataSections)
{
section2.SourceUrl = section.SourceUrl;
this.HandleSection(section2);
}
}
else if (section.Metadata is MetadataReference)
{
if (this.resolveMetadataReferences)
{
MetadataExchangeClient.MetadataRetriever item = new MetadataExchangeClient.MetadataReferenceRetriever(((MetadataReference) section.Metadata).Address, this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(item);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is MetadataLocation)
{
if (this.resolveMetadataReferences)
{
string location = ((MetadataLocation) section.Metadata).Location;
MetadataExchangeClient.MetadataRetriever retriever2 = new MetadataExchangeClient.MetadataLocationRetriever(this.CreateUri(section.SourceUrl, location), this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(retriever2);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is System.Web.Services.Description.ServiceDescription)
{
if (this.resolveMetadataReferences)
{
this.HandleWsdlImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else if (section.Metadata is System.Xml.Schema.XmlSchema)
{
if (this.resolveMetadataReferences)
{
this.HandleSchemaImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
static MetadataSet LoadMetadata(Uri uri, string filename)
{
if (!File.Exists (filename)) {
Console.WriteLine ("Downloading service metadata ...");
DownloadXml (uri, filename);
Console.WriteLine ("Downloaded service metadata into {0}.", filename);
} else {
Console.WriteLine ("Loading cached service metadata from {0}.", filename);
}
using (var stream = new StreamReader (filename)) {
var doc = new MetadataSet ();
var service = WS.ServiceDescription.Read (stream);
var sect = new MetadataSection (
"http://schemas.xmlsoap.org/wsdl/", "http://tempuri.org/", service);
doc.MetadataSections.Add (sect);
return doc;
}
}
private void Write66_MetadataSection(string n, string ns, MetadataSection o, bool isNullable, bool needType)
{
if (o == null)
{
if (isNullable)
{
base.WriteNullTagLiteral(n, ns);
}
}
else
{
if (!needType && !(o.GetType() == typeof(MetadataSection)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(o));
}
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
xmlns.Add(string.Empty, string.Empty);
base.WriteStartElement(n, ns, o, true, xmlns);
if (needType)
{
base.WriteXsiType("MetadataSection", "http://schemas.xmlsoap.org/ws/2004/09/mex");
}
Collection <System.Xml.XmlAttribute> attributes = o.Attributes;
if (attributes != null)
{
for (int i = 0; i < attributes.Count; i++)
{
System.Xml.XmlAttribute node = attributes[i];
base.WriteXmlAttribute(node, o);
}
}
base.WriteAttribute("Dialect", "", o.Dialect);
base.WriteAttribute("Identifier", "", o.Identifier);
if (o.Metadata is System.Web.Services.Description.ServiceDescription)
{
((System.Web.Services.Description.ServiceDescription)o.Metadata).Write(base.Writer);
}
else if (o.Metadata is System.Xml.Schema.XmlSchema)
{
((System.Xml.Schema.XmlSchema)o.Metadata).Write(base.Writer);
}
else if (o.Metadata is MetadataSet)
{
this.Write67_MetadataSet("Metadata", "http://schemas.xmlsoap.org/ws/2004/09/mex", (MetadataSet)o.Metadata, false, false);
}
else if (o.Metadata is MetadataLocation)
{
this.Write65_MetadataLocation("Location", "http://schemas.xmlsoap.org/ws/2004/09/mex", (MetadataLocation)o.Metadata, false, false);
}
else if (o.Metadata is MetadataReference)
{
base.WriteSerializable((MetadataReference)o.Metadata, "MetadataReference", "http://schemas.xmlsoap.org/ws/2004/09/mex", false, true);
}
else if (o.Metadata is XmlElement)
{
XmlElement metadata = (XmlElement)o.Metadata;
if ((metadata == null) && (metadata != null))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateInvalidAnyTypeException(metadata));
}
base.WriteElementLiteral(metadata, "", null, false, true);
}
else if (o.Metadata != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(o.Metadata));
}
base.WriteEndElement(o);
}
}
private void HandleWsdlImports(MetadataSection section)
{
System.Web.Services.Description.ServiceDescription metadata = (System.Web.Services.Description.ServiceDescription) section.Metadata;
foreach (Import import in metadata.Imports)
{
if (!string.IsNullOrEmpty(import.Location))
{
this.EnqueueRetrieverIfShouldResolve(new MetadataExchangeClient.MetadataLocationRetriever(this.CreateUri(section.SourceUrl, import.Location), this.resolver));
}
}
foreach (System.Xml.Schema.XmlSchema schema in metadata.Types.Schemas)
{
MetadataSection section2 = new MetadataSection(null, null, schema) {
SourceUrl = section.SourceUrl
};
this.HandleSchemaImports(section2);
}
}
private void Write66_MetadataSection(string n, string ns, MetadataSection o, bool isNullable, bool needType)
{
if (o == null)
{
if (isNullable)
{
base.WriteNullTagLiteral(n, ns);
}
}
else
{
if (!needType && !(o.GetType() == typeof(MetadataSection)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(o));
}
XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
xmlns.Add(string.Empty, string.Empty);
base.WriteStartElement(n, ns, o, true, xmlns);
if (needType)
{
base.WriteXsiType("MetadataSection", "http://schemas.xmlsoap.org/ws/2004/09/mex");
}
Collection<System.Xml.XmlAttribute> attributes = o.Attributes;
if (attributes != null)
{
for (int i = 0; i < attributes.Count; i++)
{
System.Xml.XmlAttribute node = attributes[i];
base.WriteXmlAttribute(node, o);
}
}
base.WriteAttribute("Dialect", "", o.Dialect);
base.WriteAttribute("Identifier", "", o.Identifier);
if (o.Metadata is System.Web.Services.Description.ServiceDescription)
{
((System.Web.Services.Description.ServiceDescription) o.Metadata).Write(base.Writer);
}
else if (o.Metadata is System.Xml.Schema.XmlSchema)
{
((System.Xml.Schema.XmlSchema) o.Metadata).Write(base.Writer);
}
else if (o.Metadata is MetadataSet)
{
this.Write67_MetadataSet("Metadata", "http://schemas.xmlsoap.org/ws/2004/09/mex", (MetadataSet) o.Metadata, false, false);
}
else if (o.Metadata is MetadataLocation)
{
this.Write65_MetadataLocation("Location", "http://schemas.xmlsoap.org/ws/2004/09/mex", (MetadataLocation) o.Metadata, false, false);
}
else if (o.Metadata is MetadataReference)
{
base.WriteSerializable((MetadataReference) o.Metadata, "MetadataReference", "http://schemas.xmlsoap.org/ws/2004/09/mex", false, true);
}
else if (o.Metadata is XmlElement)
{
XmlElement metadata = (XmlElement) o.Metadata;
if ((metadata == null) && (metadata != null))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateInvalidAnyTypeException(metadata));
}
base.WriteElementLiteral(metadata, "", null, false, true);
}
else if (o.Metadata != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(o.Metadata));
}
base.WriteEndElement(o);
}
}
private void HandleResult(IAsyncResult result)
{
HttpWebRequest asyncState = (HttpWebRequest) result.AsyncState;
using (XmlReader reader = MetadataExchangeClient.MetadataLocationRetriever.GetXmlReader((HttpWebResponse) asyncState.EndGetResponse(result), this.maxMessageSize, this.readerQuotas))
{
this.section = MetadataExchangeClient.MetadataRetriever.CreateMetadataSection(reader, asyncState.Address.ToString());
}
}
