コード例 #1
0
        EncryptedPackageEnvelope(
            Stream envelopeStream,
            PublishLicense publishLicense,
            CryptoProvider cryptoProvider
            )
        {
            if (envelopeStream == null)
            {
                throw new ArgumentNullException("envelopeStream");
            }

            ThrowIfRMEncryptionInfoInvalid(publishLicense, cryptoProvider);

            _root = StorageRoot.CreateOnStream(envelopeStream, _defaultFileModeForCreate);

            //
            // CreateOnStream opens the stream for read access if it's readable, and for
            // read/write access if it's writable. We're going to need it to be writable,
            // so check that it is.
            //
            if (_root.OpenAccess != FileAccess.ReadWrite)
            {
                throw new NotSupportedException(SR.StreamNeedsReadWriteAccess);
            }

            InitializeRMForCreate(publishLicense, cryptoProvider);
            EmbedPackage(null);
        }
コード例 #2
0
        EncryptedPackageEnvelope(
            string envelopeFileName,
            Stream packageStream,
            PublishLicense publishLicense,
            CryptoProvider cryptoProvider
            )
        {
            if (envelopeFileName == null)
            {
                throw new ArgumentNullException("envelopeFileName");
            }

            if (packageStream == null)
            {
                throw new ArgumentNullException("packageStream");
            }

            ThrowIfRMEncryptionInfoInvalid(publishLicense, cryptoProvider);

            _root = StorageRoot.Open(
                envelopeFileName,
                _defaultFileModeForCreate,
                _defaultFileAccess,
                _defaultFileShare
                );

            InitializeRMForCreate(publishLicense, cryptoProvider);
            EmbedPackage(packageStream);
        }
コード例 #3
0
        IsEncryptedPackageEnvelope(
            string fileName
            )
        {
            bool retval = false;

            if (fileName == null)
            {
                throw new ArgumentNullException("fileName");
            }

            StorageRoot root = null;

            try
            {
                //
                // When StorageRoot.Open is called on a file that is not a compound file,
                // it throws an IOException whose inner exception is a COMException whose
                // error code is 0x80030050, STG_E_FILEALREADYEXISTS. Check for that case
                // and return false because that means that this is not an RM-protected file.
                //
                // Any other exception is a real error. For example, StorageRoot.Open
                // throws FileNotFoundException if path does not exist, and we let that
                // flow through.
                //
                root = StorageRoot.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);

                //
                // It's a compound file. Does it contain an "EncryptedPackage" stream?
                //
                retval = ContainsEncryptedPackageStream(root);
            }
            catch (IOException ex)
            {
                COMException comException = ex.InnerException as COMException;
                if (comException != null && comException.ErrorCode == STG_E_FILEALREADYEXISTS)
                {
                    return(false);
                }

                throw;  // Any other kind of IOException is a real error.
            }
            finally
            {
                if (root != null)
                {
                    root.Close();
                }
            }

            return(retval);
        }
コード例 #4
0
        EncryptedPackageEnvelope(
            Stream envelopeStream
            )
        {
            if (envelopeStream == null)
            {
                throw new ArgumentNullException("envelopeStream");
            }

            _root = StorageRoot.CreateOnStream(envelopeStream, _defaultFileModeForOpen);

            InitForOpen();
        }
コード例 #5
0
        IsEncryptedPackageEnvelope(
            Stream stream
            )
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            bool        retval = false;
            StorageRoot root   = null;

            try
            {
                //
                // When StorageRoot.CreateOnStream is called on a stream that is not
                // a storage object, it throws an IOException whose inner exception is
                // a COMException whose error code is 0x80030050, STG_E_FILEALREADYEXISTS.
                // Check for that case and return false because that means that this
                // stream is not an RM-protected file.
                //
                // Any other exception is a real error.
                //
                root = StorageRoot.CreateOnStream(stream, FileMode.Open);

                //
                // It's a compound file. Does it contain an "EncryptedPackage" stream?
                //
                retval = ContainsEncryptedPackageStream(root);
            }
            catch (IOException ex)
            {
                COMException comException = ex.InnerException as COMException;
                if (comException != null && comException.ErrorCode == STG_E_FILEALREADYEXISTS)
                {
                    return(false);
                }

                throw;  // Any other kind of IOException is a real error.
            }
            finally
            {
                if (root != null)
                {
                    root.Close();
                }
            }

            return(retval);
        }
