示例#1
0
        /// <summary>
        /// Creates a new instance relative to the given parent
        /// </summary>
        /// <param name="parent">The parent storage</param>
        /// <param name="streamName">Path to stream under parent storage</param>
        /// <param name="compressionOption">CompressionOption</param>
        /// <param name="encryptionOption">EncryptionOption</param>
        internal StreamInfo(StorageInfo parent, string streamName, CompressionOption compressionOption,
                            EncryptionOption encryptionOption)
        {
            // Parameter validation
            CU.CheckAgainstNull(parent, "parent");
            CU.CheckStringAgainstNullAndEmpty(streamName, "streamName");

            // Parse path relative to given parent.
            BuildStreamInfoRelativeToStorage(parent,
                                             streamName);

            _compressionOption = compressionOption;
            _encryptionOption  = encryptionOption;
            _streamReference   = new CompoundFileStreamReference(this.parentStorage.FullNameInternal, this.core.streamName);
        }
示例#2
0
        /***********************************************************************/
        // Constructors

        private void BuildStreamInfoRelativeToStorage( StorageInfo parent, string path )
        {
            parentStorage = parent;
            core = parentStorage.CoreForChildStream( path );
        }
示例#3
0
 /// <summary>
 /// Creates a new instance relative to the given parent
 /// </summary>
 /// <param name="parent">The parent storage</param>
 /// <param name="streamName">Path to stream under parent storage</param>
 internal StreamInfo(StorageInfo parent, string streamName) : this(parent, streamName, CompressionOption.NotCompressed, EncryptionOption.None)
 {
 }
    /// <summary>
    /// Destroys an element and removes the references ued internally.
    /// </summary>
    internal void DestroyElement( string elementNameInternal )
    {
        object deadElementWalking = core.elementInfoCores[ elementNameInternal ];
        // It's an internal error if we try to call this without first
        //  verifying that it is indeed there.
        Debug.Assert( null != deadElementWalking,
            "Caller should have already verified that there's something to delete.");

        // Can't delete if we're in read-only mode.  This catches some but not
        //  all invalid delete scenarios - anything else would come back as a
        //  COMException of some kind that will be caught and wrapped in an
        //  IOException in the try/catch below.
        if( FileAccess.Read == Root.OpenAccess )
        {
            throw new UnauthorizedAccessException(
                SR.Get(SRID.CanNotDeleteInReadOnly));
        }

        //Clean out the entry in dataspacemanager for stream transforms
        DataSpaceManager manager = Root.GetDataSpaceManager();
        if( null != manager )
        {
             if( deadElementWalking is StorageInfoCore )
            {
                //if the element getting deleted is a storage, make sure to delete all its children's references.
                string name = ((StorageInfoCore)deadElementWalking).storageName;
                StorageInfo stInfo = new StorageInfo(this, name);
                RemoveSubStorageEntryFromDataSpaceMap(stInfo);
            }
            else if( deadElementWalking is StreamInfoCore )
            {
                //if the element getting deleted is a stream, the container reference should be removed from dataspacemap of dataspace manager.
                manager.RemoveContainerFromDataSpaceMap(new CompoundFileStreamReference( FullNameInternal, elementNameInternal ));
            }
        }
        
        // Make the call to the underlying OLE mechanism to remove the element.            
        try
        {
            core.safeIStorage.DestroyElement( elementNameInternal );
        }
        catch( COMException e )
        {
            if( e.ErrorCode == SafeNativeCompoundFileConstants.STG_E_ACCESSDENIED )
            {
                throw new UnauthorizedAccessException(
                    SR.Get(SRID.CanNotDeleteAccessDenied),
                    e );
            }
            else
            {
                throw new IOException(
                    SR.Get(SRID.CanNotDelete),
                    e );
            }
        }

        // Invalidate enumerators
        InvalidateEnumerators();
        
        // Remove the now-meaningless name, which also signifies disposed status.
        if( deadElementWalking is StorageInfoCore )
        {
            StorageInfoCore deadStorageInfoCore = (StorageInfoCore)deadElementWalking;

            // Erase this storage's existence
            deadStorageInfoCore.storageName = null;
            if( null != deadStorageInfoCore.safeIStorage )
            {
                ((IDisposable) deadStorageInfoCore.safeIStorage).Dispose();
                deadStorageInfoCore.safeIStorage = null;
            }
        }
        else if( deadElementWalking is StreamInfoCore )
        {
            StreamInfoCore deadStreamInfoCore = (StreamInfoCore)deadElementWalking;

            // Erase this stream's existence
            deadStreamInfoCore.streamName = null;

            try
            {
                if (null != deadStreamInfoCore.exposedStream)
                {
                    ((Stream)(deadStreamInfoCore.exposedStream)).Close();
                }
            }
            catch(Exception e)
            {
                if(CriticalExceptions.IsCriticalException(e))
                {
                    // PreSharp Warning 56500
                    throw;
                }
                else
                {
                    // We don't care if there are any issues - 
                    //  the user wanted this stream gone anyway.
                }
            }

            deadStreamInfoCore.exposedStream = null;
            
            if( null != deadStreamInfoCore.safeIStream ) 
            {
                ((IDisposable) deadStreamInfoCore.safeIStream).Dispose();
                deadStreamInfoCore.safeIStream = null;
            }
        }
        
        // Remove reference for destroyed element
        core.elementInfoCores.Remove(elementNameInternal);
    }
 private StorageInfo CreateStorage(string name)
 {
     // Create new StorageInfo
     StorageInfo newSubStorage = new StorageInfo( this, name );
 
     // Make it real
     if( !newSubStorage.InternalExists(name) )
     {
         /* TBD
         if( !CU.IsValidCompoundFileName(name))
         {
             throw new IOException(
                     SR.Get(SRID.UnableToCreateStorage),
                     new COMException( 
                         SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), 
                         nativeCallErrorCode ));
             }
             */
         // It doesn't already exist, please create.
         StorageInfoCore newStorage = core.elementInfoCores[ name ] as StorageInfoCore;
         Invariant.Assert( null != newStorage);
 
         int nativeCallErrorCode = core.safeIStorage.CreateStorage(
                     name, 
                 (GetStat().grfMode & SafeNativeCompoundFileConstants.STGM_READWRITE_Bits)
                     | SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE,
                 0,
                 0,
             #pragma warning suppress 6506 // Invariant.Assert(null != newStorage)
             out newStorage.safeIStorage );
         if( SafeNativeCompoundFileConstants.S_OK != nativeCallErrorCode )
         {
             if( nativeCallErrorCode == SafeNativeCompoundFileConstants.STG_E_ACCESSDENIED )
             {
                 throw new UnauthorizedAccessException(
                         SR.Get(SRID.CanNotCreateAccessDenied),
                         new COMException( 
                         SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), 
                         nativeCallErrorCode ));
             }
             else
             {
                 throw new IOException(
                     SR.Get(SRID.UnableToCreateStorage),
                     new COMException( 
                         SR.Get(SRID.NamedAPIFailure, "IStorage.CreateStorage"), 
                         nativeCallErrorCode ));
             }
         }
 
         // Invalidate enumerators
         InvalidateEnumerators();
     }
     else
     {
         throw new IOException(SR.Get(SRID.StorageAlreadyExist));
     }
 
     // Return a reference
     return newSubStorage;
 }
  /// <summary>
 /// Checks if a storage exists by the passed name.
 /// </summary>
 /// <param name="name">Name of storage</param>
 /// <returns>Reference to new storage</returns>
 public bool SubStorageExists(string name)
 {
     StorageInfo storageInfo = new StorageInfo(this, name);
     return storageInfo.InternalExists(name);
 }
    /// <summary>
    /// Constructor for a StorageInfo given a parent StorageInfo and a name
    /// </summary>
    /// <param name="parent">Reference to the parent storage</param>
    /// <param name="fileName">filename for the new StorageInfo</param>
    internal StorageInfo( StorageInfo parent, string fileName )
    {
        CU.CheckAgainstNull( parent, "parent" );
        CU.CheckAgainstNull( fileName, "fileName" );

        BuildStorageInfoRelativeToStorage( parent,  fileName );
    }
 public PreviewImage(string fileName, StorageInfo storage)
     : base(fileName, storage)
 {
     ReadStructuredStorageFile();
 }
    /// <summary>
    /// Reads a data space map from the associated container, if such a thing
    /// is written to the file.
    /// </summary>
    void ReadDataSpaceMap()
    {    
        // See if there's even a data spaces storage
        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );
        StreamInfo dataSpaceMapStreamInfo = 
            new StreamInfo( dataSpaceStorage, DataSpaceMapTableName );

        if( dataSpaceStorage.StreamExists(DataSpaceMapTableName) )
        {
            // There is an existing data space mapping table to read.

            // Read the versioning information
            ReadDataSpaceVersionInformation(dataSpaceStorage);      
     
            // Check if its the correct version for reading
            ThrowIfIncorrectReaderVersion();

            // Read the data space mapping table
            using(Stream dataSpaceMapStream = dataSpaceMapStreamInfo.GetStream(FileMode.Open))
            {
                using(BinaryReader dataSpaceMapReader = 
                    new BinaryReader( dataSpaceMapStream, System.Text.Encoding.Unicode ))
                {
                    int headerLength = dataSpaceMapReader.ReadInt32();
                    int entryCount = dataSpaceMapReader.ReadInt32();

                    if (headerLength < KnownBytesInMapTableHeader || entryCount < 0)
                        throw new FileFormatException(SR.Get(SRID.CorruptedData));

                    int extraDataSize = headerLength - KnownBytesInMapTableHeader;

                    if( 0 < extraDataSize )
                    {
                        if (extraDataSize > AllowedExtraDataMaximumSize)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        _mapTableHeaderPreservation = dataSpaceMapReader.ReadBytes(extraDataSize);

                        if (_mapTableHeaderPreservation.Length != extraDataSize)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));
                    }

                    _dataSpaceMap.Capacity = entryCount;

                    int entryLength;
                    int bytesRead;
                    int totalBytesRead;

                    for( int i = 0; i < entryCount; i++ )
                    {
                        entryLength = dataSpaceMapReader.ReadInt32();

                        if (entryLength < 0)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        totalBytesRead = 4; // entryLength
                        // Read the container reference entry
                        CompoundFileReference entryRef = 
                            CompoundFileReference.Load( dataSpaceMapReader, out bytesRead );
                        checked { totalBytesRead += bytesRead; }

                        // Read data space string and add to data space mapping table
                        string label = CU.ReadByteLengthPrefixedDWordPaddedUnicodeString(dataSpaceMapReader, out bytesRead);
                        checked { totalBytesRead += bytesRead; }

                        _dataSpaceMap[entryRef] = label;

                        // Verify entryLength against what was actually read:
                        if (entryLength != totalBytesRead)
                        {
                            throw new IOException(SR.Get(SRID.DataSpaceMapEntryInvalid));
                        }
                    }
                }                    
            }
        }
    }
