class/System.Runtime.Serialization/System.Xml/XmlMtomDictionaryReader.cs

   1 //
   2 // XmlMtomDictionaryReader.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2009 Novell, Inc.  http://www.novell.com
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Collections.Generic;
  31 using System.IO;
  32 using System.Net.Mime;
  33 using System.Reflection;
  34 using System.Text;
  35 using System.Xml;
  36
  37 namespace System.Xml
  38 {
  39         internal class XmlMtomDictionaryReader : XmlDictionaryReader
  40         {
  41                 public XmlMtomDictionaryReader (
  42                         Stream stream, Encoding encoding,
  43                         XmlDictionaryReaderQuotas quotas)
  44                 {
  45                         this.stream = stream;
  46                         this.encoding = encoding;
  47                         this.quotas = quotas;
  48
  49                         Initialize ();
  50                 }
  51
  52                 public XmlMtomDictionaryReader (
  53                         Stream stream, Encoding [] encodings, string contentType,
  54                         XmlDictionaryReaderQuotas quotas,
  55                         int maxBufferSize,
  56                         OnXmlDictionaryReaderClose onClose)
  57                 {
  58                         this.stream = stream;
  59                         this.encodings = encodings;
  60                         content_type = contentType != null ? CreateContentType (contentType) : null;
  61                         this.quotas = quotas;
  62                         this.max_buffer_size = maxBufferSize;
  63                         on_close = onClose;
  64
  65                         Initialize ();
  66                 }
  67
  68                 Stream stream;
  69                 Encoding encoding;
  70                 Encoding [] encodings;
  71                 ContentType content_type;
  72                 XmlDictionaryReaderQuotas quotas;
  73                 int max_buffer_size;
  74                 OnXmlDictionaryReaderClose on_close;
  75
  76                 Dictionary<string,MimeEncodedStream> readers = new Dictionary<string,MimeEncodedStream> ();
  77
  78                 void Initialize ()
  79                 {
  80                         var nt = new NameTable ();
  81                         initial_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.Initial);
  82                         eof_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.EndOfFile);
  83                         xml_reader = initial_reader;
  84                 }
  85
  86                 ContentType CreateContentType (string contentTypeString)
  87                 {
  88                         ContentType c = null;
  89                         foreach (var s_ in contentTypeString.Split (';')) {
  90                                 var s = s_.Trim ();
  91                                 if (c == null) {
  92                                         // first one
  93                                         c = new ContentType (s);
  94                                         continue;
  95                                 }
  96                                 int idx = s.IndexOf ('=');
  97                                 if (idx < 0)
  98                                         throw new XmlException ("Invalid content type header");
  99                                 var val = StripBraces (s.Substring (idx + 1));
 100                                 c.Parameters [s.Substring (0, idx)] = val;
 101                         }
 102                         return c;
 103                 }
 104
 105                 XmlReader xml_reader, initial_reader, eof_reader, part_reader;
 106                 XmlReader Reader {
 107                         get { return part_reader ?? xml_reader; }
 108                 }
 109
 110                 public override bool EOF {
 111                         get { return Reader == eof_reader; }
 112                 }
 113
 114                 public override void Close ()
 115                 {
 116                         if (!EOF && on_close != null)
 117                                 on_close (this);
 118                         xml_reader = eof_reader;
 119                 }
 120
 121                 public override bool Read ()
 122                 {
 123                         if (EOF)
 124                                 return false;
 125
 126                         if (Reader == initial_reader)
 127                                 SetupPrimaryReader ();
 128
 129                         if (part_reader != null)
 130                                 part_reader = null;
 131
 132                         if (!Reader.Read ()) {
 133                                 xml_reader = eof_reader;
 134                                 return false;
 135                         }
 136                         if (Reader.LocalName == "Include" && Reader.NamespaceURI == "http://www.w3.org/2004/08/xop/include") {
 137                                 string cid = Reader.GetAttribute ("href");
 138                                 if (!cid.StartsWith ("cid:"))
 139                                         throw new XmlException ("Cannot resolve non-cid href attribute value in XOP Include element");
 140                                 cid = cid.Substring (4);
 141                                 if (!readers.ContainsKey (cid))
 142                                         ReadToIdentifiedStream (cid);
 143                                 part_reader = new MultiPartedXmlReader (Reader, readers [cid]);
 144                         }
 145                         return true;
 146                 }
 147
 148                 void SetupPrimaryReader ()
 149                 {
 150                         ReadOptionalMimeHeaders ();
 151                         if (current_content_type != null)
 152                                 content_type = current_content_type;
 153
 154                         if (content_type == null)
 155                                 throw new XmlException ("Content-Type header for the MTOM message was not found");
 156                         if (content_type.Boundary == null)
 157                                 throw new XmlException ("Content-Type header for the MTOM message must contain 'boundary' parameter");
 158
 159                         if (encoding == null && content_type.CharSet != null)
 160                                 encoding = Encoding.GetEncoding (content_type.CharSet);
 161                         if (encoding == null && encodings == null)
 162                                 throw new XmlException ("Encoding specification is required either in the constructor argument or the content-type header");
 163
 164                         // consume the first identifier.
 165                         string ident = "--" + content_type.Boundary;
 166                         string idline;
 167
 168                         while (true) {
 169                                 idline = ReadAsciiLine ().Trim ();
 170                                 if (idline == null)
 171                                         return;
 172                                 if (idline.Length != 0)
 173                                         break;
 174                         }
 175                         if (!idline.StartsWith (ident, StringComparison.Ordinal))
 176                                 throw new XmlException (String.Format ("Unexpected boundary line was found. Expected boundary is '{0}' but it was '{1}'", content_type.Boundary, idline));
 177
 178                         string start = content_type.Parameters ["start"];
 179                         ReadToIdentifiedStream (start);
 180
 181                         xml_reader = XmlReader.Create (readers [start].CreateTextReader ());
 182                 }
 183
 184                 int buffer_length;
 185                 byte [] buffer;
 186                 int peek_char;
 187
 188                 ContentType current_content_type;
 189                 int content_index;
 190                 string current_content_id, current_content_encoding;
 191
 192                 void ReadToIdentifiedStream (string id)
 193                 {
 194                         while (true) {
 195                                 if (!ReadNextStream ())
 196                                         throw new XmlException (String.Format ("The stream '{0}' did not appear", id));
 197                                 if (current_content_id == id || id == null)
 198                                         break;
 199                         }
 200                 }
 201
 202                 bool ReadNextStream ()
 203                 {
 204                         ReadOptionalMimeHeaders ();
 205                         string ident = "--" + content_type.Boundary;
 206
 207                         StringBuilder sb = new StringBuilder ();
 208                         while (true) {
 209                                 string n = ReadAsciiLine ();
 210                                 if (n == null && sb.Length == 0)
 211                                         return false;
 212                                 else if (n == null || n.StartsWith (ident, StringComparison.Ordinal))
 213                                         break;
 214                                 sb.Append (n);
 215                         }
 216                         readers.Add (current_content_id, new MimeEncodedStream (current_content_id, current_content_encoding, sb.ToString ()));
 217                         return true;
 218                 }
 219
 220                 void ReadOptionalMimeHeaders ()
 221                 {
 222                         peek_char = stream.ReadByte ();
 223                         if (peek_char == '-') // no header
 224                                 return;
 225                         ReadMimeHeaders ();
 226                 }
 227
 228                 string ReadAllHeaderLines ()
 229                 {
 230                         string s = String.Empty;
 231
 232                         while (true) {
 233                                 var n = ReadAsciiLine ();
 234                                 if (n.Length == 0)
 235                                         return s;
 236                                 n = n.TrimEnd ();
 237                                 s += n;
 238                                 if (n [n.Length - 1] != ';')
 239                                         s += '\n';
 240                         }
 241                 }
 242
 243                 void ReadMimeHeaders ()
 244                 {
 245                         foreach (var s in ReadAllHeaderLines ().Split ('\n')) {
 246                                 if (s.Length == 0)
 247                                         continue;
 248                                 int idx = s.IndexOf (':');
 249                                 if (idx < 0)
 250                                         throw new XmlException (String.Format ("Unexpected header string: {0}", s));
 251                                 string v = StripBraces (s.Substring (idx + 1).Trim ());
 252                                 switch (s.Substring (0, idx).ToLower ()) {
 253                                 case "content-type":
 254                                         current_content_type = CreateContentType (v);
 255                                         break;
 256                                 case "content-id":
 257                                         current_content_id = v;
 258                                         break;
 259                                 case "content-transfer-encoding":
 260                                         current_content_encoding = v;
 261                                         break;
 262                                 }
 263                         }
 264                 }
 265
 266                 string StripBraces (string s)
 267                 {
 268                         // could be foo, <foo>, "foo" and "<foo>".
 269                         if (s.Length >= 2 && s [0] == '"' && s [s.Length - 1] == '"')
 270                                 s = s.Substring (1, s.Length - 2);
 271                         if (s.Length >= 2 && s [0] == '<' && s [s.Length - 1] == '>')
 272                                 s = s.Substring (1, s.Length - 2);
 273                         return s;
 274                 }
 275
 276                 string ReadAsciiLine ()
 277                 {
 278                         if (buffer == null)
 279                                 buffer = new byte [1024];
 280                         int bpos = 0;
 281                         int b = peek_char;
 282                         bool skipRead = b >= 0;
 283                         peek_char = -1;
 284                         while (true) {
 285                                 if (skipRead)
 286                                         skipRead = false;
 287                                 else
 288                                         b = stream.ReadByte ();
 289                                 if (b < 0) {
 290                                         if (bpos > 0)
 291                                                 throw new XmlException ("The stream ends without end of line");
 292                                         return null;
 293                                 }
 294                                 if (b == '\r') {
 295                                         b = stream.ReadByte ();
 296                                         if (b < 0) {
 297                                                 buffer [bpos++] = (byte) '\r';
 298                                                 break;
 299                                         }
 300                                         else if (b == '\n')
 301                                                 break;
 302                                         buffer [bpos++] = (byte) '\r';
 303                                         skipRead = true;
 304                                 }
 305                                 else
 306                                         buffer [bpos++] = (byte) b;
 307                                 if (bpos == buffer.Length) {
 308                                         var newbuf = new byte [buffer.Length << 1];
 309                                         Array.Copy (buffer, 0, newbuf, 0, buffer.Length);
 310                                         buffer = newbuf;
 311                                 }
 312                         }
 313                         return Encoding.ASCII.GetString (buffer, 0, bpos);
 314                 }
 315
 316                 // The rest are just reader delegation.
 317
 318                 public override int AttributeCount {
 319                         get { return Reader.AttributeCount; }
 320                 }
 321
 322                 public override string BaseURI {
 323                         get { return Reader.BaseURI; }
 324                 }
 325
 326                 public override int Depth {
 327                         get { return Reader.Depth; }
 328                 }
 329
 330                 public override bool HasValue {
 331                         get { return Reader.HasValue; }
 332                 }
 333
 334                 public override bool IsEmptyElement {
 335                         get { return Reader.IsEmptyElement; }
 336                 }
 337
 338                 public override string LocalName {
 339                         get { return Reader.LocalName; }
 340                 }
 341
 342                 public override string NamespaceURI {
 343                         get { return Reader.NamespaceURI; }
 344                 }
 345
 346                 public override XmlNameTable NameTable {
 347                         get { return Reader.NameTable; }
 348                 }
 349
 350                 public override XmlNodeType NodeType {
 351                         get { return Reader.NodeType; }
 352                 }
 353
 354                 public override string Prefix {
 355                         get { return Reader.Prefix; }
 356                 }
 357
 358                 public override ReadState ReadState {
 359                         get { return Reader.ReadState; }
 360                 }
 361
 362                 public override string Value {
 363                         get { return Reader.Value; }
 364                 }
 365
 366                 public override bool MoveToElement ()
 367                 {
 368                         return Reader.MoveToElement ();
 369                 }
 370
 371                 public override string GetAttribute (int index)
 372                 {
 373                         return Reader.GetAttribute (index);
 374                 }
 375
 376                 public override string GetAttribute (string name)
 377                 {
 378                         return Reader.GetAttribute (name);
 379                 }
 380
 381                 public override string GetAttribute (string localName, string namespaceURI)
 382                 {
 383                         return Reader.GetAttribute (localName, namespaceURI);
 384                 }
 385
 386                 public override void MoveToAttribute (int index)
 387                 {
 388                         Reader.MoveToAttribute (index);
 389                 }
 390
 391                 public override bool MoveToAttribute (string name)
 392                 {
 393                         return Reader.MoveToAttribute (name);
 394                 }
 395
 396                 public override bool MoveToAttribute (string localName, string namespaceURI)
 397                 {
 398                         return Reader.MoveToAttribute (localName, namespaceURI);
 399                 }
 400
 401                 public override bool MoveToFirstAttribute ()
 402                 {
 403                         return Reader.MoveToFirstAttribute ();
 404                 }
 405
 406                 public override bool MoveToNextAttribute ()
 407                 {
 408                         return Reader.MoveToNextAttribute ();
 409                 }
 410
 411                 public override string LookupNamespace (string prefix)
 412                 {
 413                         return Reader.LookupNamespace (prefix);
 414                 }
 415
 416                 public override bool ReadAttributeValue ()
 417                 {
 418                         return Reader.ReadAttributeValue ();
 419                 }
 420
 421                 public override void ResolveEntity ()
 422                 {
 423                         Reader.ResolveEntity ();
 424                 }
 425         }
 426
 427         class NonInteractiveStateXmlReader : DummyStateXmlReader
 428         {
 429                 public NonInteractiveStateXmlReader (string baseUri, XmlNameTable nameTable, ReadState readState)
 430                         : base (baseUri, nameTable, readState)
 431                 {
 432                 }
 433
 434                 public override int Depth {
 435                         get { return 0; }
 436                 }
 437
 438                 public override bool HasValue {
 439                         get { return false; }
 440                 }
 441
 442                 public override string Value {
 443                         get { return String.Empty; }
 444                 }
 445
 446                 public override XmlNodeType NodeType {
 447                         get { return XmlNodeType.None; }
 448                 }
 449         }
 450
 451         class MultiPartedXmlReader : DummyStateXmlReader
 452         {
 453                 public MultiPartedXmlReader (XmlReader reader, MimeEncodedStream value)
 454                         : base (reader.BaseURI, reader.NameTable, reader.ReadState)
 455                 {
 456                         this.owner = reader;
 457                         this.value = value.CreateTextReader ().ReadToEnd ();
 458                 }
 459
 460                 XmlReader owner;
 461                 string value;
 462
 463                 public override int Depth {
 464                         get { return owner.Depth; }
 465                 }
 466
 467                 public override bool HasValue {
 468                         get { return true; }
 469                 }
 470
 471                 public override string Value {
 472                         get { return value; }
 473                 }
 474
 475                 public override XmlNodeType NodeType {
 476                         get { return XmlNodeType.Text; }
 477                 }
 478         }
 479
 480         abstract class DummyStateXmlReader : XmlReader
 481         {
 482                 protected DummyStateXmlReader (string baseUri, XmlNameTable nameTable, ReadState readState)
 483                 {
 484                         base_uri = baseUri;
 485                         name_table = nameTable;
 486                         read_state = readState;
 487                 }
 488
 489                 string base_uri;
 490                 XmlNameTable name_table;
 491                 ReadState read_state;
 492
 493                 public override string BaseURI {
 494                         get { return base_uri; }
 495                 }
 496
 497                 public override bool EOF {
 498                         get { return false; }
 499                 }
 500
 501                 public override void Close ()
 502                 {
 503                         throw new NotSupportedException ();
 504                 }
 505
 506                 public override bool Read ()
 507                 {
 508                         throw new NotSupportedException ();
 509                 }
 510
 511                 // The rest are just reader delegation.
 512
 513                 public override int AttributeCount {
 514                         get { return 0; }
 515                 }
 516
 517                 public override bool IsEmptyElement {
 518                         get { return false; }
 519                 }
 520
 521                 public override string LocalName {
 522                         get { return String.Empty; }
 523                 }
 524
 525                 public override string NamespaceURI {
 526                         get { return String.Empty; }
 527                 }
 528
 529                 public override XmlNameTable NameTable {
 530                         get { return name_table; }
 531                 }
 532
 533                 public override string Prefix {
 534                         get { return String.Empty; }
 535                 }
 536
 537                 public override ReadState ReadState {
 538                         get { return read_state; }
 539                 }
 540
 541                 public override bool MoveToElement ()
 542                 {
 543                         return false;
 544                 }
 545
 546                 public override string GetAttribute (int index)
 547                 {
 548                         return null;
 549                 }
 550
 551                 public override string GetAttribute (string name)
 552                 {
 553                         return null;
 554                 }
 555
 556                 public override string GetAttribute (string localName, string namespaceURI)
 557                 {
 558                         return null;
 559                 }
 560
 561                 public override void MoveToAttribute (int index)
 562                 {
 563                         throw new ArgumentOutOfRangeException ();
 564                 }
 565
 566                 public override bool MoveToAttribute (string name)
 567                 {
 568                         return false;
 569                 }
 570
 571                 public override bool MoveToAttribute (string localName, string namespaceURI)
 572                 {
 573                         return false;
 574                 }
 575
 576                 public override bool MoveToFirstAttribute ()
 577                 {
 578                         return false;
 579                 }
 580
 581                 public override bool MoveToNextAttribute ()
 582                 {
 583                         return false;
 584                 }
 585
 586                 public override string LookupNamespace (string prefix)
 587                 {
 588                         return null;
 589                 }
 590
 591                 public override bool ReadAttributeValue ()
 592                 {
 593                         return false;
 594                 }
 595
 596                 public override void ResolveEntity ()
 597                 {
 598                         throw new InvalidOperationException ();
 599                 }
 600         }
 601
 602         class MimeEncodedStream
 603         {
 604                 public MimeEncodedStream (string id, string contentEncoding, string value)
 605                 {
 606                         Id = id;
 607                         ContentEncoding = contentEncoding;
 608                         EncodedString = value;
 609                 }
 610
 611                 public string Id { get; set; }
 612                 public string ContentEncoding { get; set; }
 613                 public string EncodedString { get; set; }
 614
 615                 public string DecodedBase64String {
 616                         get { return Convert.ToBase64String (Encoding.ASCII.GetBytes (EncodedString)); }
 617                 }
 618
 619                 public TextReader CreateTextReader ()
 620                 {
 621                         switch (ContentEncoding) {
 622                         case "7bit":
 623                         case "8bit":
 624                                 return new StringReader (EncodedString);
 625                         default:
 626                                 return new StringReader (DecodedBase64String);
 627                         }
 628                 }
 629         }
 630 }