コード例 #6
0
        StorageBasedPackageProperties(
            StorageRoot root
            )
        {
            _pss = (IPropertySetStorage)root.GetRootIStorage();

            //
            // Open the property sets with the same access with which the file itself
            // was opened.
            //
            _grfMode = SafeNativeCompoundFileConstants.STGM_DIRECT
                        | SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
            SafeNativeCompoundFileMethods.UpdateModeFlagFromFileAccess(root.OpenAccess, ref _grfMode);

            OpenPropertyStorage(ref FormatId.SummaryInformation, out _psSummInfo);
            OpenPropertyStorage(ref FormatId.DocumentSummaryInformation, out _psDocSummInfo);
        }
コード例 #7
0
        EncryptedPackageEnvelope(
            string envelopeFileName,
            FileAccess access,
            FileShare sharing
            )
        {
            if (envelopeFileName == null)
            {
                throw new ArgumentNullException("envelopeFileName");
            }

            _root = StorageRoot.Open(
                envelopeFileName,
                _defaultFileModeForOpen,
                access,
                sharing
                );

            InitForOpen();
        }
コード例 #8
0
ファイル: StreamInfo.cs プロジェクト: wenzai007/dotnet462
 /// <summary>
 /// Creates a new instance relative to the root
 /// </summary>
 /// <param name="root">The root storage</param>
 /// <param name="streamPath">Path to stream under root storage</param>
 private StreamInfo(StorageRoot root, string streamPath) : this((StorageInfo)root, streamPath)
 {
 }
コード例 #9
0
 ContainsEncryptedPackageStream(
     StorageRoot root
     )
 {
     return((new StreamInfo(root, PackageStreamName)).InternalExists());
 }
コード例 #10
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;
    }
コード例 #11
0
    /// <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; 
    }
コード例 #12
0
ファイル: StreamInfo.cs プロジェクト: JianwenSun/cc
 /// <summary>
 /// Creates a new instance relative to the root
 /// </summary>
 /// <param name="root">The root storage</param>
 /// <param name="streamPath">Path to stream under root storage</param>
 private StreamInfo( StorageRoot root, string streamPath ) : this((StorageInfo)root, streamPath)
 {
 }
コード例 #13
0
 ContainsEncryptedPackageStream(
     StorageRoot root
     )
 { 
     return ((new StreamInfo(root, PackageStreamName)).InternalExists());
 } 
コード例 #14
0
ファイル: StorageRoot.cs プロジェクト: i-kostikov/wpf
        /// <summary>Open a container given all the settings</summary>
        /// <param name="path">Path to container on local file system</param>
        /// <param name="mode">See System.IO.FileMode in .NET SDK</param>
        /// <param name="access">See System.IO.FileAccess in .NET SDK</param>
        /// <param name="share">See System.IO.FileShare in .NET SDK</param>
        /// <param name="sectorSize">Compound File sector size, must be 512 or 4096</param>
        /// <returns>StorageRoot instance representing the file</returns>
        internal static StorageRoot Open(
            string path,
            FileMode mode,
            FileAccess access,
            FileShare share,
            int sectorSize)
        {
            int grfMode     = 0;
            int returnValue = 0;

            // Simple path validation
            ContainerUtilities.CheckStringAgainstNullAndEmpty(path, "Path");

            Guid IID_IStorage = new Guid(0x0000000B, 0x0000, 0x0000, 0xC0, 0x00,
                                         0x00, 0x00, 0x00, 0x00, 0x00, 0x46);

            IStorage newRootStorage;

            ////////////////////////////////////////////////////////////////////
            // Generate STGM from FileMode
            switch (mode)
            {
            case FileMode.Append:
                throw new ArgumentException(
                          SR.FileModeUnsupported);

            case FileMode.Create:
                grfMode |= SafeNativeCompoundFileConstants.STGM_CREATE;
                break;

            case FileMode.CreateNew:
            {
                FileInfo existTest = new FileInfo(path);
                if (existTest.Exists)
                {
                    throw new IOException(
                              SR.FileAlreadyExists);
                }
            }
                goto case FileMode.Create;

            case FileMode.Open:
                break;

            case FileMode.OpenOrCreate:
            {
                FileInfo existTest = new FileInfo(path);
                if (existTest.Exists)
                {
                    // File exists, use open code path
                    goto case FileMode.Open;
                }
                else
                {
                    // File does not exist, use create code path
                    goto case FileMode.Create;
                }
            }

            case FileMode.Truncate:
                throw new ArgumentException(
                          SR.FileModeUnsupported);

            default:
                throw new ArgumentException(
                          SR.FileModeInvalid);
            }

            // Generate the access flags from the access parameter
            SafeNativeCompoundFileMethods.UpdateModeFlagFromFileAccess(access, ref grfMode);

            // Generate STGM from FileShare

            // Note: the .NET SDK does not specify the proper behavior in reaction to
            //  incompatible flags being sent in together.  Should ArgumentException be
            //  thrown?  Or do some values "trump" others?
            if (0 != (share & FileShare.Inheritable))
            {
                throw new ArgumentException(
                          SR.FileShareUnsupported);
            }
            else if (share == FileShare.None) // FileShare.None is zero, using "&" to check causes unreachable code error
            {
                grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;
            }
            else if (share == FileShare.Read)
            {
                grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_WRITE;
            }
            else if (share == FileShare.Write)
            {
                grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_READ; // Note that this makes little sense when we don't support combination of flags
            }
            else if (share == FileShare.ReadWrite)
            {
                grfMode |= SafeNativeCompoundFileConstants.STGM_SHARE_DENY_NONE;
            }
            else
            {
                throw new ArgumentException(
                          SR.FileShareInvalid);
            }

            if (0 != (grfMode & SafeNativeCompoundFileConstants.STGM_CREATE))
            {
                // STGM_CREATE set, call StgCreateStorageEx.
                returnValue = SafeNativeCompoundFileMethods.SafeStgCreateStorageEx(
                    path,
                    grfMode,
                    stgFormatDocFile,
                    0,
                    IntPtr.Zero,
                    IntPtr.Zero,
                    ref IID_IStorage,
                    out newRootStorage);
            }
            else
            {
                // STGM_CREATE not set, call StgOpenStorageEx.
                returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageEx(
                    path,
                    grfMode,
                    stgFormatDocFile,
                    0,
                    IntPtr.Zero,
                    IntPtr.Zero,
                    ref IID_IStorage,
                    out newRootStorage);
            }

            switch (returnValue)
            {
            case SafeNativeCompoundFileConstants.S_OK:
                return(StorageRoot.CreateOnIStorage(
                           newRootStorage));

            case SafeNativeCompoundFileConstants.STG_E_FILENOTFOUND:
                throw new FileNotFoundException(
                          SR.ContainerNotFound);

            case SafeNativeCompoundFileConstants.STG_E_INVALIDFLAG:
                throw new ArgumentException(
                          SR.StorageFlagsUnsupported,
                          new COMException(
                              SR.CFAPIFailure,
                              returnValue));

            default:
                throw new IOException(
                          SR.ContainerCanNotOpen,
                          new COMException(
                              SR.CFAPIFailure,
                              returnValue));
            }
        }