示例#10
0
 public BasicFileInfo(string fileName, StorageInfo storage)
     : base(fileName, storage)
 {
     ReadStructuredStorageFile();
 }
示例#11
0
        private void OpenStructuredStorageFile()
        {
            //int checkResult = IsStorageFile(FileName);
               IsInitialized = false;
               //if(checkResult == 0)
               //{
               // return;
               //}

               try
               {
            StorageRoot = GetStorageRoot(FileName);
               }
               catch(Exception ex)
               {
            Debug.WriteLine(ex.Message);
               }
        }
示例#12
0
 private void CloseStorageRoot(StorageInfo storageRoot)
 {
     InvokeStorageRootMethod(storageRoot, "Close");
 }
示例#13
0
        /// <summary>
        /// Creates a new instance relative to the given parent
        /// </summary>
        /// <param name="parent">The parent storage</param>
        /// <param name="streamName">Path to stream under parent storage</param>
        /// <param name="compressionOption">CompressionOption</param>
        /// <param name="encryptionOption">EncryptionOption</param>
        internal StreamInfo( StorageInfo parent, string streamName, CompressionOption compressionOption, 
            EncryptionOption encryptionOption )
        {
             // Parameter validation
            CU.CheckAgainstNull( parent, "parent" );
            CU.CheckStringAgainstNullAndEmpty( streamName, "streamName" );

            // Parse path relative to given parent.
            BuildStreamInfoRelativeToStorage( parent, 
                streamName);
            
             _compressionOption = compressionOption;
            _encryptionOption   = encryptionOption;
            _streamReference = new CompoundFileStreamReference(this.parentStorage.FullNameInternal, this.core.streamName);
        }
