Complete() private method

private Complete ( string filename, bool success ) : void
filename string
success bool
return void
        // Parameters:
        //  assertPermissions - If true, then we'll assert all required permissions.  Used by ClientSettingsConfigurationHost.
        //                      to allow low-trust apps to use ClientSettingsStore.
        static internal void StaticWriteCompleted(string streamName, bool success, object writeContext, bool assertPermissions)
        {
            WriteFileContext writeFileContext = (WriteFileContext)writeContext;
            bool             revertAssert     = false;

            if (assertPermissions)
            {
                // If asked to assert permissions, we will assert allAccess on the streamName, the temporary file
                // created by WriteContext, and also the directory itself.  The last one is needed because
                // WriteFileContext will call TempFileCollection.Dispose, which will remove a .tmp file it created.
                string           dir        = Path.GetDirectoryName(streamName);
                string[]         filePaths  = new string[] { streamName, writeFileContext.TempNewFilename, dir };
                FileIOPermission fileIOPerm = new FileIOPermission(FileIOPermissionAccess.AllAccess, AccessControlActions.View | AccessControlActions.Change, filePaths);
                fileIOPerm.Assert();
                revertAssert = true;
            }

            try {
                writeFileContext.Complete(streamName, success);
            }
            finally {
                if (revertAssert)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }
        }
