C# FileIOPermission.PermitOnly方法代码示例

        public void FlatFileListenerWillFallbackIfNotPriviledgesToWrite()
        {
            string fileName = @"trace.log";
            string fullPath = String.Format(@"{0}\{1}", Directory.GetCurrentDirectory(), fileName);

            File.Delete(fileName);

            FileIOPermission fileIOPerm1 = new FileIOPermission(PermissionState.None);
            fileIOPerm1.SetPathList(FileIOPermissionAccess.Read, fullPath);
            fileIOPerm1.PermitOnly();

            try
            {
                FlatFileTraceListener listener = new FlatFileTraceListener(fileName, "---header---", "***footer***",
                    new TextFormatter("DUMMY{newline}DUMMY"));

                // need to go through the source to get a TraceEventCache
                LogSource source = new LogSource("notfromconfig", new[] { listener }, SourceLevels.All);
                source.TraceData(TraceEventType.Error, 0,
                    new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null));
                listener.Dispose();
            }
            catch (SecurityException)
            {
                FileIOPermission.RevertAll();
                throw;
            }
        }

        private void InThread(ControllerContext context, Action<ControllerContext> functor)
        {
            var timeout = int.Parse(ConfigurationManager.AppSettings["SandboxTimeout"] ?? "5");
            var thread = new Thread(()=>
            {
                try
                {
                    var fileIo = new FileIOPermission(FileIOPermissionAccess.Read,AppDomain.CurrentDomain.BaseDirectory);
                    fileIo.AllLocalFiles = FileIOPermissionAccess.NoAccess;
                    fileIo.PermitOnly();

                    functor(context);
                }
                catch(Exception e)
                {
                    // 全部書きだす
                    context.HttpContext.Response.Write(e.Message);
                }
            });
            thread.Start();
            thread.Join(timeout*1000);
            if(thread.IsAlive)
            {
                thread.Abort();
                throw new HttpException((int)HttpStatusCode.InternalServerError, "処理が長すぎ(" + timeout + "秒で終わらせてね)");
            }
        }

        /*
                Method:     RemoveAssembly
                Purpose:    Attempts to delete an assembly from the servers disk
                cache.
            */

        public static void RemoveAssembly(string version, string assemblyFileName)
        {
            var assemblyRoot = ServerSettings.AssemblyPath;
            version = new Version(version).ToString(3);

            var path = new DirectoryInfo(assemblyRoot + "\\" + version);
            if (!path.Exists)
                return;

            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, new[] { assemblyRoot + "\\" + version });
            try
            {
                permission.PermitOnly();
                if (File.Exists(assemblyRoot + "\\" + version + "\\" + assemblyFileName))
                    File.Delete(assemblyRoot + "\\" + version + "\\" + assemblyFileName);
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }
        }

        /*
        Method:     LoadAssembly
        Purpose:    Grabs an assembly off the disk and returns it as a
        byte array.
    */

        public static byte[] LoadAssembly(string version, string assemblyFileName)
        {
            var assemblyRoot = ServerSettings.AssemblyPath;
            version = new Version(version).ToString(3);

            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, new[] { assemblyRoot + "\\" + version });
            byte[] bytes;
            try
            {
                permission.PermitOnly();

                using (var sourceStream = File.OpenRead(assemblyRoot + "\\" + version + "\\" + assemblyFileName))
                {
                    bytes = new byte[sourceStream.Length];
                    sourceStream.Read(bytes, 0, (int)sourceStream.Length);
                }
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }

            return bytes;
        }

        public IsolatedStorageFileStream(String path, FileMode mode, 
            FileAccess access, FileShare share, int bufferSize, 
            IsolatedStorageFile isf)
        { 
            if (path == null)
                throw new ArgumentNullException("path");
            Contract.EndContractBlock();
 
#if FEATURE_PAL
            if (s_BackSlash == null) 
                s_BackSlash = new String(System.IO.Path.DirectorySeparatorChar,1); 
#endif // FEATURE_PAL
 
            if ((path.Length == 0) || path.Equals(s_BackSlash))
                throw new ArgumentException(
                    Environment.GetResourceString(
                        "IsolatedStorage_Path")); 

            ulong oldFileSize=0, newFileSize; 
            bool fNewFile = false, fLock=false; 

            if (isf == null) 
            {
#if FEATURE_ISOSTORE_LIGHT
                throw new ArgumentNullException("isf");
#else // !FEATURE_ISOSTORE_LIGHT 
                m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain(); 
#endif // !FEATURE_ISOSTORE_LIGHT 
            }
 
            if (isf.Disposed)
                throw new ObjectDisposedException(null, Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));

 
            m_isf = isf;
 
            FileIOPermission fiop = 
                new FileIOPermission(FileIOPermissionAccess.AllAccess,
                    m_isf.RootDirectory); 

            fiop.Assert();
            fiop.PermitOnly();
 
            m_GivenPath = path;
            m_FullPath  = m_isf.GetFullPath(m_GivenPath); 
 
            RuntimeHelpers.PrepareConstrainedRegions();
            try { // for finally Unlocking locked store 

                // Cache the old file size if the file size could change
                // Also find if we are going to create a new file.
 
                switch (mode) {
                case FileMode.CreateNew:        // Assume new file 
#if FEATURE_ISOSTORE_LIGHT 
                    // We are going to call Reserve so we need to lock the store.
                    m_isf.Lock(ref fLock); 
#endif
                    fNewFile = true;
                    break;
 
                case FileMode.Create:           // Check for New file & Unreserve
                case FileMode.OpenOrCreate:     // Check for new file 
                case FileMode.Truncate:         // Unreserve old file size 
                case FileMode.Append:           // Check for new file
 
                    m_isf.Lock(ref fLock);      // oldFileSize needs to be
                                                // protected

                    try { 
#if FEATURE_ISOSTORE_LIGHT
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)(new FileInfo(m_FullPath).Length)); 
#else 
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)LongPathFile.GetLength(m_FullPath));
#endif 
                    } catch (FileNotFoundException) {
                        fNewFile = true;
                    } catch {
                    } 

                    break; 
 
                case FileMode.Open:             // Open existing, else exception
                    break; 

                default:
                    throw new ArgumentException(
                        Environment.GetResourceString( 
                            "IsolatedStorage_FileOpenMode"));
                } 
 
                if (fNewFile)
                    m_isf.ReserveOneBlock(); 

                try {
#if FEATURE_ISOSTORE_LIGHT
                    m_fs = new 
                        FileStream(m_FullPath, mode, access, share, bufferSize,
                            FileOptions.None, m_GivenPath, true); 
//.........这里部分代码省略.........

        /*
                Method:     SaveAssembly
                Purpose:    Attemps to save a byte array as an assembly on the
                servers disk cache.
            */

        public static void SaveAssembly(byte[] assemblyCode, string version, string assemblyFileName)
        {
            var assemblyRoot = ServerSettings.AssemblyPath;
            version = new Version(version).ToString(3);

            var path = new DirectoryInfo(assemblyRoot + "\\" + version);
            if (!path.Exists)
                path.Create();

            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess,
                new[] { assemblyRoot + "\\" + version });
            try
            {
                permission.PermitOnly();

                // Use CreateNew to create so we get an exception if the file already exists -- it never should
                using (
                    var targetStream = File.Open(assemblyRoot + "\\" + version + "\\" + assemblyFileName, FileMode.CreateNew))
                {
                    try
                    {
                        targetStream.Write(assemblyCode, 0, assemblyCode.Length);
                        targetStream.Close();
                    }
                    catch
                    {
                        targetStream.Close();

                        // If something happens, delete the file so we don't have
                        // a corrupted file hanging around
                        File.Delete(assemblyRoot + "\\" + version + "\\" + assemblyFileName);

                        throw;
                    }
                }
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }
        }

        /// <summary>
        ///  Saves the array of bytes given an assembly full name to
        ///  the private assembly cache.
        /// </summary>
        /// <param name="bytes">The bytes of the assembly.</param>
        /// <param name="fullName">The full name of the original assembly.</param>
        public void SaveOrganismBytes(byte[] bytes, string fullName)
        {
            var directory = AssemblyDirectory;
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var fileName = GetFileName(fullName);

            if (File.Exists(fileName))
            {
                return;
            }

            // Ensure that the caller can't pass us a name that actually makes this file get created somewhere else
            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess,
                                                  new[] {directory});

            try
            {
                permission.PermitOnly();

                var targetStream = File.Create(fileName);
                try
                {
                    targetStream.Write(bytes, 0, bytes.Length);
                }
                catch
                {
                    targetStream.Close();

                    // If something happens, delete the file so we don't have
                    // a corrupted file hanging around
                    File.Delete(fileName);

                    throw;
                }
                finally
                {
                    targetStream.Close();
                }
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }

            OnPacAssembliesChanged(new EventArgs());
        }

        /// <summary>
        ///  Save an assembly along with symbols given a full path to the
        ///  assembly and symbols to the cache.
        /// </summary>
        /// <param name="assemblyPath">A local path to the assembly.</param>
        /// <param name="symbolPath">A local path to the symbols.</param>
        /// <param name="fullName">The full name of the assembly.</param>
        public void SaveOrganismAssembly(string assemblyPath, string symbolPath, string fullName)
        {
            var directory = AssemblyDirectory;
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var fileName = GetFileName(fullName);
            var symName = Path.ChangeExtension(GetFileName(fullName), ".pdb");

            if (File.Exists(fileName))
            {
                return;
            }

            var reportPath = Path.Combine(GameConfig.ApplicationDirectory, Guid.NewGuid() + ".xml");
            var validAssembly = checkAssemblyWithReporting(assemblyPath, reportPath);

            if (validAssembly == 0)
            {
                throw OrganismAssemblyFailedValidationException.GenerateExceptionFromXml(reportPath);
            }

            if (File.Exists(reportPath))
            {
                File.Delete(reportPath);
            }

            var sourceStream = File.OpenRead(assemblyPath);
            FileStream symStream = null;
            try
            {
                if (!string.IsNullOrEmpty(symbolPath) && File.Exists(symbolPath))
                {
                    symStream = File.OpenRead(symbolPath);
                }
            }
            catch
            {
                // In case anything goes wrong with the symbols (access denied and others), we are good
            }

            // Ensure that the caller can't pass us a name that actually makes this file get created somewhere else
            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess,
                                                  new[] {directory});
            try
            {
                permission.PermitOnly();

                var targetStream = File.Create(fileName);
                try
                {
                    var bytes = new byte[65536];
                    int bytesRead;
                    while ((bytesRead = sourceStream.Read(bytes, 0, 65536)) > 0)
                    {
                        targetStream.Write(bytes, 0, bytesRead);
                    }
                }
                catch
                {
                    targetStream.Close();

                    // If something happens, delete the file so we don't have
                    // a corrupted file hanging around
                    File.Delete(fileName);

                    throw;
                }
                finally
                {
                    targetStream.Close();
                }

                if (symStream != null)
                {
                    try
                    {
                        targetStream = File.Create(symName);
                        try
                        {
                            var bytes = new byte[65536];
                            int bytesRead;
                            while ((bytesRead = symStream.Read(bytes, 0, 65536)) > 0)
                            {
                                targetStream.Write(bytes, 0, bytesRead);
                            }
                        }
                        catch
                        {
                            targetStream.Close();

//.........这里部分代码省略.........

        /// <summary>
        ///  Determine if the assembly with the given full name exists
        ///  within the PAC.
        /// </summary>
        /// <param name="fullName">The full name of the assembly to check for.</param>
        /// <returns>True if the assembly exists, false otherwise.</returns>
        public Boolean Exists(string fullName)
        {
            bool exists = false;
            var asmDir = Path.GetFullPath(AssemblyDirectory);

            // Make sure we can't be hacked to return whether files exist by only allowing our code
            // to access files in the assembly directory.
            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, new[] {asmDir});
            try
            {
                permission.PermitOnly();
                exists = File.Exists(GetFileName(fullName));
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }

            return exists;
        }

        /// <summary>
        ///  Blacklist a series of assemblies by setting their assemblies to zero length
        ///  files.  This is a way of ensuring that we don't load them again, or replace them
        ///  with fresh working copies because the file name gets reserved with an invalid assembly.
        /// </summary>
        /// <param name="assemblies">The assemblies to be blacklisted.</param>
        public void BlacklistAssemblies(string[] assemblies)
        {
            // Ensure that the caller can't pass us a name that actually makes this file get created somewhere else
            var permission = new FileIOPermission(FileIOPermissionAccess.AllAccess,
                                                  new[] {AssemblyDirectory});

            try
            {
                permission.PermitOnly();

                if (assemblies != null)
                {
                    foreach (var assembly in assemblies)
                    {
                        var fileName = GetFileName(assembly);
                        try
                        {
                            // Replace this file with a zero length file (or create one), so we won't get it again
                            using (var stream = File.Create(fileName))
                            {
                                stream.Close();
                            }
                        }
                        catch (Exception e)
                        {
                            Debug.WriteLine("Error blacklisting organism:");
                            ErrorLog.LogHandledException(e);
                        }
                    }
                }
            }
            finally
            {
                CodeAccessPermission.RevertPermitOnly();
            }
        }

 public static void Log1(string text)
 {
     FileIOPermission p = new FileIOPermission(PermissionState.Unrestricted);
     p.PermitOnly();
 }

        public IsolatedStorageFileStream(String path, FileMode mode, 
            FileAccess access, FileShare share, int bufferSize,  
            IsolatedStorageFile isf) 
        {
            if (path == null)
                throw new ArgumentNullException("path");

            if (s_BackSlash == null)
                s_BackSlash = new String(System.IO.Path.DirectorySeparatorChar,1);

            if ((path.Length == 0) || path.Equals(s_BackSlash))
                throw new ArgumentException(
                    Environment.GetResourceString(
                        "IsolatedStorage_path"));

            ulong oldFileSize=0, newFileSize;
            bool fNewFile = false, fLock=false;
            FileInfo fOld;
 
            if (isf == null)
            {
                m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain();
            }

            m_isf = isf;

            FileIOPermission fiop = 
                new FileIOPermission(FileIOPermissionAccess.AllAccess,
                    m_isf.RootDirectory);

            fiop.Assert();
            fiop.PermitOnly();

            m_GivenPath = path;
            m_FullPath  = m_isf.GetFullPath(m_GivenPath);

            try { // for finally Unlocking locked store

                // Cache the old file size if the file size could change
                // Also find if we are going to create a new file.
    
                switch (mode) {
                case FileMode.CreateNew:        // Assume new file
                    fNewFile = true;
                    break;
    
                case FileMode.Create:           // Check for New file & Unreserve
                case FileMode.OpenOrCreate:     // Check for new file
                case FileMode.Truncate:         // Unreserve old file size
                case FileMode.Append:           // Check for new file
    
                    m_isf.Lock();               // oldFileSize needs to be 
                                                // protected
                    fLock = true;               // Lock succeded

                    try {
                        fOld = new FileInfo(m_FullPath);
                        oldFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)fOld.Length);
                    } catch (FileNotFoundException) {
                            fNewFile = true;
                    } catch {
                    }
    
                    break;
    
                case FileMode.Open:             // Open existing, else exception
                    break;
    
                default:
                    throw new ArgumentException(
                        Environment.GetResourceString(
                            "IsolatedStorage_FileOpenMode"));
                }
    
                if (fNewFile)
                    m_isf.ReserveOneBlock();
    
                try {
                    m_fs = new 
                        FileStream(m_FullPath, mode, access, share, bufferSize, 
                            FileOptions.None, m_GivenPath, true);
                } catch {
    
                    if (fNewFile)
                        m_isf.UnreserveOneBlock();
    
                    throw;
                }
    
                // make adjustment to the Reserve / Unreserve state
    
                if ((fNewFile == false) &&
                    ((mode == FileMode.Truncate) || (mode == FileMode.Create)))
                {
                    newFileSize = IsolatedStorageFile.RoundToBlockSize((ulong)m_fs.Length);
        
                    if (oldFileSize > newFileSize)
                        m_isf.Unreserve(oldFileSize - newFileSize);
                    else if (newFileSize > oldFileSize)     // Can this happen ?
//.........这里部分代码省略.........

        /*
            Method:     SaveAssembly
            Purpose:    Attemps to save a byte array as an assembly on the
                        servers disk cache.
        */
        public void SaveAssembly(byte[] assemblyCode, string version, string assemblyFileName)
        {
            String assemblyRoot = ServerSettings.AssemblyPath;
            version = new Version(version).ToString(3);

            DirectoryInfo path = new DirectoryInfo(assemblyRoot + "\\" + version);
            if (!path.Exists)
                path.Create();

            FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, new string[] { assemblyRoot + "\\" + version });
            try {
                permission.PermitOnly();

                // Use CreateNew to create so we get an exception if the file already exists -- it never should
                string pathToAssembly = assemblyRoot + "\\" + version + "\\" + assemblyFileName;
                if (File.Exists(pathToAssembly)) {
                    throw new ApplicationException("an assembly with the same filename already exists in the server");
                }
                using (FileStream targetStream = File.Open(pathToAssembly, FileMode.CreateNew)) {
                    try {
                        targetStream.Write(assemblyCode, 0, assemblyCode.Length);
                        targetStream.Close();
                    } catch {
                        targetStream.Close();

                        // If something happens, delete the file so we don't have
                        // a corrupted file hanging around
                        File.Delete(pathToAssembly);

                        throw;
                    }
                }
            } finally {
                CodeAccessPermission.RevertPermitOnly();
            }
        }

        public IsolatedStorageFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, IsolatedStorageFile isf)
        {
            if (path == null)
            {
                throw new ArgumentNullException("path");
            }
            if ((path.Length == 0) || path.Equals(@"\"))
            {
                throw new ArgumentException(Environment.GetResourceString("IsolatedStorage_Path"));
            }
            ulong num = 0L;
            bool flag = false;
            bool locked = false;
            if (isf == null)
            {
                this.m_OwnedStore = true;
                isf = IsolatedStorageFile.GetUserStoreForDomain();
            }
            if (isf.Disposed)
            {
                throw new ObjectDisposedException(null, Environment.GetResourceString("IsolatedStorage_StoreNotOpen"));
            }
            this.m_isf = isf;
            FileIOPermission permission = new FileIOPermission(FileIOPermissionAccess.AllAccess, this.m_isf.RootDirectory);
            permission.Assert();
            permission.PermitOnly();
            this.m_GivenPath = path;
            this.m_FullPath = this.m_isf.GetFullPath(this.m_GivenPath);
            RuntimeHelpers.PrepareConstrainedRegions();
            try
            {
                switch (mode)
                {
                    case FileMode.CreateNew:
                        flag = true;
                        break;

                    case FileMode.Create:
                    case FileMode.OpenOrCreate:
                    case FileMode.Truncate:
                    case FileMode.Append:
                        this.m_isf.Lock(ref locked);
                        try
                        {
                            num = IsolatedStorageFile.RoundToBlockSize((ulong) LongPathFile.GetLength(this.m_FullPath));
                        }
                        catch (FileNotFoundException)
                        {
                            flag = true;
                        }
                        catch
                        {
                        }
                        break;

                    case FileMode.Open:
                        break;

                    default:
                        throw new ArgumentException(Environment.GetResourceString("IsolatedStorage_FileOpenMode"));
                }
                if (flag)
                {
                    this.m_isf.ReserveOneBlock();
                }
                try
                {
                    this.m_fs = new FileStream(this.m_FullPath, mode, access, share, bufferSize, FileOptions.None, this.m_GivenPath, true, true);
                }
                catch
                {
                    if (flag)
                    {
                        this.m_isf.UnreserveOneBlock();
                    }
                    throw;
                }
                if (!flag && ((mode == FileMode.Truncate) || (mode == FileMode.Create)))
                {
                    ulong num2 = IsolatedStorageFile.RoundToBlockSize((ulong) this.m_fs.Length);
                    if (num > num2)
                    {
                        this.m_isf.Unreserve(num - num2);
                    }
                    else if (num2 > num)
                    {
                        this.m_isf.Reserve(num2 - num);
                    }
                }
            }
            finally
            {
                if (locked)
                {
                    this.m_isf.Unlock();
                }
            }
            CodeAccessPermission.RevertAll();
        }