示例#14
0
 /// <summary>
 /// Creates a new instance relative to the given parent
 /// </summary>
 /// <param name="parent">The parent storage</param>
 /// <param name="streamName">Path to stream under parent storage</param>
 internal StreamInfo( StorageInfo parent, string streamName ) : this (parent, streamName, CompressionOption.NotCompressed, EncryptionOption.None)
 {
 }
    /// <summary>
    /// Internally visible constructor
    /// </summary>
    /// <param name="containerInstance">The container instance we're associated with</param>
    internal DataSpaceManager( StorageRoot containerInstance )
    {
        _associatedStorage = containerInstance;

        // Storage under which all data space information is stored.
        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );

        // Initialize internal data structures.
        //  
        _dataSpaceMap = new SortedList();
        _mapTableHeaderPreservation = new byte[0];
        _dataSpaceDefinitions = new Hashtable(CU.StringCaseInsensitiveComparer);
        _transformDefinitions = new Hashtable(CU.StringCaseInsensitiveComparer);
        _transformedStreams = new ArrayList();

        // Check to see if we have any data space information to read
        if (dataSpaceStorage.Exists)
        {
            // Read any existing data space mapping information from the container
            //  
            ReadDataSpaceMap();
            ReadDataSpaceDefinitions();
            ReadTransformDefinitions();
        }
        return; 
    }
    /// <summary>
    /// Internal method to get the StorageInfo where the transform instance
    /// data is stored.  This StorageInfo may not yet exist!
    /// </summary>
    /// <param name="transformLabel">Transform Label</param>
    /// <returns>StorageInfo pointing to transform instance data storage</returns>
    internal StorageInfo GetInstanceDataStorageOf( string transformLabel )
    {
        TransformInstance targetInstance = GetTransformInstanceOf( transformLabel );

        if( null == targetInstance.transformStorage )
        {
            //string name = DataSpaceStorageName + '\\' + TransformDefinitions + '\\' + transformLabel;
            
            //targetInstance.transformStorage  = new StorageInfo(_associatedStorage,name);

            StorageInfo dataSpaceStorage = new StorageInfo( _associatedStorage, DataSpaceStorageName );
            if (!dataSpaceStorage.Exists )
            {
                dataSpaceStorage.Create();
            }
            StorageInfo transformDefinition = new StorageInfo( dataSpaceStorage, TransformDefinitions );
            if (!transformDefinition.Exists)
            {
                transformDefinition.Create();
            }
            targetInstance.transformStorage  = new StorageInfo(transformDefinition,transformLabel);
        }
        return targetInstance.transformStorage;
    }
    /// <summary>
    /// Write the data space mapping table to underlying storage.
    /// </summary>
    void WriteDataSpaceMap()
    {
        ThrowIfIncorrectUpdaterVersion();

        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );
        StreamInfo dataSpaceMapStreamInfo = 
            new StreamInfo ( dataSpaceStorage, DataSpaceMapTableName );

        if( 0 < _dataSpaceMap.Count )
        {
            // Write versioning information
            StreamInfo versionStreamInfo = null;
            if (dataSpaceStorage.StreamExists( DataSpaceVersionName ) )
                versionStreamInfo = dataSpaceStorage.GetStreamInfo( DataSpaceVersionName );
            else
                versionStreamInfo = dataSpaceStorage.CreateStream( DataSpaceVersionName );
            Stream versionStream = versionStreamInfo.GetStream();
            _fileFormatVersion.SaveToStream(versionStream);
            versionStream.Close();

            // Create stream for write, overwrite any existing
            using(Stream dataSpaceMapStream = dataSpaceMapStreamInfo.GetStream(FileMode.Create))
            {
                using(BinaryWriter dataSpaceMapWriter =
                    new BinaryWriter( dataSpaceMapStream, System.Text.Encoding.Unicode ))
                {
                    // Write header 

                    // header length = our known size + preserved array size
                    dataSpaceMapWriter.Write( 
                        checked ((Int32) (KnownBytesInMapTableHeader + _mapTableHeaderPreservation.Length)));
                    // number of entries
                    dataSpaceMapWriter.Write(
                        _dataSpaceMap.Count );
                    // anything else we've preserved
                    dataSpaceMapWriter.Write(
                        _mapTableHeaderPreservation );

                    // Loop to write entries
                    foreach( CompoundFileReference o in _dataSpaceMap.Keys )
                    {
                        // determine the entry length
                        string label = (string)_dataSpaceMap[o];
                        int entryLength = CompoundFileReference.Save(o, null);

                        checked { entryLength += CU.WriteByteLengthPrefixedDWordPaddedUnicodeString(null, label); }

                        // length of entryLength itself
                        checked { entryLength += 4; }

                        // write out the entry length
                        dataSpaceMapWriter.Write((Int32) entryLength);

                        // Write out reference
                        CompoundFileReference.Save( o, dataSpaceMapWriter);

                        // Write out dataspace label
                        CU.WriteByteLengthPrefixedDWordPaddedUnicodeString(
                            dataSpaceMapWriter, label);
                    }
                }
            }
        }
        else
        {
            // data space map is empty, remove existing stream if there.
            if ( dataSpaceStorage.StreamExists( DataSpaceMapTableName ) )
                dataSpaceStorage.DeleteStream( DataSpaceMapTableName );
        }
    }