Beispiel #2
0
        // This method doesn't really open the streamName for write.  Instead, using WriteFileContext
        // it opens a stream on a temporary file created in the same directory as streamName.
        internal static Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext)
        {
            if (string.IsNullOrEmpty(streamName))
            {
                throw new ConfigurationErrorsException(SR.Config_no_stream_to_write);
            }

            // Create directory if it does not exist.
            // Ignore errors, allow any failure to come when trying to open the file.
            string dir = Path.GetDirectoryName(streamName);

            if (!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
            }

            Stream           stream;
            WriteFileContext writeFileContext = null;

            try
            {
                writeFileContext = new WriteFileContext(streamName, templateStreamName);

                if (File.Exists(streamName))
                {
                    FileInfo       fi    = new FileInfo(streamName);
                    FileAttributes attrs = fi.Attributes;
                    if ((attrs & InvalidAttributesForWrite) != 0)
                    {
                        throw new IOException(SR.Format(SR.Config_invalid_attributes_for_write, streamName));
                    }
                }

                try
                {
                    stream = new FileStream(writeFileContext.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
                }
                catch (Exception e)
                {
                    // Wrap all exceptions so that we provide a meaningful filename - otherwise the end user
                    // will just see the temporary file name, which is meaningless.

                    throw new ConfigurationErrorsException(SR.Format(SR.Config_write_failed, streamName), e);
                }
            }
            catch
            {
                writeFileContext?.Complete(streamName, false);
                throw;
            }

            writeContext = writeFileContext;
            return(stream);
        }
Beispiel #3
0
        internal static void StaticWriteCompleted(string streamName, bool success, object writeContext, bool assertPermissions)
        {
            WriteFileContext context = (WriteFileContext)writeContext;
            bool             flag    = false;

            if (assertPermissions)
            {
                string   directoryName = Path.GetDirectoryName(streamName);
                string[] pathList      = new string[] { streamName, context.TempNewFilename, directoryName };
                new FileIOPermission(FileIOPermissionAccess.AllAccess, AccessControlActions.Change | AccessControlActions.View, pathList).Assert();
                flag = true;
            }
            try
            {
                context.Complete(streamName, success);
            }
            finally
            {
                if (flag)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }
        }
        // This method doesn't really open the streamName for write.  Instead, using WriteFileContext
        // it opens a stream on a temporary file created in the same directory as streamName.
        //
        // Parameters:
        //  assertPermissions - If true, then we'll assert all required permissions.  Used by ClientSettingsConfigurationHost.
        //                      to allow low-trust apps to use ClientSettingsStore.
        static internal Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions) {
            bool revertAssert = false;
            
            if (string.IsNullOrEmpty(streamName)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_no_stream_to_write));
            }

            // Create directory if it does not exist.
            // Ignore errors, allow any failure to come when trying to open the file.
            string dir = Path.GetDirectoryName(streamName);
            try {
                if (!Directory.Exists(dir)) {
                    // 





                    if (assertPermissions) {
                        new FileIOPermission(PermissionState.Unrestricted).Assert();
                        revertAssert = true;
                    }
                    
                    Directory.CreateDirectory(dir);
                }
            }
            catch {
            }
            finally {
                if (revertAssert) {
                    CodeAccessPermission.RevertAssert();
                }
            }

            Stream stream;
            WriteFileContext writeFileContext = null;
            revertAssert = false;

            if (assertPermissions) {
                // If we're asked to assert permission, we will assert allAccess on the directory (instead of just the file).
                // We need to assert for the whole directory because WriteFileContext will call TempFileCollection.AddExtension,
                // which will generate a temporary file and make a AllAccess Demand on that file.
                // Since we don't know the name of the temporary file right now, we need to assert for the whole dir.
                new FileIOPermission(FileIOPermissionAccess.AllAccess, dir).Assert();
                revertAssert = true;
            }

            try {
                writeFileContext = new WriteFileContext(streamName, templateStreamName);

                if (File.Exists(streamName)) {
                    FileInfo fi = new FileInfo(streamName);
                    FileAttributes attrs = fi.Attributes;
                    if ((int)(attrs & InvalidAttributesForWrite) != 0) {
                        throw new IOException(SR.GetString(SR.Config_invalid_attributes_for_write, streamName));
                    }
                }

                try {
                    stream = new FileStream(writeFileContext.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
                }
                // Wrap all exceptions so that we provide a meaningful filename - otherwise the end user
                // will just see the temporary file name, which is meaningless.
                catch (Exception e) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_write_failed, streamName), e);
                }
            }
            catch {
                if (writeFileContext != null) {
                    writeFileContext.Complete(streamName, false);
                }
                throw;
            }
            finally {
                if (revertAssert) {
                    CodeAccessPermission.RevertAssert();
                }
            }

            writeContext = writeFileContext;
            return stream;
        }
        // This method doesn't really open the streamName for write.  Instead, using WriteFileContext
        // it opens a stream on a temporary file created in the same directory as streamName.
        //
        // Parameters:
        //  assertPermissions - If true, then we'll assert all required permissions.  Used by ClientSettingsConfigurationHost.
        //                      to allow low-trust apps to use ClientSettingsStore.
        static internal Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions)
        {
            bool revertAssert = false;

            if (string.IsNullOrEmpty(streamName))
            {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_no_stream_to_write));
            }

            // Create directory if it does not exist.
            // Ignore errors, allow any failure to come when trying to open the file.
            string dir = Path.GetDirectoryName(streamName);

            try {
                if (!Directory.Exists(dir))
                {
                    //



                    if (assertPermissions)
                    {
                        new FileIOPermission(PermissionState.Unrestricted).Assert();
                        revertAssert = true;
                    }

                    Directory.CreateDirectory(dir);
                }
            }
            catch {
            }
            finally {
                if (revertAssert)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }

            Stream           stream;
            WriteFileContext writeFileContext = null;

            revertAssert = false;

            if (assertPermissions)
            {
                // If we're asked to assert permission, we will assert allAccess on the directory (instead of just the file).
                // We need to assert for the whole directory because WriteFileContext will call TempFileCollection.AddExtension,
                // which will generate a temporary file and make a AllAccess Demand on that file.
                // Since we don't know the name of the temporary file right now, we need to assert for the whole dir.
                new FileIOPermission(FileIOPermissionAccess.AllAccess, dir).Assert();
                revertAssert = true;
            }

            try {
                writeFileContext = new WriteFileContext(streamName, templateStreamName);

                if (File.Exists(streamName))
                {
                    FileInfo       fi    = new FileInfo(streamName);
                    FileAttributes attrs = fi.Attributes;
                    if ((int)(attrs & InvalidAttributesForWrite) != 0)
                    {
                        throw new IOException(SR.GetString(SR.Config_invalid_attributes_for_write, streamName));
                    }
                }

                try {
                    stream = new FileStream(writeFileContext.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
                }
                // Wrap all exceptions so that we provide a meaningful filename - otherwise the end user
                // will just see the temporary file name, which is meaningless.
                catch (Exception e) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_write_failed, streamName), e);
                }
            }
            catch {
                if (writeFileContext != null)
                {
                    writeFileContext.Complete(streamName, false);
                }
                throw;
            }
            finally {
                if (revertAssert)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }

            writeContext = writeFileContext;
            return(stream);
        }
 internal static Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions)
 {
     Stream stream;
     bool flag = false;
     if (string.IsNullOrEmpty(streamName))
     {
         throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_no_stream_to_write"));
     }
     string directoryName = Path.GetDirectoryName(streamName);
     try
     {
         if (!Directory.Exists(directoryName))
         {
             if (assertPermissions)
             {
                 new FileIOPermission(PermissionState.Unrestricted).Assert();
                 flag = true;
             }
             Directory.CreateDirectory(directoryName);
         }
     }
     catch
     {
     }
     finally
     {
         if (flag)
         {
             CodeAccessPermission.RevertAssert();
         }
     }
     WriteFileContext context = null;
     flag = false;
     if (assertPermissions)
     {
         new FileIOPermission(FileIOPermissionAccess.AllAccess, directoryName).Assert();
         flag = true;
     }
     try
     {
         context = new WriteFileContext(streamName, templateStreamName);
         if (File.Exists(streamName))
         {
             FileInfo info = new FileInfo(streamName);
             if ((info.Attributes & (FileAttributes.Hidden | FileAttributes.ReadOnly)) != 0)
             {
                 throw new IOException(System.Configuration.SR.GetString("Config_invalid_attributes_for_write", new object[] { streamName }));
             }
         }
         try
         {
             stream = new FileStream(context.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
         }
         catch (Exception exception)
         {
             throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_write_failed", new object[] { streamName }), exception);
         }
     }
     catch
     {
         if (context != null)
         {
             context.Complete(streamName, false);
         }
         throw;
     }
     finally
     {
         if (flag)
         {
             CodeAccessPermission.RevertAssert();
         }
     }
     writeContext = context;
     return stream;
 }
Beispiel #7
0
        internal static Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions)
        {
            Stream stream;
            bool   flag = false;

            if (string.IsNullOrEmpty(streamName))
            {
                throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_no_stream_to_write"));
            }
            string directoryName = Path.GetDirectoryName(streamName);

            try
            {
                if (!Directory.Exists(directoryName))
                {
                    if (assertPermissions)
                    {
                        new FileIOPermission(PermissionState.Unrestricted).Assert();
                        flag = true;
                    }
                    Directory.CreateDirectory(directoryName);
                }
            }
            catch
            {
            }
            finally
            {
                if (flag)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }
            WriteFileContext context = null;

            flag = false;
            if (assertPermissions)
            {
                new FileIOPermission(FileIOPermissionAccess.AllAccess, directoryName).Assert();
                flag = true;
            }
            try
            {
                context = new WriteFileContext(streamName, templateStreamName);
                if (File.Exists(streamName))
                {
                    FileInfo info = new FileInfo(streamName);
                    if ((info.Attributes & (FileAttributes.Hidden | FileAttributes.ReadOnly)) != 0)
                    {
                        throw new IOException(System.Configuration.SR.GetString("Config_invalid_attributes_for_write", new object[] { streamName }));
                    }
                }
                try
                {
                    stream = new FileStream(context.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
                }
                catch (Exception exception)
                {
                    throw new ConfigurationErrorsException(System.Configuration.SR.GetString("Config_write_failed", new object[] { streamName }), exception);
                }
            }
            catch
            {
                if (context != null)
                {
                    context.Complete(streamName, false);
                }
                throw;
            }
            finally
            {
                if (flag)
                {
                    CodeAccessPermission.RevertAssert();
                }
            }
            writeContext = context;
            return(stream);
        }
        // This method doesn't really open the streamName for write.  Instead, using WriteFileContext
        // it opens a stream on a temporary file created in the same directory as streamName.
        //
        // Parameters:
        //  assertPermissions - If true, then we'll assert all required permissions.  Used by ClientSettingsConfigurationHost.
        //                      to allow low-trust apps to use ClientSettingsStore.
        internal static Stream StaticOpenStreamForWrite(string streamName, string templateStreamName, ref object writeContext, bool assertPermissions)
        {
            bool revertAssert = false;

            if (string.IsNullOrEmpty(streamName))
            {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_no_stream_to_write));
            }

            // Create directory if it does not exist.
            // Ignore errors, allow any failure to come when trying to open the file.
            string dir = Path.GetDirectoryName(streamName);
            try
            {
                if (!Directory.Exists(dir))
                {
                    Directory.CreateDirectory(dir);
                }
            }
            catch
            {
            }

            Stream stream;
            WriteFileContext writeFileContext = null;

            try
            {
                writeFileContext = new WriteFileContext(streamName, templateStreamName);

                if (File.Exists(streamName))
                {
                    FileInfo fi = new FileInfo(streamName);
                    FileAttributes attrs = fi.Attributes;
                    if ((int)(attrs & InvalidAttributesForWrite) != 0)
                    {
                        throw new IOException(SR.GetString(SR.Config_invalid_attributes_for_write, streamName));
                    }
                }

                try
                {
                    stream = new FileStream(writeFileContext.TempNewFilename, FileMode.Create, FileAccess.Write, FileShare.Read);
                }
                // Wrap all exceptions so that we provide a meaningful filename - otherwise the end user
                // will just see the temporary file name, which is meaningless.
                catch (Exception e)
                {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_write_failed, streamName), e);
                }
            }
            catch
            {
                if (writeFileContext != null)
                {
                    writeFileContext.Complete(streamName, false);
                }
                throw;
            }

            writeContext = writeFileContext;
            return stream;
        }