コード例 #15
0
ファイル: StorageRoot.cs プロジェクト: i-kostikov/wpf
        /// <summary>
        /// Create a container StorageRoot based on the given System.IO.Stream object
        /// </summary>
        /// <param name="baseStream">The new Stream upon which to build the new StorageRoot</param>
        /// <param name="mode">The mode (Open or Create) to use on the lock bytes</param>
        /// <returns>New StorageRoot object built on the given Stream</returns>
        internal static StorageRoot CreateOnStream(Stream baseStream, FileMode mode)
        {
            if (null == baseStream)
            {
                throw new ArgumentNullException("baseStream");
            }

            IStorage storageOnStream;
            int      returnValue;
            int      openFlags = SafeNativeCompoundFileConstants.STGM_SHARE_EXCLUSIVE;

            if (baseStream.CanRead)
            {
                if (baseStream.CanWrite)
                {
                    openFlags |= SafeNativeCompoundFileConstants.STGM_READWRITE;
                }
                else
                {
                    openFlags |= SafeNativeCompoundFileConstants.STGM_READ;

                    if (FileMode.Create == mode)
                    {
                        throw new ArgumentException(
                                  SR.CanNotCreateContainerOnReadOnlyStream);
                    }
                }
            }
            else
            {
                throw new ArgumentException(
                          SR.CanNotCreateStorageRootOnNonReadableStream);
            }

            if (FileMode.Create == mode)
            {
                returnValue = SafeNativeCompoundFileMethods.SafeStgCreateDocfileOnStream(
                    baseStream,
                    openFlags | SafeNativeCompoundFileConstants.STGM_CREATE,
                    out storageOnStream);
            }
            else if (FileMode.Open == mode)
            {
                returnValue = SafeNativeCompoundFileMethods.SafeStgOpenStorageOnStream(
                    baseStream,
                    openFlags,
                    out storageOnStream);
            }
            else
            {
                throw new ArgumentException(
                          SR.CreateModeMustBeCreateOrOpen);
            }

            switch ((uint)returnValue)
            {
            case SafeNativeCompoundFileConstants.S_OK:
                return(StorageRoot.CreateOnIStorage(
                           storageOnStream));

            default:
                throw new IOException(
                          SR.UnableToCreateOnStream,
                          new COMException(
                              SR.CFAPIFailure,
                              returnValue));
            }
        }