示例#18
0
    /// <summary>
    ///     Given a parent and a path under it, step through each of the path
    /// elements and create an intermediate StorageInfo at each step because
    /// a StorageInfo is only meaningful relative to its immediate parent -
    /// multi-step relations can't be represented.
    /// </summary>
    private void BuildStorageInfoRelativeToStorage( StorageInfo parent, string fileName )
    {

        parentStorage = parent;
        core = parent.CoreForChildStorage( fileName );
        rootStorage = parent.Root;
    }
    /// <summary>
    /// Read all data space definitions in one chunk.  To be replaced
    /// with on-demand reading mechanism.
    /// </summary>
    void ReadDataSpaceDefinitions()
    {
        ThrowIfIncorrectReaderVersion();

        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );
        StorageInfo dataSpaceDefinitionsStorage =
            new StorageInfo( dataSpaceStorage, DataSpaceDefinitionsStorageName );

        if( dataSpaceDefinitionsStorage.Exists )
        {
            // Fill in the Data Space Definitions hash table
            foreach( StreamInfo definitionStreamInfo in dataSpaceDefinitionsStorage.GetStreams())
            {
                // Open up the stream for this data space definition
                using(Stream definitionStream = definitionStreamInfo.GetStream(FileMode.Open))
                {
                    using(BinaryReader definitionReader = new BinaryReader( definitionStream, System.Text.Encoding.Unicode ))
                    {
                        // Read data space definition stream
                        int headerLength = definitionReader.ReadInt32();
                        int transformCount = definitionReader.ReadInt32();

                        if (headerLength < KnownBytesInDataSpaceDefinitionHeader || transformCount < 0)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        ArrayList transformLabels = new ArrayList(transformCount);
                        byte[] extraData = null;
                        int extraDataSize = headerLength - KnownBytesInDataSpaceDefinitionHeader;

                        if (extraDataSize > AllowedExtraDataMaximumSize)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        if (extraDataSize > 0)
                        {
                            extraData = definitionReader.ReadBytes(extraDataSize);

                            if (extraData.Length != extraDataSize)
                                throw new FileFormatException(SR.Get(SRID.CorruptedData));
                        }

                        // Read the array of strings that make up the transform stack
                        for( int i = 0; i < transformCount; i++ )
                        {
                            transformLabels.Add(
                                CU.ReadByteLengthPrefixedDWordPaddedUnicodeString( definitionReader ) );
                        }

                        // Add data space definition to table
                        SetDataSpaceDefinition( definitionStreamInfo.Name, new DataSpaceDefinition(transformLabels, extraData));
                    }
                }
            }
        }
    }
