?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disable broken tests on net_4_0
[mcs.git] / class / corlib / System.Resources / ResourceReader.cs
blob422375f87652a7763949574903322ef2c5cec48b
1 //
2 // System.Resources.ResourceReader.cs
3 //
4 // Authors:
5 // Duncan Mak <duncan@ximian.com>
6 // Nick Drochak <ndrochak@gol.com>
7 // Dick Porter <dick@ximian.com>
8 // Marek Safar <marek.safar@seznam.cz>
9 // Atsushi Enomoto <atsushi@ximian.com>
10 // Larry Ewing <lewing@novell.com>
11 //
12 // (C) 2001, 2002 Ximian Inc, http://www.ximian.com
13 // Copyright (C) 2004-2005,2007-2008 Novell, Inc (http://www.novell.com)
14 //
15 // Permission is hereby granted, free of charge, to any person obtaining
16 // a copy of this software and associated documentation files (the
17 // "Software"), to deal in the Software without restriction, including
18 // without limitation the rights to use, copy, modify, merge, publish,
19 // distribute, sublicense, and/or sell copies of the Software, and to
20 // permit persons to whom the Software is furnished to do so, subject to
21 // the following conditions:
22 //
23 // The above copyright notice and this permission notice shall be
24 // included in all copies or substantial portions of the Software.
25 //
26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33 //
34
35 using System.Collections;
36 using System.Resources;
37 using System.IO;
38 using System.Text;
39 using System.Runtime.InteropServices;
40 using System.Runtime.Serialization;
41 using System.Runtime.Serialization.Formatters.Binary;
42 using System.Security.Permissions;
43 using System.Collections.Generic;
44
45 namespace System.Resources
46 {
47 internal enum PredefinedResourceType
48 {
49 Null = 0,
50 String = 1,
51 Bool = 2,
52 Char = 3,
53 Byte = 4,
54 SByte = 5,
55 Int16 = 6,
56 UInt16 = 7,
57 Int32 = 8,
58 UInt32 = 9,
59 Int64 = 10,
60 UInt64 = 11,
61 Single = 12,
62 Double = 13,
63 Decimal = 14,
64 DateTime = 15,
65 TimeSpan = 16,
66 ByteArray = 32,
67 Stream = 33,
68 FistCustom = 64
69 }
70
71 [System.Runtime.InteropServices.ComVisible (true)]
72 public sealed class ResourceReader : IResourceReader, IEnumerable, IDisposable
73 {
74 struct ResourceInfo
75 {
76 public readonly long ValuePosition;
77 public readonly string ResourceName;
78 public readonly int TypeIndex;
79
80 public ResourceInfo (string resourceName, long valuePosition, int type_index)
81 {
82 ValuePosition = valuePosition;
83 ResourceName = resourceName;
84 TypeIndex = type_index;
85 }
86 }
87
88 struct ResourceCacheItem
89 {
90 public readonly string ResourceName;
91 public readonly object ResourceValue;
92
93 public ResourceCacheItem (string name, object value)
94 {
95 ResourceName = name;
96 ResourceValue = value;
97 }
98 }
99
100 BinaryReader reader;
101 object readerLock = new object ();
102 IFormatter formatter;
103 internal int resourceCount = 0;
104 int typeCount = 0;
105 string[] typeNames;
106 int[] hashes;
107 ResourceInfo[] infos;
108 int dataSectionOffset;
109 long nameSectionOffset;
110 int resource_ver;
111 ResourceCacheItem[] cache;
112 object cache_lock = new object ();
113
114 // Constructors
115 [SecurityPermission (SecurityAction.LinkDemand, SerializationFormatter = true)]
116 public ResourceReader (Stream stream)
117 {
118 if (stream == null)
119 throw new ArgumentNullException ("stream");
120
121 if (!stream.CanRead)
122 throw new ArgumentException ("Stream was not readable.");
123
124 reader = new BinaryReader(stream, Encoding.UTF8);
125 formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.File|StreamingContextStates.Persistence));
126
127 ReadHeaders();
128 }
129
130 public ResourceReader (string fileName)
131 {
132 reader = new BinaryReader (new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read));
133 formatter = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.File|StreamingContextStates.Persistence));
134
135 ReadHeaders();
136 }
137
138 /* Read the ResourceManager header and the
139 * ResourceReader header.
140 */
141 private void ReadHeaders()
142 {
143 try {
144 int manager_magic = reader.ReadInt32();
145
146 if(manager_magic != ResourceManager.MagicNumber)
147 throw new ArgumentException(String.Format ("Stream is not a valid .resources file, magic=0x{0:x}", manager_magic));
148
149 int manager_ver = reader.ReadInt32();
150 int manager_len = reader.ReadInt32();
151
152 /* We know how long the header is, even if
153 * the version number is too new
154 */
155 if(manager_ver > ResourceManager.HeaderVersionNumber) {
156 reader.BaseStream.Seek(manager_len, SeekOrigin.Current);
157 } else {
158 string reader_class=reader.ReadString();
159 if(!reader_class.StartsWith("System.Resources.ResourceReader")) {
160 throw new NotSupportedException("This .resources file requires reader class " + reader_class);
161 }
162
163 string set_class=reader.ReadString();
164 if(!set_class.StartsWith(typeof(ResourceSet).FullName) && !set_class.StartsWith("System.Resources.RuntimeResourceSet")) {
165 throw new NotSupportedException("This .resources file requires set class " + set_class);
166 }
167 }
168
169 /* Now read the ResourceReader header */
170 resource_ver = reader.ReadInt32();
171
172 if(resource_ver != 1 && resource_ver != 2) {
173 throw new NotSupportedException("This .resources file requires unsupported set class version: " + resource_ver.ToString());
174 }
175
176 resourceCount = reader.ReadInt32();
177 typeCount = reader.ReadInt32();
178
179 typeNames=new string[typeCount];
180
181 for(int i=0; i<typeCount; i++) {
182 typeNames[i]=reader.ReadString();
183 }
184
185 /* There are between 0 and 7 bytes of
186 * padding here, consisting of the
187 * letters PAD. The next item (Hash
188 * values for each resource name) need
189 * to be aligned on an 8-byte
190 * boundary.
191 */
192
193 int pad_align=(int)(reader.BaseStream.Position & 7);
194 int pad_chars=0;
195
196 if(pad_align!=0) {
197 pad_chars=8-pad_align;
198 }
199
200 for(int i=0; i<pad_chars; i++) {
201 byte pad_byte=reader.ReadByte();
202 if(pad_byte!="PAD"[i%3]) {
203 throw new ArgumentException("Malformed .resources file (padding values incorrect)");
204 }
205 }
206 /* Read in the hash values for each
207 * resource name. These can be used
208 * by ResourceSet (calling internal
209 * methods) to do a fast compare on
210 * resource names without doing
211 * expensive string compares (but we
212 * dont do that yet, so far we only
213 * implement the Enumerator interface)
214 */
215 hashes=new int[resourceCount];
216 for(int i=0; i<resourceCount; i++) {
217 hashes[i]=reader.ReadInt32();
218 }
219
220 /* Read in the virtual offsets for
221 * each resource name
222 */
223 long[] positions = new long [resourceCount];
224 for(int i = 0; i < resourceCount; i++)
225 positions [i] = reader.ReadInt32();
226
227 dataSectionOffset = reader.ReadInt32();
228 nameSectionOffset = reader.BaseStream.Position;
229
230 long origPosition = reader.BaseStream.Position;
231 infos = new ResourceInfo [resourceCount];
232 for (int i = 0; i < resourceCount; i++)
233 CreateResourceInfo (positions [i], ref infos [i]);
234 reader.BaseStream.Seek (origPosition, SeekOrigin.Begin);
235
236 positions = null;
237 } catch(EndOfStreamException e) {
238 throw new ArgumentException("Stream is not a valid .resources file! It was possibly truncated.", e);
239 }
240 }
241
242 void CreateResourceInfo (long position, ref ResourceInfo info)
243 {
244 long pos = position + nameSectionOffset;
245
246 reader.BaseStream.Seek (pos, SeekOrigin.Begin);
247
248 // Resource name
249 int len = Read7BitEncodedInt ();
250 byte[] str = new byte [len];
251
252 reader.Read (str, 0, len);
253 string resourceName = Encoding.Unicode.GetString (str);
254
255 long data_offset = reader.ReadInt32 () + dataSectionOffset;
256 reader.BaseStream.Seek (data_offset, SeekOrigin.Begin);
257 int type_index = Read7BitEncodedInt ();
258
259 info = new ResourceInfo (resourceName, reader.BaseStream.Position, type_index);
260 }
261
262 /* Cut and pasted from BinaryReader, because it's
263 * 'protected' there
264 */
265 private int Read7BitEncodedInt() {
266 int ret = 0;
267 int shift = 0;
268 byte b;
269
270 do {
271 b = reader.ReadByte();
272
273 ret = ret | ((b & 0x7f) << shift);
274 shift += 7;
275 } while ((b & 0x80) == 0x80);
276
277 return ret;
278 }
279
280 object ReadValueVer2 (int type_index)
281 {
282 switch ((PredefinedResourceType)type_index)
283 {
284 case PredefinedResourceType.Null:
285 return null;
286
287 case PredefinedResourceType.String:
288 return reader.ReadString();
289
290 case PredefinedResourceType.Bool:
291 return reader.ReadBoolean ();
292
293 case PredefinedResourceType.Char:
294 return (char)reader.ReadUInt16();
295
296 case PredefinedResourceType.Byte:
297 return reader.ReadByte();
298
299 case PredefinedResourceType.SByte:
300 return reader.ReadSByte();
301
302 case PredefinedResourceType.Int16:
303 return reader.ReadInt16();
304
305 case PredefinedResourceType.UInt16:
306 return reader.ReadUInt16();
307
308 case PredefinedResourceType.Int32:
309 return reader.ReadInt32();
310
311 case PredefinedResourceType.UInt32:
312 return reader.ReadUInt32();
313
314 case PredefinedResourceType.Int64:
315 return reader.ReadInt64();
316
317 case PredefinedResourceType.UInt64:
318 return reader.ReadUInt64();
319
320 case PredefinedResourceType.Single:
321 return reader.ReadSingle();
322
323 case PredefinedResourceType.Double:
324 return reader.ReadDouble();
325
326 case PredefinedResourceType.Decimal:
327 return reader.ReadDecimal();
328
329 case PredefinedResourceType.DateTime:
330 return new DateTime(reader.ReadInt64());
331
332 case PredefinedResourceType.TimeSpan:
333 return new TimeSpan(reader.ReadInt64());
334
335 case PredefinedResourceType.ByteArray:
336 return reader.ReadBytes (reader.ReadInt32 ());
337
338 case PredefinedResourceType.Stream:
339 // FIXME: create pinned UnmanagedMemoryStream for efficiency.
340 byte [] bytes = new byte [reader.ReadUInt32 ()];
341 reader.Read (bytes, 0, bytes.Length);
342 return new MemoryStream (bytes);
343 }
344
345 type_index -= (int)PredefinedResourceType.FistCustom;
346 return ReadNonPredefinedValue (Type.GetType (typeNames[type_index], true));
347 }
348
349 object ReadValueVer1 (Type type)
350 {
351 // The most common first
352 if (type==typeof(String))
353 return reader.ReadString();
354 if (type==typeof(Int32))
355 return reader.ReadInt32();
356 if (type==typeof(Byte))
357 return(reader.ReadByte());
358 if (type==typeof(Double))
359 return(reader.ReadDouble());
360 if (type==typeof(Int16))
361 return(reader.ReadInt16());
362 if (type==typeof(Int64))
363 return(reader.ReadInt64());
364 if (type==typeof(SByte))
365 return(reader.ReadSByte());
366 if (type==typeof(Single))
367 return(reader.ReadSingle());
368 if (type==typeof(TimeSpan))
369 return(new TimeSpan(reader.ReadInt64()));
370 if (type==typeof(UInt16))
371 return(reader.ReadUInt16());
372 if (type==typeof(UInt32))
373 return(reader.ReadUInt32());
374 if (type==typeof(UInt64))
375 return(reader.ReadUInt64());
376 if (type==typeof(Decimal))
377 return(reader.ReadDecimal());
378 if (type==typeof(DateTime))
379 return(new DateTime(reader.ReadInt64()));
380
381 return ReadNonPredefinedValue(type);
382 }
383
384 // TODO: Add security checks
385 object ReadNonPredefinedValue (Type exp_type)
386 {
387 object obj=formatter.Deserialize(reader.BaseStream);
388 if(obj.GetType() != exp_type) {
389 /* We got a bogus
390 * object. This
391 * exception is the
392 * best match I could
393 * find. (.net seems
394 * to throw
395 * BadImageFormatException,
396 * which the docs
397 * state is used when
398 * file or dll images
399 * cant be loaded by
400 * the runtime.)
401 */
402 throw new InvalidOperationException("Deserialized object is wrong type");
403 }
404 return obj;
405 }
406
407 void LoadResourceValues (ResourceCacheItem[] store)
408 {
409 ResourceInfo ri;
410 object value;
411
412 lock (readerLock) {
413 for (int i = 0; i < resourceCount; i++) {
414 ri = infos [i];
415 if (ri.TypeIndex == -1) {
416 store [i] = new ResourceCacheItem (ri.ResourceName, null);
417 continue;
418 }
419
420 reader.BaseStream.Seek (ri.ValuePosition, SeekOrigin.Begin);
421 if (resource_ver == 2)
422 value = ReadValueVer2 (ri.TypeIndex);
423 else
424 value = ReadValueVer1 (Type.GetType (typeNames [ri.TypeIndex], true));
425
426 store [i] = new ResourceCacheItem (ri.ResourceName, value);
427 }
428 }
429 }
430
431 internal UnmanagedMemoryStream ResourceValueAsStream (string name, int index)
432 {
433 ResourceInfo ri = infos [index];
434 if ((PredefinedResourceType)ri.TypeIndex != PredefinedResourceType.Stream)
435 throw new InvalidOperationException (String.Format ("Resource '{0}' was not a Stream. Use GetObject() instead.", name));
436
437 lock (readerLock) {
438 reader.BaseStream.Seek (ri.ValuePosition, SeekOrigin.Begin);
439
440 // here we return a Stream from exactly
441 // current position so that the returned
442 // Stream represents a single object stream.
443 long slen = reader.ReadInt32();
444 UnmanagedMemoryStream basePtrStream = reader.BaseStream as UnmanagedMemoryStream;
445 unsafe {
446 if (basePtrStream != null) {
447 return new UnmanagedMemoryStream (basePtrStream.PositionPointer, slen);
448 } else {
449 IntPtr ptr = Marshal.AllocHGlobal ((int) slen);
450 byte* addr = (byte*) ptr.ToPointer ();
451 UnmanagedMemoryStream ms = new UnmanagedMemoryStream (addr, slen, slen, FileAccess.ReadWrite);
452 // The memory resource must be freed
453 // when the stream is disposed.
454 ms.Closed += delegate (object o, EventArgs e) {
455 Marshal.FreeHGlobal (ptr);
456 };
457
458 byte [] bytes = new byte [slen < 1024 ? slen : 1024];
459 while (slen > 0 ) {
460 int x = reader.Read (bytes, 0, (int)Math.Min (bytes.Length, slen));
461
462 if (x == 0)
463 throw new FormatException ("The resource data is corrupt. Resource stream ended");
464
465 ms.Write (bytes, 0, x);
466 slen -= x;
467 }
468 ms.Seek (0, SeekOrigin.Begin);
469 return ms;
470 }
471 }
472 }
473 }
474
475 public void Close ()
476 {
477 Dispose(true);
478 }
479
480 public IDictionaryEnumerator GetEnumerator () {
481 if (reader == null){
482 throw new InvalidOperationException("ResourceReader is closed.");
483 }
484 else {
485 return new ResourceEnumerator (this);
486 }
487 }
488
489 IEnumerator IEnumerable.GetEnumerator ()
490 {
491 return ((IResourceReader) this).GetEnumerator();
492 }
493
494 public void GetResourceData (string resourceName, out string resourceType, out byte [] resourceData)
495 {
496 if (resourceName == null)
497 throw new ArgumentNullException ("resourceName");
498 ResourceEnumerator en = new ResourceEnumerator (this);
499 while (en.MoveNext ())
500 if ((string) en.Key == resourceName) {
501 GetResourceDataAt (en.Index, out resourceType, out resourceData);
502 return;
503 }
504 throw new ArgumentException (String.Format ("Specified resource not found: {0}", resourceName));
505 }
506
507 private void GetResourceDataAt (int index, out string resourceType, out byte [] data)
508 {
509 ResourceInfo ri = infos [index];
510 int type_index = ri.TypeIndex;
511 if (type_index == -1)
512 throw new FormatException ("The resource data is corrupt");
513
514 lock (readerLock) {
515 reader.BaseStream.Seek (ri.ValuePosition, SeekOrigin.Begin);
516 long pos2 = reader.BaseStream.Position;
517
518 // Simply read data, and seek back to the original position
519 if (resource_ver == 2) {
520 if (type_index >= (int) PredefinedResourceType.FistCustom) {
521 int typenameidx = type_index - (int)PredefinedResourceType.FistCustom;
522 if (typenameidx >= typeNames.Length)
523 throw new FormatException ("The resource data is corrupt. Invalid index to types");
524 resourceType = typeNames[typenameidx];
525 }
526 else
527 resourceType = "ResourceTypeCode." + (PredefinedResourceType) type_index;
528 ReadValueVer2 (type_index);
529 } else {
530 // resource ver 1 == untyped
531 resourceType = "ResourceTypeCode.Null";
532 ReadValueVer1 (Type.GetType (typeNames [type_index], true));
533 }
534
535 // FIXME: the data size is wrong.
536 int datalen = (int) (reader.BaseStream.Position - pos2);
537 reader.BaseStream.Seek (-datalen, SeekOrigin.Current);
538 data = new byte [datalen];
539 reader.BaseStream.Read (data, 0, datalen);
540 }
541 }
542
543 void IDisposable.Dispose ()
544 {
545 Dispose(true);
546 }
547
548 private void Dispose (bool disposing)
549 {
550 if(disposing) {
551 if(reader!=null) {
552 reader.Close();
553 }
554 }
555
556 reader=null;
557 hashes=null;
558 infos=null;
559 typeNames=null;
560 cache = null;
561 }
562
563 internal sealed class ResourceEnumerator : IDictionaryEnumerator
564 {
565 private ResourceReader reader;
566 private int index = -1;
567 private bool finished;
568
569 internal ResourceEnumerator(ResourceReader readerToEnumerate)
570 {
571 reader = readerToEnumerate;
572 FillCache ();
573 }
574
575 public int Index
576 {
577 get { return index; }
578 }
579
580 public DictionaryEntry Entry {
581 get {
582 if (reader.reader == null)
583 throw new InvalidOperationException("ResourceReader is closed.");
584 if (index < 0)
585 throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");
586
587 return new DictionaryEntry(Key, Value);
588 }
589 }
590
591 public object Key
592 {
593 get {
594 if (reader.reader == null)
595 throw new InvalidOperationException("ResourceReader is closed.");
596 if (index < 0)
597 throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");
598
599 return reader.cache [index].ResourceName;
600 }
601 }
602
603 public object Value
604 {
605 get {
606 if (reader.reader == null)
607 throw new InvalidOperationException("ResourceReader is closed.");
608 if (index < 0)
609 throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");
610 return reader.cache [index].ResourceValue;
611 }
612 }
613
614 public UnmanagedMemoryStream ValueAsStream
615 {
616 get {
617 if (reader.reader == null)
618 throw new InvalidOperationException("ResourceReader is closed.");
619 if (index < 0)
620 throw new InvalidOperationException("Enumeration has not started. Call MoveNext.");
621 return(reader.ResourceValueAsStream((string) Key, index));
622 }
623 }
624
625 public object Current
626 {
627 get {
628 /* Entry does the checking, no
629 * need to repeat it here
630 */
631 return Entry;
632 }
633 }
634
635 public bool MoveNext ()
636 {
637 if (reader.reader == null)
638 throw new InvalidOperationException("ResourceReader is closed.");
639 if (finished) {
640 return false;
641 }
642
643 if (++index < reader.resourceCount){
644 return true;
645 }
646
647 finished=true;
648 return false;
649 }
650
651 public void Reset () {
652 if (reader.reader == null)
653 throw new InvalidOperationException("ResourceReader is closed.");
654 index = -1;
655 finished = false;
656 }
657
658 void FillCache ()
659 {
660 if (reader.cache != null)
661 return;
662
663 lock (reader.cache_lock) {
664 if (reader.cache != null)
665 return;
666
667 ResourceCacheItem[] resources = new ResourceCacheItem [reader.resourceCount];
668 reader.LoadResourceValues (resources);
669 reader.cache = resources;
670 }
671 }
672 } // internal class ResourceEnumerator
673 } // public sealed class ResourceReader
674 } // namespace System.Resources
git-svn mirror of mcs