| | | 1 | | // Licensed to the .NET Foundation under one or more agreements. |
| | | 2 | | // The .NET Foundation licenses this file to you under the MIT license. |
| | | 3 | | |
| | | 4 | | using System; |
| | | 5 | | using System.Globalization; |
| | | 6 | | using System.IO; |
| | | 7 | | using System.Runtime.Serialization; |
| | | 8 | | using System.Xml; |
| | | 9 | | using CoreWCF.Description; |
| | | 10 | | using CoreWCF.Dispatcher; |
| | | 11 | | using CoreWCF.Runtime; |
| | | 12 | | |
| | | 13 | | namespace CoreWCF.Channels |
| | | 14 | | { |
| | | 15 | | public abstract class MessageHeader : MessageHeaderInfo |
| | | 16 | | { |
| | | 17 | | private const bool DefaultRelayValue = false; |
| | | 18 | | private const bool DefaultMustUnderstandValue = false; |
| | | 19 | | private const string DefaultActorValue = ""; |
| | | 20 | | |
| | | 21 | | public override string Actor |
| | | 22 | | { |
| | 31102 | 23 | | get { return ""; } |
| | | 24 | | } |
| | | 25 | | |
| | | 26 | | public override bool IsReferenceParameter |
| | | 27 | | { |
| | 12 | 28 | | get { return false; } |
| | | 29 | | } |
| | | 30 | | |
| | | 31 | | public override bool MustUnderstand |
| | | 32 | | { |
| | 0 | 33 | | get { return DefaultMustUnderstandValue; } |
| | | 34 | | } |
| | | 35 | | |
| | | 36 | | public override bool Relay |
| | | 37 | | { |
| | 2242 | 38 | | get { return DefaultRelayValue; } |
| | | 39 | | } |
| | | 40 | | |
| | | 41 | | public virtual bool IsMessageVersionSupported(MessageVersion messageVersion) |
| | | 42 | | { |
| | 28923 | 43 | | if (messageVersion == null) |
| | | 44 | | { |
| | 0 | 45 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 46 | | } |
| | | 47 | | |
| | 28923 | 48 | | return true; |
| | | 49 | | } |
| | | 50 | | |
| | | 51 | | public override string ToString() |
| | | 52 | | { |
| | 0 | 53 | | XmlWriterSettings xmlSettings = new XmlWriterSettings() { Indent = true }; |
| | 0 | 54 | | using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture)) |
| | | 55 | | { |
| | 0 | 56 | | using (XmlWriter textWriter = XmlWriter.Create(stringWriter, xmlSettings)) |
| | | 57 | | { |
| | 0 | 58 | | using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateDictionaryWriter(textWriter)) |
| | | 59 | | { |
| | 0 | 60 | | if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressing10)) |
| | | 61 | | { |
| | 0 | 62 | | WriteHeader(writer, MessageVersion.Soap12WSAddressing10); |
| | | 63 | | } |
| | | 64 | | //else if (IsMessageVersionSupported(MessageVersion.Soap12WSAddressingAugust2004)) |
| | | 65 | | //{ |
| | | 66 | | // WriteHeader(writer, MessageVersion.Soap12WSAddressingAugust2004); |
| | | 67 | | //} |
| | | 68 | | //else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressing10)) |
| | | 69 | | //{ |
| | | 70 | | // WriteHeader(writer, MessageVersion.Soap11WSAddressing10); |
| | | 71 | | //} |
| | | 72 | | //else if (IsMessageVersionSupported(MessageVersion.Soap11WSAddressingAugust2004)) |
| | | 73 | | //{ |
| | | 74 | | // WriteHeader(writer, MessageVersion.Soap11WSAddressingAugust2004); |
| | | 75 | | //} |
| | | 76 | | //else if (IsMessageVersionSupported(MessageVersion.Soap12)) |
| | | 77 | | //{ |
| | | 78 | | // WriteHeader(writer, MessageVersion.Soap12); |
| | | 79 | | //} |
| | 0 | 80 | | else if (IsMessageVersionSupported(MessageVersion.Soap11)) |
| | | 81 | | { |
| | 0 | 82 | | WriteHeader(writer, MessageVersion.Soap11); |
| | | 83 | | } |
| | | 84 | | else |
| | | 85 | | { |
| | 0 | 86 | | WriteHeader(writer, MessageVersion.None); |
| | | 87 | | } |
| | | 88 | | |
| | 0 | 89 | | writer.Flush(); |
| | 0 | 90 | | return stringWriter.ToString(); |
| | | 91 | | } |
| | | 92 | | } |
| | | 93 | | } |
| | 0 | 94 | | } |
| | | 95 | | |
| | | 96 | | public void WriteHeader(XmlWriter writer, MessageVersion messageVersion) |
| | | 97 | | { |
| | 0 | 98 | | WriteHeader(XmlDictionaryWriter.CreateDictionaryWriter(writer), messageVersion); |
| | 0 | 99 | | } |
| | | 100 | | |
| | | 101 | | public void WriteHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 102 | | { |
| | 197 | 103 | | if (writer == null) |
| | | 104 | | { |
| | 0 | 105 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(writer)); |
| | | 106 | | } |
| | | 107 | | |
| | 197 | 108 | | if (messageVersion == null) |
| | | 109 | | { |
| | 0 | 110 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 111 | | } |
| | | 112 | | |
| | 197 | 113 | | OnWriteStartHeader(writer, messageVersion); |
| | 197 | 114 | | OnWriteHeaderContents(writer, messageVersion); |
| | 197 | 115 | | writer.WriteEndElement(); |
| | 197 | 116 | | } |
| | | 117 | | |
| | | 118 | | public void WriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 119 | | { |
| | 46483 | 120 | | if (writer == null) |
| | | 121 | | { |
| | 0 | 122 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(writer)); |
| | | 123 | | } |
| | | 124 | | |
| | 46483 | 125 | | if (messageVersion == null) |
| | | 126 | | { |
| | 0 | 127 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 128 | | } |
| | | 129 | | |
| | 46483 | 130 | | OnWriteStartHeader(writer, messageVersion); |
| | 46483 | 131 | | } |
| | | 132 | | |
| | | 133 | | protected virtual void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 134 | | { |
| | 28861 | 135 | | writer.WriteStartElement(Name, Namespace); |
| | 28861 | 136 | | WriteHeaderAttributes(writer, messageVersion); |
| | 28861 | 137 | | } |
| | | 138 | | |
| | | 139 | | public void WriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 140 | | { |
| | 46483 | 141 | | if (writer == null) |
| | | 142 | | { |
| | 0 | 143 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(writer)); |
| | | 144 | | } |
| | | 145 | | |
| | 46483 | 146 | | if (messageVersion == null) |
| | | 147 | | { |
| | 0 | 148 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 149 | | } |
| | | 150 | | |
| | 46483 | 151 | | OnWriteHeaderContents(writer, messageVersion); |
| | 46483 | 152 | | } |
| | | 153 | | |
| | | 154 | | protected abstract void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion); |
| | | 155 | | |
| | | 156 | | protected void WriteHeaderAttributes(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 157 | | { |
| | 31166 | 158 | | string actor = Actor; |
| | 31166 | 159 | | if (actor.Length > 0) |
| | | 160 | | { |
| | 0 | 161 | | writer.WriteAttributeString(messageVersion.Envelope.DictionaryActor, messageVersion.Envelope.DictionaryN |
| | | 162 | | } |
| | | 163 | | |
| | 31166 | 164 | | if (MustUnderstand) |
| | | 165 | | { |
| | 1974 | 166 | | writer.WriteAttributeString(XD.MessageDictionary.MustUnderstand, messageVersion.Envelope.DictionaryNames |
| | | 167 | | } |
| | | 168 | | |
| | 31166 | 169 | | if (Relay && messageVersion.Envelope == EnvelopeVersion.Soap12) |
| | | 170 | | { |
| | 0 | 171 | | writer.WriteAttributeString(XD.Message12Dictionary.Relay, XD.Message12Dictionary.Namespace, "1"); |
| | | 172 | | } |
| | 31166 | 173 | | } |
| | | 174 | | |
| | | 175 | | public static MessageHeader CreateHeader(string name, string ns, object value) |
| | | 176 | | { |
| | 1 | 177 | | return CreateHeader(name, ns, value, DefaultMustUnderstandValue, DefaultActorValue, DefaultRelayValue); |
| | | 178 | | } |
| | | 179 | | |
| | | 180 | | public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand) |
| | | 181 | | { |
| | 0 | 182 | | return CreateHeader(name, ns, value, mustUnderstand, DefaultActorValue, DefaultRelayValue); |
| | | 183 | | } |
| | | 184 | | |
| | | 185 | | public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor |
| | | 186 | | { |
| | 0 | 187 | | return CreateHeader(name, ns, value, mustUnderstand, actor, DefaultRelayValue); |
| | | 188 | | } |
| | | 189 | | |
| | | 190 | | public static MessageHeader CreateHeader(string name, string ns, object value, bool mustUnderstand, string actor |
| | | 191 | | { |
| | 5 | 192 | | return new XmlObjectSerializerHeader(name, ns, value, null, mustUnderstand, actor, relay); |
| | | 193 | | } |
| | | 194 | | |
| | | 195 | | public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer) |
| | | 196 | | { |
| | 0 | 197 | | return CreateHeader(name, ns, value, serializer, DefaultMustUnderstandValue, DefaultActorValue, DefaultRelay |
| | | 198 | | } |
| | | 199 | | |
| | | 200 | | public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, b |
| | | 201 | | { |
| | 0 | 202 | | return CreateHeader(name, ns, value, serializer, mustUnderstand, DefaultActorValue, DefaultRelayValue); |
| | | 203 | | } |
| | | 204 | | |
| | | 205 | | public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, b |
| | | 206 | | { |
| | 0 | 207 | | return CreateHeader(name, ns, value, serializer, mustUnderstand, actor, DefaultRelayValue); |
| | | 208 | | } |
| | | 209 | | |
| | | 210 | | public static MessageHeader CreateHeader(string name, string ns, object value, XmlObjectSerializer serializer, b |
| | | 211 | | { |
| | 0 | 212 | | if (serializer == null) |
| | | 213 | | { |
| | 0 | 214 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(serializer)); |
| | | 215 | | } |
| | | 216 | | |
| | 0 | 217 | | return new XmlObjectSerializerHeader(name, ns, value, serializer, mustUnderstand, actor, relay); |
| | | 218 | | } |
| | | 219 | | |
| | | 220 | | internal static void GetHeaderAttributes(XmlDictionaryReader reader, MessageVersion version, |
| | | 221 | | out string actor, out bool mustUnderstand, out bool relay, out bool isReferenceParameter) |
| | | 222 | | { |
| | 19276 | 223 | | int attributeCount = reader.AttributeCount; |
| | | 224 | | |
| | 19276 | 225 | | if (attributeCount == 0) |
| | | 226 | | { |
| | 558 | 227 | | mustUnderstand = false; |
| | 558 | 228 | | actor = string.Empty; |
| | 558 | 229 | | relay = false; |
| | 558 | 230 | | isReferenceParameter = false; |
| | | 231 | | } |
| | | 232 | | else |
| | | 233 | | { |
| | 18718 | 234 | | string mustUnderstandString = reader.GetAttribute(XD.MessageDictionary.MustUnderstand, version.Envelope. |
| | 18718 | 235 | | if (mustUnderstandString != null && ToBoolean(mustUnderstandString)) |
| | | 236 | | { |
| | 4273 | 237 | | mustUnderstand = true; |
| | | 238 | | } |
| | | 239 | | else |
| | | 240 | | { |
| | 14445 | 241 | | mustUnderstand = false; |
| | | 242 | | } |
| | | 243 | | |
| | 18718 | 244 | | if (mustUnderstand && attributeCount == 1) |
| | | 245 | | { |
| | 4175 | 246 | | actor = string.Empty; |
| | 4175 | 247 | | relay = false; |
| | | 248 | | } |
| | | 249 | | else |
| | | 250 | | { |
| | 14543 | 251 | | actor = reader.GetAttribute(version.Envelope.DictionaryActor, version.Envelope.DictionaryNamespace); |
| | 14543 | 252 | | if (actor == null) |
| | | 253 | | { |
| | 14543 | 254 | | actor = ""; |
| | | 255 | | } |
| | | 256 | | |
| | 14543 | 257 | | if (version.Envelope == EnvelopeVersion.Soap12) |
| | | 258 | | { |
| | 14524 | 259 | | string relayString = reader.GetAttribute(XD.Message12Dictionary.Relay, version.Envelope.Dictiona |
| | 14524 | 260 | | if (relayString != null && ToBoolean(relayString)) |
| | | 261 | | { |
| | 0 | 262 | | relay = true; |
| | | 263 | | } |
| | | 264 | | else |
| | | 265 | | { |
| | 14524 | 266 | | relay = false; |
| | | 267 | | } |
| | | 268 | | } |
| | | 269 | | else |
| | | 270 | | { |
| | 19 | 271 | | relay = false; |
| | | 272 | | } |
| | | 273 | | } |
| | | 274 | | |
| | 18718 | 275 | | isReferenceParameter = false; |
| | 18718 | 276 | | if (version.Addressing == AddressingVersion.WSAddressing10) |
| | | 277 | | { |
| | 18667 | 278 | | string refParam = reader.GetAttribute(XD.AddressingDictionary.IsReferenceParameter, version.Addressi |
| | 18667 | 279 | | if (refParam != null) |
| | | 280 | | { |
| | 0 | 281 | | isReferenceParameter = ToBoolean(refParam); |
| | | 282 | | } |
| | | 283 | | } |
| | | 284 | | } |
| | 18718 | 285 | | } |
| | | 286 | | |
| | | 287 | | private static bool ToBoolean(string value) |
| | | 288 | | { |
| | 4273 | 289 | | if (value.Length == 1) |
| | | 290 | | { |
| | 4273 | 291 | | char ch = value[0]; |
| | 4273 | 292 | | if (ch == '1') |
| | | 293 | | { |
| | 4273 | 294 | | return true; |
| | | 295 | | } |
| | 0 | 296 | | if (ch == '0') |
| | | 297 | | { |
| | 0 | 298 | | return false; |
| | | 299 | | } |
| | | 300 | | } |
| | | 301 | | else |
| | | 302 | | { |
| | 0 | 303 | | if (value == "true") |
| | | 304 | | { |
| | 0 | 305 | | return true; |
| | | 306 | | } |
| | 0 | 307 | | else if (value == "false") |
| | | 308 | | { |
| | 0 | 309 | | return false; |
| | | 310 | | } |
| | | 311 | | } |
| | | 312 | | try |
| | | 313 | | { |
| | 0 | 314 | | return XmlConvert.ToBoolean(value); |
| | | 315 | | } |
| | 0 | 316 | | catch (FormatException exception) |
| | | 317 | | { |
| | 0 | 318 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, null)); |
| | | 319 | | } |
| | 0 | 320 | | } |
| | | 321 | | } |
| | | 322 | | |
| | | 323 | | // TODO: This needed to be made public for NetTcp, investigate making it internal again |
| | | 324 | | public abstract class DictionaryHeader : MessageHeader |
| | | 325 | | { |
| | | 326 | | public override string Name |
| | | 327 | | { |
| | | 328 | | get { return DictionaryName.Value; } |
| | | 329 | | } |
| | | 330 | | |
| | | 331 | | public override string Namespace |
| | | 332 | | { |
| | | 333 | | get { return DictionaryNamespace.Value; } |
| | | 334 | | } |
| | | 335 | | |
| | | 336 | | public abstract XmlDictionaryString DictionaryName { get; } |
| | | 337 | | public abstract XmlDictionaryString DictionaryNamespace { get; } |
| | | 338 | | |
| | | 339 | | protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 340 | | { |
| | | 341 | | writer.WriteStartElement(DictionaryName, DictionaryNamespace); |
| | | 342 | | WriteHeaderAttributes(writer, messageVersion); |
| | | 343 | | } |
| | | 344 | | } |
| | | 345 | | |
| | | 346 | | internal class XmlObjectSerializerHeader : MessageHeader |
| | | 347 | | { |
| | | 348 | | private XmlObjectSerializer _serializer; |
| | | 349 | | private readonly bool _mustUnderstand; |
| | | 350 | | private readonly bool _relay; |
| | | 351 | | private readonly bool _isOneTwoSupported; |
| | | 352 | | private readonly bool _isOneOneSupported; |
| | | 353 | | private readonly bool _isNoneSupported; |
| | | 354 | | private readonly object _objectToSerialize; |
| | | 355 | | private readonly string _name; |
| | | 356 | | private readonly string _ns; |
| | | 357 | | private readonly string _actor; |
| | | 358 | | private readonly object _syncRoot = new object(); |
| | | 359 | | |
| | | 360 | | private XmlObjectSerializerHeader(XmlObjectSerializer serializer, bool mustUnderstand, string actor, bool relay) |
| | | 361 | | { |
| | | 362 | | _mustUnderstand = mustUnderstand; |
| | | 363 | | _relay = relay; |
| | | 364 | | _serializer = serializer; |
| | | 365 | | _actor = actor ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(actor)); |
| | | 366 | | if (actor == EnvelopeVersion.Soap12.UltimateDestinationActor) |
| | | 367 | | { |
| | | 368 | | _isOneOneSupported = false; |
| | | 369 | | _isOneTwoSupported = true; |
| | | 370 | | } |
| | | 371 | | else if (actor == EnvelopeVersion.Soap12.NextDestinationActorValue) |
| | | 372 | | { |
| | | 373 | | _isOneOneSupported = false; |
| | | 374 | | _isOneTwoSupported = true; |
| | | 375 | | } |
| | | 376 | | else if (actor == EnvelopeVersion.Soap11.NextDestinationActorValue) |
| | | 377 | | { |
| | | 378 | | _isOneOneSupported = true; |
| | | 379 | | _isOneTwoSupported = false; |
| | | 380 | | } |
| | | 381 | | else |
| | | 382 | | { |
| | | 383 | | _isOneOneSupported = true; |
| | | 384 | | _isOneTwoSupported = true; |
| | | 385 | | _isNoneSupported = true; |
| | | 386 | | } |
| | | 387 | | } |
| | | 388 | | |
| | | 389 | | public XmlObjectSerializerHeader(string name, string ns, object objectToSerialize, XmlObjectSerializer serialize |
| | | 390 | | : this(serializer, mustUnderstand, actor, relay) |
| | | 391 | | { |
| | | 392 | | if (null == name) |
| | | 393 | | { |
| | | 394 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(name)); |
| | | 395 | | } |
| | | 396 | | |
| | | 397 | | if (name.Length == 0) |
| | | 398 | | { |
| | | 399 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.SFXHeaderNameCannotBe |
| | | 400 | | } |
| | | 401 | | |
| | | 402 | | if (ns == null) |
| | | 403 | | { |
| | | 404 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(ns)); |
| | | 405 | | } |
| | | 406 | | if (ns.Length > 0) |
| | | 407 | | { |
| | | 408 | | NamingHelper.CheckUriParameter(ns, nameof(ns)); |
| | | 409 | | } |
| | | 410 | | _objectToSerialize = objectToSerialize; |
| | | 411 | | _name = name; |
| | | 412 | | _ns = ns; |
| | | 413 | | } |
| | | 414 | | |
| | | 415 | | public override bool IsMessageVersionSupported(MessageVersion messageVersion) |
| | | 416 | | { |
| | | 417 | | if (messageVersion == null) |
| | | 418 | | { |
| | | 419 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 420 | | } |
| | | 421 | | |
| | | 422 | | if (messageVersion.Envelope == EnvelopeVersion.Soap12) |
| | | 423 | | { |
| | | 424 | | return _isOneTwoSupported; |
| | | 425 | | } |
| | | 426 | | else if (messageVersion.Envelope == EnvelopeVersion.Soap11) |
| | | 427 | | { |
| | | 428 | | return _isOneOneSupported; |
| | | 429 | | } |
| | | 430 | | else if (messageVersion.Envelope == EnvelopeVersion.None) |
| | | 431 | | { |
| | | 432 | | return _isNoneSupported; |
| | | 433 | | } |
| | | 434 | | else |
| | | 435 | | { |
| | | 436 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.Env |
| | | 437 | | } |
| | | 438 | | } |
| | | 439 | | |
| | | 440 | | public override string Name |
| | | 441 | | { |
| | | 442 | | get { return _name; } |
| | | 443 | | } |
| | | 444 | | |
| | | 445 | | public override string Namespace |
| | | 446 | | { |
| | | 447 | | get { return _ns; } |
| | | 448 | | } |
| | | 449 | | |
| | | 450 | | public override bool MustUnderstand |
| | | 451 | | { |
| | | 452 | | get { return _mustUnderstand; } |
| | | 453 | | } |
| | | 454 | | |
| | | 455 | | public override bool Relay |
| | | 456 | | { |
| | | 457 | | get { return _relay; } |
| | | 458 | | } |
| | | 459 | | |
| | | 460 | | public override string Actor |
| | | 461 | | { |
| | | 462 | | get { return _actor; } |
| | | 463 | | } |
| | | 464 | | |
| | | 465 | | protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 466 | | { |
| | | 467 | | lock (_syncRoot) |
| | | 468 | | { |
| | | 469 | | if (_serializer == null) |
| | | 470 | | { |
| | | 471 | | _serializer = DataContractSerializerDefaults.CreateSerializer( |
| | | 472 | | (_objectToSerialize == null ? typeof(object) : _objectToSerialize.GetType()), Name, Namespace, i |
| | | 473 | | } |
| | | 474 | | |
| | | 475 | | _serializer.WriteObjectContent(writer, _objectToSerialize); |
| | | 476 | | } |
| | | 477 | | } |
| | | 478 | | } |
| | | 479 | | |
| | | 480 | | internal abstract class ReadableMessageHeader : MessageHeader |
| | | 481 | | { |
| | | 482 | | public abstract XmlDictionaryReader GetHeaderReader(); |
| | | 483 | | |
| | | 484 | | protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 485 | | { |
| | | 486 | | if (!IsMessageVersionSupported(messageVersion)) |
| | | 487 | | { |
| | | 488 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.MessageHead |
| | | 489 | | } |
| | | 490 | | |
| | | 491 | | XmlDictionaryReader reader = GetHeaderReader(); |
| | | 492 | | writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); |
| | | 493 | | writer.WriteAttributes(reader, false); |
| | | 494 | | reader.Dispose(); |
| | | 495 | | } |
| | | 496 | | |
| | | 497 | | protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) |
| | | 498 | | { |
| | | 499 | | XmlDictionaryReader reader = GetHeaderReader(); |
| | | 500 | | reader.ReadStartElement(); |
| | | 501 | | while (reader.NodeType != XmlNodeType.EndElement) |
| | | 502 | | { |
| | | 503 | | writer.WriteNode(reader, false); |
| | | 504 | | } |
| | | 505 | | |
| | | 506 | | reader.ReadEndElement(); |
| | | 507 | | reader.Dispose(); |
| | | 508 | | } |
| | | 509 | | } |
| | | 510 | | |
| | | 511 | | internal interface IMessageHeaderWithSharedNamespace |
| | | 512 | | { |
| | | 513 | | XmlDictionaryString SharedNamespace { get; } |
| | | 514 | | XmlDictionaryString SharedPrefix { get; } |
| | | 515 | | } |
| | | 516 | | |
| | | 517 | | internal class BufferedHeader : ReadableMessageHeader |
| | | 518 | | { |
| | | 519 | | private readonly MessageVersion _version; |
| | | 520 | | private readonly XmlBuffer _buffer; |
| | | 521 | | private readonly int _bufferIndex; |
| | | 522 | | private readonly string _actor; |
| | | 523 | | private readonly bool _relay; |
| | | 524 | | private readonly bool _mustUnderstand; |
| | | 525 | | private readonly string _name; |
| | | 526 | | private readonly string _ns; |
| | | 527 | | private readonly bool _streamed; |
| | | 528 | | private readonly bool _isRefParam; |
| | | 529 | | |
| | | 530 | | public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, string name, string ns, bool mu |
| | | 531 | | { |
| | | 532 | | _version = version; |
| | | 533 | | _buffer = buffer; |
| | | 534 | | _bufferIndex = bufferIndex; |
| | | 535 | | _name = name; |
| | | 536 | | _ns = ns; |
| | | 537 | | _mustUnderstand = mustUnderstand; |
| | | 538 | | _actor = actor; |
| | | 539 | | _relay = relay; |
| | | 540 | | _isRefParam = isRefParam; |
| | | 541 | | } |
| | | 542 | | |
| | | 543 | | public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, MessageHeaderInfo headerInfo) |
| | | 544 | | { |
| | | 545 | | _version = version; |
| | | 546 | | _buffer = buffer; |
| | | 547 | | _bufferIndex = bufferIndex; |
| | | 548 | | _actor = headerInfo.Actor; |
| | | 549 | | _relay = headerInfo.Relay; |
| | | 550 | | _name = headerInfo.Name; |
| | | 551 | | _ns = headerInfo.Namespace; |
| | | 552 | | _isRefParam = headerInfo.IsReferenceParameter; |
| | | 553 | | _mustUnderstand = headerInfo.MustUnderstand; |
| | | 554 | | } |
| | | 555 | | |
| | | 556 | | public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] |
| | | 557 | | { |
| | | 558 | | _streamed = true; |
| | | 559 | | _buffer = buffer; |
| | | 560 | | _version = version; |
| | | 561 | | GetHeaderAttributes(reader, version, out _actor, out _mustUnderstand, out _relay, out _isRefParam); |
| | | 562 | | _name = reader.LocalName; |
| | | 563 | | _ns = reader.NamespaceURI; |
| | | 564 | | Fx.Assert(_name != null, ""); |
| | | 565 | | Fx.Assert(_ns != null, ""); |
| | | 566 | | _bufferIndex = buffer.SectionCount; |
| | | 567 | | XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas); |
| | | 568 | | |
| | | 569 | | // Write an enclosing Envelope tag |
| | | 570 | | writer.WriteStartElement(MessageStrings.Envelope); |
| | | 571 | | if (envelopeAttributes != null) |
| | | 572 | | { |
| | | 573 | | XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer); |
| | | 574 | | } |
| | | 575 | | |
| | | 576 | | // Write and enclosing Header tag |
| | | 577 | | writer.WriteStartElement(MessageStrings.Header); |
| | | 578 | | if (headerAttributes != null) |
| | | 579 | | { |
| | | 580 | | XmlAttributeHolder.WriteAttributes(headerAttributes, writer); |
| | | 581 | | } |
| | | 582 | | |
| | | 583 | | writer.WriteNode(reader, false); |
| | | 584 | | |
| | | 585 | | writer.WriteEndElement(); |
| | | 586 | | writer.WriteEndElement(); |
| | | 587 | | |
| | | 588 | | buffer.CloseSection(); |
| | | 589 | | } |
| | | 590 | | |
| | | 591 | | public override string Actor |
| | | 592 | | { |
| | | 593 | | get { return _actor; } |
| | | 594 | | } |
| | | 595 | | |
| | | 596 | | public override bool IsReferenceParameter |
| | | 597 | | { |
| | | 598 | | get { return _isRefParam; } |
| | | 599 | | } |
| | | 600 | | |
| | | 601 | | public override string Name |
| | | 602 | | { |
| | | 603 | | get { return _name; } |
| | | 604 | | } |
| | | 605 | | |
| | | 606 | | public override string Namespace |
| | | 607 | | { |
| | | 608 | | get { return _ns; } |
| | | 609 | | } |
| | | 610 | | |
| | | 611 | | public override bool MustUnderstand |
| | | 612 | | { |
| | | 613 | | get { return _mustUnderstand; } |
| | | 614 | | } |
| | | 615 | | |
| | | 616 | | public override bool Relay |
| | | 617 | | { |
| | | 618 | | get { return _relay; } |
| | | 619 | | } |
| | | 620 | | |
| | | 621 | | public override bool IsMessageVersionSupported(MessageVersion messageVersion) |
| | | 622 | | { |
| | | 623 | | if (messageVersion == null) |
| | | 624 | | { |
| | | 625 | | throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageVersion)); |
| | | 626 | | } |
| | | 627 | | |
| | | 628 | | return messageVersion == _version; |
| | | 629 | | } |
| | | 630 | | |
| | | 631 | | public override XmlDictionaryReader GetHeaderReader() |
| | | 632 | | { |
| | | 633 | | XmlDictionaryReader reader = _buffer.GetReader(_bufferIndex); |
| | | 634 | | // See if we need to move past the enclosing envelope/header |
| | | 635 | | if (_streamed) |
| | | 636 | | { |
| | | 637 | | reader.MoveToContent(); |
| | | 638 | | reader.Read(); // Envelope |
| | | 639 | | reader.Read(); // Header |
| | | 640 | | reader.MoveToContent(); |
| | | 641 | | } |
| | | 642 | | return reader; |
| | | 643 | | } |
| | | 644 | | } |
| | | 645 | | } |