示例#20
0
    /// <summary>
    /// Returns the storage by the passed name.
    /// </summary>
    /// <param name="name">Name of storage</param>
    /// <returns>Reference to the storage</returns>
    public StorageInfo GetSubStorageInfo(string name)
    {
        //Find if this storage exists
        StorageInfo storageInfo = new StorageInfo(this, name);

        if (storageInfo.InternalExists(name))
        {
            return storageInfo;
        }
        else
        {
            throw new IOException(SR.Get(SRID.StorageNotExist));
        }
    }
    /// <summary>
    /// Write all data space definitions to underlying storage in one chunk.
    /// </summary>
    /// 
    // 
    void WriteDataSpaceDefinitions()
    {
        ThrowIfIncorrectUpdaterVersion();

        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );

        // 



        // Write out data space definitions
        if( 0 < _dataSpaceDefinitions.Count )
        {
            
            StorageInfo dataSpaceDefinitionsStorage =
                new StorageInfo(dataSpaceStorage, DataSpaceDefinitionsStorageName);
            dataSpaceDefinitionsStorage.Create();

            foreach( string name in _dataSpaceDefinitions.Keys )
            {
                StreamInfo singleDefinitionInfo =
                    new StreamInfo(dataSpaceDefinitionsStorage,name);

                using(Stream singleDefinition = singleDefinitionInfo.GetStream())
                {
                    using(BinaryWriter definitionWriter =new BinaryWriter( singleDefinition, System.Text.Encoding.Unicode ))
                    {
                        DataSpaceDefinition definition = (DataSpaceDefinition) _dataSpaceDefinitions[name];

                        int headerSize = KnownBytesInDataSpaceDefinitionHeader;

                        if (definition.ExtraData != null)
                        {
                            checked { headerSize += definition.ExtraData.Length; }
                        }
                        definitionWriter.Write( headerSize );
                        definitionWriter.Write( definition.TransformStack.Count );
                        if (definition.ExtraData != null)
                        {
                            definitionWriter.Write(definition.ExtraData);
                        }

                        foreach( object transformLabel in definition.TransformStack)
                        {
                            CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( 
                                definitionWriter, (string)transformLabel);
                        }
                    }
                }
            }
        }
    }
