private void ImportOperationScopeSupportingTokensPolicy(MetadataImporter importer, PolicyConversionContext policyContext, SecurityBindingElement binding) { foreach (OperationDescription description in policyContext.Contract.Operations) { string action = null; foreach (MessageDescription description2 in description.Messages) { if (description2.Direction == MessageDirection.Input) { action = description2.Action; break; } } SupportingTokenParameters requirements = new SupportingTokenParameters(); SupportingTokenParameters optionalRequirements = new SupportingTokenParameters(); ICollection <XmlElement> operationBindingAssertions = policyContext.GetOperationBindingAssertions(description); this.ImportSupportingTokenAssertions(importer, policyContext, operationBindingAssertions, requirements, optionalRequirements); if (((requirements.Endorsing.Count > 0) || (requirements.Signed.Count > 0)) || ((requirements.SignedEncrypted.Count > 0) || (requirements.SignedEndorsing.Count > 0))) { if (action == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("CannotImportSupportingTokensForOperationWithoutRequestAction"))); } binding.OperationSupportingTokenParameters[action] = requirements; } if (((optionalRequirements.Endorsing.Count > 0) || (optionalRequirements.Signed.Count > 0)) || ((optionalRequirements.SignedEncrypted.Count > 0) || (optionalRequirements.SignedEndorsing.Count > 0))) { if (action == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("CannotImportSupportingTokensForOperationWithoutRequestAction"))); } binding.OptionalOperationSupportingTokenParameters[action] = optionalRequirements; } } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } TransactionFlowBindingElement bindingElement = context.BindingElements.Find <TransactionFlowBindingElement>(); if (bindingElement == null || !bindingElement.Transactions) { return; } XmlDocument doc = new XmlDocument(); XmlElement assertion = null; foreach (OperationDescription operation in context.Contract.Operations) { TransactionFlowAttribute contextParam = operation.Behaviors.Find <TransactionFlowAttribute>(); TransactionFlowOption txFlowOption = contextParam == null ? TransactionFlowOption.NotAllowed : contextParam.Transactions; // Transactions if (bindingElement.TransactionProtocol == TransactionProtocol.OleTransactions) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.OleTxTransactionsPrefix, TransactionPolicyStrings.OleTxTransactionsLocal, TransactionPolicyStrings.OleTxTransactionsNamespace, exporter.PolicyVersion.Namespace); } else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal, TransactionPolicyStrings.WsatTransactionsNamespace10, exporter.PolicyVersion.Namespace); } else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransaction11) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal, TransactionPolicyStrings.WsatTransactionsNamespace11, exporter.PolicyVersion.Namespace); } if (assertion != null) { context.GetOperationBindingAssertions(operation).Add(assertion); } } }
private void ImportOperationScopeSupportingTokensPolicy(MetadataImporter importer, PolicyConversionContext policyContext, SecurityBindingElement binding) { foreach (OperationDescription operation in policyContext.Contract.Operations) { string requestAction = null; foreach (MessageDescription message in operation.Messages) { if (message.Direction == MessageDirection.Input) { requestAction = message.Action; break; } } SupportingTokenParameters requirements = new SupportingTokenParameters(); SupportingTokenParameters optionalRequirements = new SupportingTokenParameters(); ICollection <XmlElement> operationBindingAssertions = policyContext.GetOperationBindingAssertions(operation); this.ImportSupportingTokenAssertions(importer, policyContext, operationBindingAssertions, requirements, optionalRequirements); if (requirements.Endorsing.Count > 0 || requirements.Signed.Count > 0 || requirements.SignedEncrypted.Count > 0 || requirements.SignedEndorsing.Count > 0) { if (requestAction != null) { binding.OperationSupportingTokenParameters[requestAction] = requirements; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SRServiceModel.CannotImportSupportingTokensForOperationWithoutRequestAction)); } } if (optionalRequirements.Endorsing.Count > 0 || optionalRequirements.Signed.Count > 0 || optionalRequirements.SignedEncrypted.Count > 0 || optionalRequirements.SignedEndorsing.Count > 0) { if (requestAction != null) { binding.OptionalOperationSupportingTokenParameters[requestAction] = optionalRequirements; } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.CannotImportSupportingTokensForOperationWithoutRequestAction))); } } } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } TransactionFlowBindingElement element = context.BindingElements.Find <TransactionFlowBindingElement>(); if ((element != null) && element.Transactions) { XmlDocument doc = new XmlDocument(); XmlElement item = null; foreach (OperationDescription description in context.Contract.Operations) { TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); TransactionFlowOption option = (attribute == null) ? TransactionFlowOption.NotAllowed : attribute.Transactions; if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions) { item = this.GetAssertion(doc, option, "oletx", "OleTxAssertion", "http://schemas.microsoft.com/ws/2006/02/tx/oletx", exporter.PolicyVersion.Namespace); } else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004) { item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://schemas.xmlsoap.org/ws/2004/10/wsat", exporter.PolicyVersion.Namespace); } else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransaction11) { item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://docs.oasis-open.org/ws-tx/wsat/2006/06", exporter.PolicyVersion.Namespace); } if (item != null) { context.GetOperationBindingAssertions(description).Add(item); } } } }
private void ImportMessageScopeProtectionPolicy(MetadataImporter importer, PolicyConversionContext policyContext) { MessagePartSpecification endpointSignedParts; MessagePartSpecification endpointEncryptedParts; bool isContractAssociatedWithAtLeastOneOtherBinding; ContractProtectionLevel otherBindingProtectionLevel = null; bool hasContractProtectionLevel = false; bool isContractProtectionLevelUniform = true; ProtectionLevel contractProtectionLevel = ProtectionLevel.None; string contractAssociationName = String.Format("{0}:{1}:{2}", ContractProtectionLevelKey, policyContext.Contract.Name, policyContext.Contract.Namespace); if (importer.State.ContainsKey(contractAssociationName)) { isContractAssociatedWithAtLeastOneOtherBinding = true; otherBindingProtectionLevel = (ContractProtectionLevel)importer.State[contractAssociationName]; } else { isContractAssociatedWithAtLeastOneOtherBinding = false; } ICollection <XmlElement> endpointBindingAssertions = policyContext.GetBindingAssertions(); this.ImportProtectionAssertions(endpointBindingAssertions, out endpointSignedParts, out endpointEncryptedParts); if (importer.State.ContainsKey(InSecureConversationBootstrapBindingImportMode)) { // when importing secure conversation boostrap binding, add the endpoint scope protection requirements // to the importer state to be consumed in SecurityPolicy11.TryImportWsspBootrstapPolicyAssertion if (endpointEncryptedParts != null) { importer.State[SecureConversationBootstrapEncryptionRequirements] = endpointEncryptedParts; } if (endpointSignedParts != null) { importer.State[SecureConversationBootstrapSignatureRequirements] = endpointSignedParts; } } foreach (OperationDescription operation in policyContext.Contract.Operations) { MessagePartSpecification operationSignedParts; MessagePartSpecification operationEncryptedParts; ICollection <XmlElement> operationBindingAssertions = policyContext.GetOperationBindingAssertions(operation); this.ImportProtectionAssertions(operationBindingAssertions, out operationSignedParts, out operationEncryptedParts); this.AddParts(ref operationSignedParts, endpointSignedParts); this.AddParts(ref operationEncryptedParts, endpointEncryptedParts); MessagePartSpecification messageSignedParts; MessagePartSpecification messageEncryptedParts; bool hasProtectionLevel = false; bool isProtectionLevelUniform = true; ProtectionLevel protectionLevel = ProtectionLevel.None; // import application message protection requirements foreach (MessageDescription message in operation.Messages) { ICollection <XmlElement> messageBindingAssertions = policyContext.GetMessageBindingAssertions(message); this.ImportProtectionAssertions(messageBindingAssertions, out messageSignedParts, out messageEncryptedParts); this.AddParts(ref messageSignedParts, operationSignedParts); this.AddParts(ref messageEncryptedParts, operationEncryptedParts); // validate or set body protection level ProtectionLevel newProtectionLevel = GetProtectionLevel(messageSignedParts.IsBodyIncluded, messageEncryptedParts.IsBodyIncluded, message.Action); if (OperationFormatter.IsValidReturnValue(message.Body.ReturnValue)) { ValidateExistingOrSetNewProtectionLevel(message.Body.ReturnValue, message, operation, policyContext.Contract, newProtectionLevel); } foreach (MessagePartDescription body in message.Body.Parts) { ValidateExistingOrSetNewProtectionLevel(body, message, operation, policyContext.Contract, newProtectionLevel); } if (!OperationFormatter.IsValidReturnValue(message.Body.ReturnValue) || message.Body.Parts.Count == 0) { ValidateExistingOrSetNewProtectionLevel(null, message, operation, policyContext.Contract, newProtectionLevel); } if (hasProtectionLevel) { if (protectionLevel != newProtectionLevel) { isProtectionLevelUniform = false; } } else { protectionLevel = newProtectionLevel; hasProtectionLevel = true; } if (hasContractProtectionLevel) { if (contractProtectionLevel != newProtectionLevel) { isContractProtectionLevelUniform = false; } } else { contractProtectionLevel = newProtectionLevel; hasContractProtectionLevel = true; } // validate o set header protection level foreach (MessageHeaderDescription header in message.Headers) { bool signed = messageSignedParts.IsHeaderIncluded(header.Name, header.Namespace); bool encrypted = messageEncryptedParts.IsHeaderIncluded(header.Name, header.Namespace); newProtectionLevel = GetProtectionLevel(signed, encrypted, message.Action); ValidateExistingOrSetNewProtectionLevel(header, message, operation, policyContext.Contract, newProtectionLevel); if (hasProtectionLevel) { if (protectionLevel != newProtectionLevel) { isProtectionLevelUniform = false; } } else { protectionLevel = newProtectionLevel; hasProtectionLevel = true; } if (hasContractProtectionLevel) { if (contractProtectionLevel != newProtectionLevel) { isContractProtectionLevelUniform = false; } } else { contractProtectionLevel = newProtectionLevel; hasContractProtectionLevel = true; } } } // normalize protection level settings at the operation scope if possible to help avoid typed message generation if (hasProtectionLevel && isProtectionLevelUniform) { // (hongmeig) remove the foreach message here // foreach (MessageDescription message in operation.Messages) this.ResetProtectionLevelForMessages(operation); operation.ProtectionLevel = protectionLevel; } // import fault protection requirements foreach (FaultDescription fault in operation.Faults) { ICollection <XmlElement> faultBindingAssertions = policyContext.GetFaultBindingAssertions(fault); this.ImportProtectionAssertions(faultBindingAssertions, out messageSignedParts, out messageEncryptedParts); this.AddParts(ref messageSignedParts, operationSignedParts); this.AddParts(ref messageEncryptedParts, operationEncryptedParts); // validate or set fault protection level ProtectionLevel newProtectionLevel = GetProtectionLevel(messageSignedParts.IsBodyIncluded, messageEncryptedParts.IsBodyIncluded, fault.Action); if (fault.HasProtectionLevel) { if (fault.ProtectionLevel != newProtectionLevel) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(string.Format(SRServiceModel.CannotImportProtectionLevelForContract, policyContext.Contract.Name, policyContext.Contract.Namespace))); } } else { fault.ProtectionLevel = newProtectionLevel; } if (hasContractProtectionLevel) { if (contractProtectionLevel != newProtectionLevel) { isContractProtectionLevelUniform = false; } } else { contractProtectionLevel = newProtectionLevel; hasContractProtectionLevel = true; } } } if (isContractAssociatedWithAtLeastOneOtherBinding) { if (hasContractProtectionLevel != otherBindingProtectionLevel.HasProtectionRequirements || isContractProtectionLevelUniform != otherBindingProtectionLevel.HasUniformProtectionLevel || contractProtectionLevel != otherBindingProtectionLevel.UniformProtectionLevel) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(string.Format(SRServiceModel.CannotImportProtectionLevelForContract, policyContext.Contract.Name, policyContext.Contract.Namespace))); } } else { if (hasContractProtectionLevel && isContractProtectionLevelUniform && contractProtectionLevel == ProtectionLevel.EncryptAndSign) { // remove all explicitly set protection levels on the contract description, since they are uniform across the contract // and match our binding's default of EncryptAndSign foreach (OperationDescription operation in policyContext.Contract.Operations) { this.ResetProtectionLevelForMessages(operation); foreach (FaultDescription fault in operation.Faults) { fault.ResetProtectionLevel(); } operation.ResetProtectionLevel(); } } importer.State[contractAssociationName] = new ContractProtectionLevel(hasContractProtectionLevel, isContractProtectionLevelUniform, contractProtectionLevel); } }
void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } // foreach property, we keep track of // - everyoneAgreesAbout: all operations agree on a value // - anOperationCaresAbout: at least one operation has expressed a preference // - agreed value itself (which only matters if anOperationCaresAbout && everyoneAgrees) bool everyoneAgreesAboutTransactions = true; bool everyoneAgreesAboutTransactionProtocol = true; TransactionFlowOption agreedTransactions = TransactionFlowOption.NotAllowed; TransactionProtocol agreedTransactionProtocol = TransactionFlowDefaults.TransactionProtocol; bool anOperationCaresAboutTransactions = false; bool anOperationCaresAboutTransactionProtocol = false; XmlElement oleTxTransactionsAssertion = null; XmlElement wsatTransactionsAssertion = null; foreach (OperationDescription operation in context.Contract.Operations) { ICollection <XmlElement> operationAssertions = context.GetOperationBindingAssertions(operation); foreach (XmlElement element in operationAssertions) { if (element.NamespaceURI == TransactionPolicyStrings.OleTxTransactionsNamespace && element.LocalName == TransactionPolicyStrings.OleTxTransactionsLocal) { oleTxTransactionsAssertion = element; TransactionFlowOption txFlow = GetOption(element, true); UpdateTransactionFlowAtribute(operation, txFlow); TrackAgreement(ref everyoneAgreesAboutTransactions, txFlow, ref agreedTransactions, ref anOperationCaresAboutTransactions); TrackAgreementTransactionProtocol(ref everyoneAgreesAboutTransactionProtocol, TransactionProtocol.OleTransactions, ref agreedTransactionProtocol, ref anOperationCaresAboutTransactionProtocol); } else if (element.NamespaceURI == TransactionPolicyStrings.WsatTransactionsNamespace10 && element.LocalName == TransactionPolicyStrings.WsatTransactionsLocal) { wsatTransactionsAssertion = element; TransactionFlowOption txFlow = GetOption(element, true); UpdateTransactionFlowAtribute(operation, txFlow); TrackAgreement(ref everyoneAgreesAboutTransactions, txFlow, ref agreedTransactions, ref anOperationCaresAboutTransactions); TrackAgreementTransactionProtocol(ref everyoneAgreesAboutTransactionProtocol, TransactionProtocol.WSAtomicTransactionOctober2004, ref agreedTransactionProtocol, ref anOperationCaresAboutTransactionProtocol); } else if (element.NamespaceURI == TransactionPolicyStrings.WsatTransactionsNamespace11 && element.LocalName == TransactionPolicyStrings.WsatTransactionsLocal) { wsatTransactionsAssertion = element; TransactionFlowOption txFlow = GetOption(element, false); UpdateTransactionFlowAtribute(operation, txFlow); TrackAgreement(ref everyoneAgreesAboutTransactions, txFlow, ref agreedTransactions, ref anOperationCaresAboutTransactions); TrackAgreementTransactionProtocol(ref everyoneAgreesAboutTransactionProtocol, TransactionProtocol.WSAtomicTransaction11, ref agreedTransactionProtocol, ref anOperationCaresAboutTransactionProtocol); } } // remove any imported assertions. if (oleTxTransactionsAssertion != null) { operationAssertions.Remove(oleTxTransactionsAssertion); } if (wsatTransactionsAssertion != null) { operationAssertions.Remove(wsatTransactionsAssertion); } } // setup the ContextFlowBindingElement (if needed) with any agreed-on information if (anOperationCaresAboutTransactions) { TransactionFlowBindingElement tfbe = EnsureBindingElement(context); tfbe.Transactions = true; if (anOperationCaresAboutTransactionProtocol && everyoneAgreesAboutTransactionProtocol) { tfbe.TransactionProtocol = agreedTransactionProtocol; } else if (anOperationCaresAboutTransactionProtocol) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException( SR.GetString(SR.SFxCannotHaveDifferentTransactionProtocolsInOneBinding))); } } }
private void ImportMessageScopeProtectionPolicy(MetadataImporter importer, PolicyConversionContext policyContext) { MessagePartSpecification specification; MessagePartSpecification specification2; bool flag; ContractProtectionLevel level = null; bool hasProtectionRequirements = false; bool hasUniformProtectionLevel = true; ProtectionLevel none = ProtectionLevel.None; string key = string.Format("{0}:{1}:{2}", "ContractProtectionLevelKey", policyContext.Contract.Name, policyContext.Contract.Namespace); if (importer.State.ContainsKey(key)) { flag = true; level = (ContractProtectionLevel)importer.State[key]; } else { flag = false; } ICollection <XmlElement> bindingAssertions = policyContext.GetBindingAssertions(); this.ImportProtectionAssertions(bindingAssertions, out specification, out specification2); if (importer.State.ContainsKey("InSecureConversationBootstrapBindingImportMode")) { if (specification2 != null) { importer.State["SecureConversationBootstrapEncryptionRequirements"] = specification2; } if (specification != null) { importer.State["SecureConversationBootstrapSignatureRequirements"] = specification; } } foreach (OperationDescription description in policyContext.Contract.Operations) { MessagePartSpecification specification3; MessagePartSpecification specification4; MessagePartSpecification specification5; MessagePartSpecification specification6; ICollection <XmlElement> operationBindingAssertions = policyContext.GetOperationBindingAssertions(description); this.ImportProtectionAssertions(operationBindingAssertions, out specification3, out specification4); this.AddParts(ref specification3, specification); this.AddParts(ref specification4, specification2); bool flag4 = false; bool flag5 = true; ProtectionLevel level3 = ProtectionLevel.None; foreach (MessageDescription description2 in description.Messages) { ICollection <XmlElement> messageBindingAssertions = policyContext.GetMessageBindingAssertions(description2); this.ImportProtectionAssertions(messageBindingAssertions, out specification5, out specification6); this.AddParts(ref specification5, specification3); this.AddParts(ref specification6, specification4); ProtectionLevel newProtectionLevel = GetProtectionLevel(specification5.IsBodyIncluded, specification6.IsBodyIncluded, description2.Action); if (OperationFormatter.IsValidReturnValue(description2.Body.ReturnValue)) { this.ValidateExistingOrSetNewProtectionLevel(description2.Body.ReturnValue, description2, description, policyContext.Contract, newProtectionLevel); } foreach (MessagePartDescription description3 in description2.Body.Parts) { this.ValidateExistingOrSetNewProtectionLevel(description3, description2, description, policyContext.Contract, newProtectionLevel); } if (!OperationFormatter.IsValidReturnValue(description2.Body.ReturnValue) || (description2.Body.Parts.Count == 0)) { this.ValidateExistingOrSetNewProtectionLevel(null, description2, description, policyContext.Contract, newProtectionLevel); } if (flag4) { if (level3 != newProtectionLevel) { flag5 = false; } } else { level3 = newProtectionLevel; flag4 = true; } if (hasProtectionRequirements) { if (none != newProtectionLevel) { hasUniformProtectionLevel = false; } } else { none = newProtectionLevel; hasProtectionRequirements = true; } foreach (MessageHeaderDescription description4 in description2.Headers) { bool signed = specification5.IsHeaderIncluded(description4.Name, description4.Namespace); bool encrypted = specification6.IsHeaderIncluded(description4.Name, description4.Namespace); newProtectionLevel = GetProtectionLevel(signed, encrypted, description2.Action); this.ValidateExistingOrSetNewProtectionLevel(description4, description2, description, policyContext.Contract, newProtectionLevel); if (flag4) { if (level3 != newProtectionLevel) { flag5 = false; } } else { level3 = newProtectionLevel; flag4 = true; } if (hasProtectionRequirements) { if (none != newProtectionLevel) { hasUniformProtectionLevel = false; } } else { none = newProtectionLevel; hasProtectionRequirements = true; } } } if (flag4 && flag5) { this.ResetProtectionLevelForMessages(description); description.ProtectionLevel = level3; } foreach (FaultDescription description5 in description.Faults) { ICollection <XmlElement> faultBindingAssertions = policyContext.GetFaultBindingAssertions(description5); this.ImportProtectionAssertions(faultBindingAssertions, out specification5, out specification6); this.AddParts(ref specification5, specification3); this.AddParts(ref specification6, specification4); ProtectionLevel level5 = GetProtectionLevel(specification5.IsBodyIncluded, specification6.IsBodyIncluded, description5.Action); if (description5.HasProtectionLevel) { if (description5.ProtectionLevel != level5) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("CannotImportProtectionLevelForContract", new object[] { policyContext.Contract.Name, policyContext.Contract.Namespace }))); } } else { description5.ProtectionLevel = level5; } if (hasProtectionRequirements) { if (none != level5) { hasUniformProtectionLevel = false; } } else { none = level5; hasProtectionRequirements = true; } } } if (flag) { if (((hasProtectionRequirements != level.HasProtectionRequirements) || (hasUniformProtectionLevel != level.HasUniformProtectionLevel)) || (none != level.UniformProtectionLevel)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("CannotImportProtectionLevelForContract", new object[] { policyContext.Contract.Name, policyContext.Contract.Namespace }))); } } else { if ((hasProtectionRequirements && hasUniformProtectionLevel) && (none == ProtectionLevel.EncryptAndSign)) { foreach (OperationDescription description6 in policyContext.Contract.Operations) { this.ResetProtectionLevelForMessages(description6); foreach (FaultDescription description7 in description6.Faults) { description7.ResetProtectionLevel(); } description6.ResetProtectionLevel(); } } importer.State[key] = new ContractProtectionLevel(hasProtectionRequirements, hasUniformProtectionLevel, none); } }
void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } bool everyoneAgrees = true; bool flag2 = true; TransactionFlowOption notAllowed = TransactionFlowOption.NotAllowed; TransactionProtocol transactionProtocol = TransactionFlowDefaults.TransactionProtocol; bool anOperationCares = false; bool flag4 = false; XmlElement item = null; XmlElement element2 = null; foreach (OperationDescription description in context.Contract.Operations) { ICollection <XmlElement> operationBindingAssertions = context.GetOperationBindingAssertions(description); foreach (XmlElement element3 in operationBindingAssertions) { if ((element3.NamespaceURI == "http://schemas.microsoft.com/ws/2006/02/tx/oletx") && (element3.LocalName == "OleTxAssertion")) { item = element3; TransactionFlowOption option = this.GetOption(element3, true); this.UpdateTransactionFlowAtribute(description, option); TrackAgreement(ref everyoneAgrees, option, ref notAllowed, ref anOperationCares); TrackAgreementTransactionProtocol(ref flag2, TransactionProtocol.OleTransactions, ref transactionProtocol, ref flag4); } else if ((element3.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/10/wsat") && (element3.LocalName == "ATAssertion")) { element2 = element3; TransactionFlowOption txFlow = this.GetOption(element3, true); this.UpdateTransactionFlowAtribute(description, txFlow); TrackAgreement(ref everyoneAgrees, txFlow, ref notAllowed, ref anOperationCares); TrackAgreementTransactionProtocol(ref flag2, TransactionProtocol.WSAtomicTransactionOctober2004, ref transactionProtocol, ref flag4); } else if ((element3.NamespaceURI == "http://docs.oasis-open.org/ws-tx/wsat/2006/06") && (element3.LocalName == "ATAssertion")) { element2 = element3; TransactionFlowOption option4 = this.GetOption(element3, false); this.UpdateTransactionFlowAtribute(description, option4); TrackAgreement(ref everyoneAgrees, option4, ref notAllowed, ref anOperationCares); TrackAgreementTransactionProtocol(ref flag2, TransactionProtocol.WSAtomicTransaction11, ref transactionProtocol, ref flag4); } } if (item != null) { operationBindingAssertions.Remove(item); } if (element2 != null) { operationBindingAssertions.Remove(element2); } } if (anOperationCares) { TransactionFlowBindingElement element4 = this.EnsureBindingElement(context); element4.Transactions = true; if (flag4 && flag2) { element4.TransactionProtocol = transactionProtocol; } else if (flag4) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(System.ServiceModel.SR.GetString("SFxCannotHaveDifferentTransactionProtocolsInOneBinding"))); } } }