示例#22
0
    /// <summary>
    /// Deletes a storage recursively.
    /// </summary>
    /// <param name="name">Name of storage</param>
    public void DeleteSubStorage(string name)
    {
        CheckDisposedStatus();

         //check the arguments
        if( null == name )
            throw new ArgumentNullException("name");

        StorageInfo storageInfo = new StorageInfo(this, name);
        if (storageInfo.InternalExists(name))
        {
            InvalidateEnumerators();
            // Go ahead and delete "this" storage
            DestroyElement( name );
        }
        //We will not throw exceptions if the storage does not exist. This is to be consistent with Package.DeletePart.
    }
    /// <summary>
    /// Read all transform definitions in one chunk
    /// </summary>
    // 

    void ReadTransformDefinitions()
    {
        ThrowIfIncorrectReaderVersion();

        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );
        StorageInfo transformDefinitionsStorage =
            new StorageInfo( dataSpaceStorage, TransformDefinitions );

        if( transformDefinitionsStorage.Exists )
        {
            // Read transform definitions from file
            foreach( StorageInfo transformStorage in transformDefinitionsStorage.GetSubStorages() )
            {
                // Read from primary stream
                StreamInfo transformPrimary = new StreamInfo(
                    transformStorage, TransformPrimaryInfo );

                using(Stream transformDefinition = transformPrimary.GetStream(FileMode.Open))
                {
                    using(BinaryReader definitionReader = new BinaryReader( transformDefinition, System.Text.Encoding.Unicode ))
                    {
                        int headerLength = definitionReader.ReadInt32(); // We don't actually do anything with HeaderLen at the moment
                        int transformType = definitionReader.ReadInt32();

                        if (headerLength < 0)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        // Create a TransformInstance class using name from file
                        TransformInstance transformInstance =
                            new TransformInstance(transformType, CU.ReadByteLengthPrefixedDWordPaddedUnicodeString( definitionReader ) );

                        
                        int extraDataSize = checked ((int) (headerLength - transformDefinition.Position));

                        if (extraDataSize < 0)
                            throw new FileFormatException(SR.Get(SRID.CorruptedData));

                        if (extraDataSize > 0)
                        {
                            if (extraDataSize > AllowedExtraDataMaximumSize)
                                throw new FileFormatException(SR.Get(SRID.CorruptedData));

                            // Preserve the fields we don't know about.
                            byte[] extraData = definitionReader.ReadBytes(extraDataSize);

                            if (extraData.Length != extraDataSize)
                                throw new FileFormatException(SR.Get(SRID.CorruptedData));

                            transformInstance.ExtraData = extraData;
                        }

                        if( transformDefinition.Length > transformDefinition.Position )
                        {
                            // We have additional data in the primary instance data stream
                            int instanceDataSize = checked ((int)(transformDefinition.Length - transformDefinition.Position));
                            byte[] instanceData = new byte[instanceDataSize];
                            PackagingUtilities.ReliableRead(transformDefinition, instanceData, 0, instanceDataSize);

                            //build memory stream on the byte[] , and allow writes only if 
                            // FileAccess is Write or ReadWrite
                            MemoryStream instanceDataStream;
                            if (_associatedStorage.OpenAccess == FileAccess.Read)
                            {
                                //  NOTE: Building MemoryStream directly on top of
                                //  instanceData byte array because we want it to be
                                //  NOT resizable and NOT writable.                    
                                instanceDataStream = new MemoryStream(instanceData, false /* Not writable */);
                            }
                            else
                            {
                                // Copy additional data into a memory stream
                                //  NOTE: Not building MemoryStream directly on top of
                                //  instanceData byte array because we want it to be
                                //  resizable.                    
                                instanceDataStream = new MemoryStream();
                                instanceDataStream.Write( instanceData, 0, instanceDataSize );
                            }
                            instanceDataStream.Seek( 0, SeekOrigin.Begin );

                            // Dirty state should be tracked after the original data is read in from the disk into the memory stream
                            transformInstance.transformPrimaryStream = new DirtyStateTrackingStream(instanceDataStream);
                        }

                        transformInstance.transformStorage = transformStorage;

                        SetTransformDefinition( transformStorage.Name, transformInstance );
                    }
                }
            }
        }
    }
示例#24
0
    /// <summary>
    /// When a substorage is getting deleted, its references in the dataspacemanager's transform definition are removed.
    /// This is called recursively because the DeleteSubStorage deletes all its children by default.
    /// </summary>
    internal void RemoveSubStorageEntryFromDataSpaceMap(StorageInfo storageInfo)
    {
        StorageInfo[] subStorages = storageInfo.GetSubStorages();
        foreach(StorageInfo storage in subStorages)
        {
            //If this is a storage, call recursively till we encounter a stream. Then we can use that container (storage,stream) reference to remove from the
            // dataspace manager's data space map.
            RemoveSubStorageEntryFromDataSpaceMap(storage); //recursive call
        }

        //Now we have StorageInfo. Find if there is a stream underneath so a container can be used as reference in data space map of data spacemanager.
        StreamInfo[] streams = storageInfo.GetStreams();
        DataSpaceManager manager = Root.GetDataSpaceManager();
        foreach(StreamInfo stream in streams)
        {
            manager.RemoveContainerFromDataSpaceMap(new CompoundFileStreamReference( storageInfo.FullNameInternal, stream.Name ));
        }
    }
    /// <summary>
    /// Write out all transform definitions all at once
    /// </summary>
    /// 
    // 

    void WriteTransformDefinitions()
    {
        ThrowIfIncorrectUpdaterVersion();

        StorageInfo dataSpaceStorage = 
            new StorageInfo( _associatedStorage, DataSpaceStorageName );
        StorageInfo transformDefinitionsStorage =
            new StorageInfo( dataSpaceStorage, TransformDefinitions );

        // 



        if( 0 < _transformDefinitions.Count )
        {
            foreach( string transformDef in _transformDefinitions.Keys )
            {
                // 'transformDef' is the normalized label.  We need to dig a
                //  bit to retrieve the original transform label.
                string transformLabel = null;
                TransformInstance transformInstance = GetTransformInstanceOf( transformDef );
                Debug.Assert( transformInstance != null, "A transform instance should be available if its name is in the transformDefinitions hashtable");
                
                if( transformInstance.transformEnvironment != null )
                {
                    // We have a transform environment object - it has the transform label.
                    transformLabel = transformInstance.transformEnvironment.TransformLabel;
                }
                else
                {
                    // We don't have a transform environment object - we'll need to do a
                    //  more expensive reverse-lookup with the name manager.
                    transformLabel = transformDef;
                }

                // Now use transformLabel to create the storage.
                StorageInfo singleTransformStorage =
                    new StorageInfo( transformDefinitionsStorage, transformLabel );
                StreamInfo transformPrimaryInfo =
                    new StreamInfo( singleTransformStorage, TransformPrimaryInfo );

                using(Stream transformPrimary = transformPrimaryInfo.GetStream())
                {
                    using(BinaryWriter transformWriter = new BinaryWriter( transformPrimary, System.Text.Encoding.Unicode ))
                    {
                        // Header length size = Known (the number itself + identifier) +
                        //  to be calculated (length of type name)
                        int headerLength = checked (KnownBytesInTransformDefinitionHeader +
                                                CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( null, transformInstance.typeName));

                        if (transformInstance.ExtraData != null)
                        {
                            Debug.Assert(transformInstance.ExtraData.Length > 0);

                            checked { headerLength += transformInstance.ExtraData.Length; }
                        }

                        transformWriter.Write(headerLength);
                        
                        transformWriter.Write((int)TransformIdentifierTypes_PredefinedTransformName);
                        CU.WriteByteLengthPrefixedDWordPaddedUnicodeString( 
                            transformWriter, transformInstance.typeName);

                        // Write out the preserved unknown data if there are some
                        if (transformInstance.ExtraData != null)
                        {
                            transformWriter.Write(transformInstance.ExtraData);
                        }

                        if( null != transformInstance.transformPrimaryStream )
                        {
                            byte[] memoryBuffer = ((MemoryStream) ((DirtyStateTrackingStream) transformInstance.transformPrimaryStream).BaseStream).GetBuffer();
                            transformPrimary.Write( memoryBuffer, 0, memoryBuffer.Length );
                        }
                    }
                }
            }
        }
        else // No transform definitions
        {
            if ( transformDefinitionsStorage.Exists)
            {
                dataSpaceStorage.Delete(true, TransformDefinitions);
                //transformDefinitionStorage.Delete(true);
            }
        }
    }
示例#26
0
        /***********************************************************************/
        // Constructors

        private void BuildStreamInfoRelativeToStorage(StorageInfo parent, string path)
        {
            parentStorage = parent;
            core          = parentStorage.CoreForChildStream(path);
        }
 // When we know everything to put into a TransformInstance.
 internal TransformInstance( 
     int classType,
     string name, 
     IDataTransform instance, 
     TransformEnvironment environment, 
     Stream primaryStream, 
     StorageInfo storage )
 {
     typeName = name;
     transformReference = instance;
     transformEnvironment = environment;
     transformPrimaryStream = primaryStream;
     transformStorage = storage;
     _classType = classType;
 }
 /// <summary>
 /// Read the version information that specifies the minimum versions of the 
 /// DataSpaceManager software that can read, write, or update the data space 
 /// information in this file.
 /// </summary>
 /// <param name="dataSpaceStorage"></param>
 /// <exception cref="FileFormatException">
 /// If the format version information in the stream is corrupt.
 /// </exception>
 private void ReadDataSpaceVersionInformation(StorageInfo dataSpaceStorage)
 {      
     if (_fileFormatVersion == null)
     {
         if (dataSpaceStorage.StreamExists( DataSpaceVersionName ))
         {
             StreamInfo versionStreamInfo = dataSpaceStorage.GetStreamInfo( DataSpaceVersionName );
             using (Stream versionStream = versionStreamInfo.GetStream(FileMode.Open))
             {
                 _fileFormatVersion = FormatVersion.LoadFromStream(versionStream);
                                     
                 // Transform Identifier: we preserve casing, but do case-insensitive comparison
                 //Case-insensitive comparison. As per recommendations, we convert both strings
                 //to Upper case and then compare with StringComparison.Ordinal
                 if (!((IEqualityComparer) CU.StringCaseInsensitiveComparer).Equals(_fileFormatVersion.FeatureIdentifier,
                                    DataSpaceVersionIdentifier))
                 {
                     throw new FileFormatException(
                                         SR.Get(SRID.InvalidTransformFeatureName,
                                         _fileFormatVersion.FeatureIdentifier,
                                         DataSpaceVersionIdentifier));                       
                 }
                 // If we ever write this version number out again, we will want to record
                 // the fact that it was done by the current version of the Dataspace software.
                 _fileFormatVersion.WriterVersion = DataSpaceCurrentWriterVersion;
             }
         }
     }        
 }
 public StorageStreamBase(string fileName, StorageInfo storage)
     : base(fileName)
 {
     FileName = fileName;
        Storage = storage;
 }