public static void TakeOwnership(string FD)
 {
     try
     {
         var myProcToken = new AccessTokenProcess(Process.GetCurrentProcess().Id, TokenAccessType.TOKEN_ALL_ACCESS | TokenAccessType.TOKEN_ADJUST_PRIVILEGES);
         myProcToken.EnablePrivilege(new Microsoft.Win32.Security.TokenPrivilege(Microsoft.Win32.Security.TokenPrivilege.SE_TAKE_OWNERSHIP_NAME, true));
         SecurityIdentifier identifier = new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null);
         NTAccount identity = (NTAccount)identifier.Translate(typeof(NTAccount));
         if (File.Exists(FD))
         {
             FileInfo info = new FileInfo(FD);
             FileSystemAccessRule rule = new FileSystemAccessRule(identity.Value, FileSystemRights.FullControl, AccessControlType.Allow);
             FileSecurity accessControl = info.GetAccessControl(AccessControlSections.Owner);
             accessControl.SetOwner(new NTAccount(identity.Value));
             info.SetAccessControl(accessControl);
             accessControl.AddAccessRule(rule);
             info.SetAccessControl(accessControl);
         }
         if (Directory.Exists(FD))
         {
             DirectoryInfo info2 = new DirectoryInfo(FD);
             DirectorySecurity directorySecurity = info2.GetAccessControl(AccessControlSections.All);
             directorySecurity.SetOwner(identity);
             info2.SetAccessControl(directorySecurity);
             directorySecurity.AddAccessRule(new FileSystemAccessRule(identity, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow));
             info2.SetAccessControl(directorySecurity);
         }
         Clear(FD);
     }
     catch (Exception)
     {
     }
 }
Example #2
0
        public Tuple <int, string, bool> ACLParse(System.IO.DirectoryInfo directoryInfo)
        {
            string error        = string.Empty;
            int    aclId        = 0;
            bool   allInherited = true;

            try
            {
                var dirSecurity  = directoryInfo.GetAccessControl();
                var authRuleColl = dirSecurity.GetAccessRules(true, true, typeof(NTAccount));
                var acl          = new ACL();
                foreach (FileSystemAccessRule fsaRule in authRuleColl)
                {
                    if (!fsaRule.IsInherited)
                    {
                        allInherited = false;
                    }
                    var ace = new ACE(fsaRule);
                    var id  = _ACESet.GetId(ace);   // add this ace to the aceset;
                    acl.Add(ace, id);
                }
                acl.Seal();
                aclId = _ACLSet.GetId(acl);
            }
            catch (Exception ex)
            {
                error = ex.Message;
            }
            finally
            {
            }
            return(Tuple.Create(aclId, error, allInherited));
        }
Example #3
0
        /// <summary>
        /// 如果用户没有在权限列表中,则不能自动加入。
        /// </summary>
        /// <param name="pathname"></param>
        /// <param name="username"></param>
        /// <param name="power">FullControl | ReadOnly
        /// | Write | Modify</param>
        public static void AddPathPower(string pathname, string username, string power)
        {
            if (!System.IO.Directory.Exists(pathname))
            {
                System.IO.Directory.CreateDirectory(pathname);
            }
            DirectoryInfo dirinfo = new DirectoryInfo(pathname);

            if ((dirinfo.Attributes & FileAttributes.ReadOnly) != 0)
            {
                dirinfo.Attributes = FileAttributes.Normal;
            }

            //取得访问控制列表
            DirectorySecurity dirsecurity = dirinfo.GetAccessControl();

            switch (power)
            {
                case "FullControl":
                    dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow));
                    break;
                case "ReadOnly":
                    dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Read, AccessControlType.Allow));
                    break;
                case "Write":
                    dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Write, AccessControlType.Allow));
                    break;
                case "Modify":
                    dirsecurity.AddAccessRule(new FileSystemAccessRule(username, FileSystemRights.Modify, AccessControlType.Allow));
                    break;
            }
        }
Example #4
0
    public static FileStream openStreamForAtomicAppend(string name)
    {
#if !FIRST_PASS
        System.Security.AccessControl.FileSecurity security;
        if (System.IO.File.Exists(name))
        {
            System.IO.FileInfo file = new FileInfo(name);
            security = file.GetAccessControl();
        }
        else
        {
            System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(name)));
            var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
            security = new System.Security.AccessControl.FileSecurity();
            foreach (object ruleObject in parentSecurity)
            {
                var rule = ruleObject as FileSystemAccessRule;
                security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType));
            }

            security.SetAccessRuleProtection(false, false);
        }

        return(FileSystemAclExtensions.Create(new FileInfo(name), FileMode.Append, FileSystemRights.AppendData, FileShare.ReadWrite, 1, FileOptions.None, security));
#else
        return(null);
#endif
    }
        public override void Apply(Prison prison)
        {
            if (prison == null)
            {
                throw new ArgumentNullException("prison");
            }

            WindowsUsersAndGroups.AddUserToGroup(prison.User.UserName, prisonRestrictionsGroup);

            if (Directory.Exists(prison.PrisonHomePath))
            {
                prison.User.Profile.UnloadUserProfileUntilReleased();
                Directory.Delete(prison.PrisonHomePath, true);
            }

            Directory.CreateDirectory(prison.PrisonHomePath);

            DirectoryInfo deploymentDirInfo = new DirectoryInfo(prison.PrisonHomePath);
            DirectorySecurity deploymentDirSecurity = deploymentDirInfo.GetAccessControl();

            // Owner is important to account for disk quota
            SetDirectoryOwner(deploymentDirSecurity, prison);

            // Taking ownership of a file has to be executed with restore privilege enabled
            using (new ProcessPrivileges.PrivilegeEnabler(Process.GetCurrentProcess(), ProcessPrivileges.Privilege.Restore))
            {
                deploymentDirInfo.SetAccessControl(deploymentDirSecurity);
            }
        }
Example #6
0
        public void Checker()
        {
            while (Thread.CurrentThread.IsAlive)
            {
                Directory.CreateDirectory(@"\\nas.unil.ch\FBM\SYS\TEST");

                int x = 0;

                foreach (User user in listOfUsers)
                {
                    util.Log("Try for User : "******"\\nas.unil.ch\FBM\SYS\TEST");
                        DirectorySecurity dirSecurity = info.GetAccessControl();
                        dirSecurity.SetAccessRuleProtection(true, false);

                        dirSecurity.AddAccessRule(new FileSystemAccessRule(@"ad\" + user.Username, FileSystemRights.Write, AccessControlType.Allow));
                        Directory.SetAccessControl(@"\\nas.unil.ch\FBM\SYS\TEST", dirSecurity);
                        util.Log(user.Username + " exists", x);
                    }
                    catch
                    {
                        util.Log(user.Username + " doesn't exist", x);
                        util.LogError(user.Departement + " : " + user.Username);
                    }
                    x++;
                }
                Thread.CurrentThread.Abort();
            }
        }
        private void AddAccessRuleTo(FileSystemAccessRule accessRule, string path)
        {
            var pathInfo = new DirectoryInfo(path);
            if (pathInfo.Exists)
            {
                log.Trace("Adding access rule to path '{0}'", pathInfo.FullName);
                DirectorySecurity pathSecurity = pathInfo.GetAccessControl();
                pathSecurity.AddAccessRule(accessRule);

                ReplaceAllChildPermissions(pathInfo, pathSecurity);
            }
            else
            {
                DirectoryInfo parentInfo = pathInfo.Parent;
                if (parentInfo.Exists)
                {
                    log.Trace("Adding access rule to path '{0}' via parent '{1}'", pathInfo.FullName, parentInfo.FullName);
                    DirectorySecurity pathSecurity = parentInfo.GetAccessControl();
                    pathSecurity.AddAccessRule(accessRule);

                    Directory.CreateDirectory(pathInfo.FullName, pathSecurity);

                    ReplaceAllChildPermissions(pathInfo, pathSecurity);
                }
            }
        }
Example #8
0
        private void TestIfUserExistsInAD(List<User> listOfUsers)
        {
            Directory.CreateDirectory(@"\\nas.unil.ch\FBM\SYS\TEST");

            int x = 0;

            foreach (User user in listOfUsers)
            {
                mw.Log("Try for User : "******"\\nas.unil.ch\FBM\SYS\TEST");
                    DirectorySecurity dirSecurity = info.GetAccessControl();
                    dirSecurity.SetAccessRuleProtection(true, false);

                    dirSecurity.AddAccessRule(new FileSystemAccessRule(@"ad\" + user.Username, FileSystemRights.Write, AccessControlType.Allow));
                    Directory.SetAccessControl(@"\\nas.unil.ch\FBM\SYS\TEST", dirSecurity);
                    mw.Log(user.Username + " exists", x);
                }
                catch
                {
                    mw.Log(user.Username + " doesn't exist", x);
                    mw.LogError(user.Departement + " : " + user.Username);
                }
                x++;
            }
        }
Example #9
0
		private static void RemoveInheritablePermissons(string folderName)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(folderName);
			DirectorySecurity accessControl = directoryInfo.GetAccessControl();
			accessControl.SetAccessRuleProtection(true, false);
			directoryInfo.SetAccessControl(accessControl);
		}
Example #10
0
		private static void AddDirectorySecurity(string folderName, string account, FileSystemRights rights, InheritanceFlags inheritance, PropagationFlags propogation, AccessControlType controlType)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(folderName);
			DirectorySecurity accessControl = directoryInfo.GetAccessControl();
			accessControl.AddAccessRule(new FileSystemAccessRule(account, rights, inheritance, propogation, controlType));
			directoryInfo.SetAccessControl(accessControl);
		}
Example #11
0
 public static void RemoveDenyDelete()
 {
     var info = new DirectoryInfo( SpazFile.SaveFolder );
     var sec = info.GetAccessControl();
     sec.RemoveAccessRuleSpecific( MakeNewDenyDeleteRule() );
     info.SetAccessControl( sec );
 }
Example #12
0
    public static Stream open(string name, FileMode fileMode, FileAccess fileAccess)
    {
        if (VirtualFileSystem.IsVirtualFS(name))
        {
            return(VirtualFileSystem.Open(name, fileMode, fileAccess));
        }
        else if (fileMode == FileMode.Append)
        {
            System.Security.AccessControl.FileSecurity security;
            if (System.IO.File.Exists(name))
            {
                System.IO.FileInfo file = new FileInfo(name);
                security = file.GetAccessControl();
            }
            else
            {
                System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(name)));
                var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
                security = new System.Security.AccessControl.FileSecurity();
                foreach (object ruleObject in parentSecurity)
                {
                    var rule = ruleObject as FileSystemAccessRule;
                    security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType));
                }

                security.SetAccessRuleProtection(false, false);
            }

            return(FileSystemAclExtensions.Create(new FileInfo(name), FileMode.Append, FileSystemRights.AppendData, FileShare.ReadWrite, 1, FileOptions.None, security));
        }
        else
        {
            return(new FileStream(name, fileMode, fileAccess, FileShare.ReadWrite, 1, false));
        }
    }
Example #13
0
    public static FileStream createFile0(string path, FileMode fileMode, FileSystemRights fileSystemRights, FileShare fileShare, int bufferSize, FileOptions fileOptions)
    {
#if !FIRST_PASS
        System.Security.AccessControl.FileSecurity security = null;
        if (System.IO.File.Exists(path))
        {
            //If the file already exists, we simply retrieve the current security object and use that
            System.IO.FileInfo file = new FileInfo(path);
            security = file.GetAccessControl();
        }
        else
        {
            //If the file does not exist, it is a little bit more complicated.
            Console.Error.WriteLine($"Getting for directory: {path}");
            Console.Error.WriteLine($"Parent is: {System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path))}");
            System.IO.DirectoryInfo directory = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path)));
            Console.Error.WriteLine($"Getting security for: {System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(path))}");
            var parentSecurity = directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
            security = new System.Security.AccessControl.FileSecurity();
            foreach (object ruleObject in parentSecurity)
            {
                var rule = ruleObject as FileSystemAccessRule;
                security.AddAccessRule(new FileSystemAccessRule(rule.IdentityReference, rule.FileSystemRights, rule.AccessControlType));
            }
            security.SetAccessRuleProtection(false, false);
        }

        return(FileSystemAclExtensions.Create(new FileInfo(path), fileMode, fileSystemRights, fileShare, bufferSize, fileOptions, security));
#else
        return(null);
#endif
    }
Example #14
0
 public static void AddDirectorySecurity(string strPath, string Account, System.Security.AccessControl.FileSystemRights Rights, System.Security.AccessControl.AccessControlType ControlType)
 {
     System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(strPath);
     System.Security.AccessControl.DirectorySecurity accessControl = directoryInfo.GetAccessControl();
     accessControl.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule(Account, Rights, ControlType));
     directoryInfo.SetAccessControl(accessControl);
 }
Example #15
0
        public static bool GrantModifyAccessToFolder(string windowsAccountUserName,
            string folderName)
        {
            DirectoryInfo directory = null;
            DirectorySecurity directorySecurity = null;
            FileSystemAccessRule rule = null;

            try
            {

                if (windowsAccountUserName.Length < 1) { return false; }
                if (folderName.Length < 1) { return false; }
                if (!Directory.Exists(folderName)) { return false; }

                directory = new DirectoryInfo(folderName);

                directorySecurity = directory.GetAccessControl();

                rule = new FileSystemAccessRule(windowsAccountUserName,
                                                FileSystemRights.Modify,
                                                InheritanceFlags.None |
                                                InheritanceFlags.ContainerInherit |
                                                InheritanceFlags.ObjectInherit,
                                                PropagationFlags.None,
                                                AccessControlType.Allow);

                directorySecurity.SetAccessRule(rule);

                directory.SetAccessControl(directorySecurity);

                return true;

            }
            catch (Exception) { throw; }
        }
Example #16
0
        public static ActionResult SetRightAction(Session session)
        {
            try
            {
                string folder = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "digiCamControl");
                if (!Directory.Exists(folder))
                {
                    Directory.CreateDirectory(folder);
                }
                DirectoryInfo dInfo = new DirectoryInfo(folder);
                DirectorySecurity dSecurity = dInfo.GetAccessControl();
                SecurityIdentifier everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
                dSecurity.AddAccessRule(new FileSystemAccessRule(everyone, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow));
                dInfo.SetAccessControl(dSecurity);
                string cachfolder = Path.Combine(
                                    Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "digiCamControl", "Cache");
                if (Directory.Exists(cachfolder))
                {
                    Directory.Delete(cachfolder, true);
                }

            }
            catch (Exception ex)
            {
                session.Log("Set right error " + ex.Message);
            }
            return ActionResult.Success;
        }
Example #17
0
        public static void ProtectFolder(string folderToProtect, string accountFullAccessAllowed, string accountDenied, bool allowDeniedToList)
        {
            EnsureFolderExists(folderToProtect);

            var directoryInfo = new DirectoryInfo(folderToProtect);

            // Get a DirectorySecurity object that represents the current security settings.
            DirectorySecurity directorySecurity = directoryInfo.GetAccessControl();

            // Apply the account has FULL access to this folder
            directorySecurity.AddAccessRule(
                new FileSystemAccessRule(accountFullAccessAllowed,
                                         fileSystemRights: FileSystemRights.FullControl,
                                         inheritanceFlags:
                                             InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                                         propagationFlags: PropagationFlags.None,
                                         type: AccessControlType.Allow)
                );

            if (!string.IsNullOrEmpty(accountDenied))
            {
                // Other users can only list files
                if (allowDeniedToList)
                {
                    directorySecurity.AddAccessRule(
                        new FileSystemAccessRule(accountDenied, // Instead of just AccountUserNameWizUser
                                                 fileSystemRights: FileSystemRights.ListDirectory,
                                                 inheritanceFlags:
                                                     InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                                                 propagationFlags: PropagationFlags.None,
                                                 type: AccessControlType.Allow)
                        );
                }

                directorySecurity.AddAccessRule(
                    new FileSystemAccessRule(accountDenied,
                                             fileSystemRights:
                                                 FileSystemRights.Delete |
                                                 FileSystemRights.CreateFiles |
                                                 FileSystemRights.CreateDirectories |
                                                 FileSystemRights.AppendData |
                                                 FileSystemRights.ReadExtendedAttributes |
                                                 FileSystemRights.WriteExtendedAttributes |
                                                 FileSystemRights.ExecuteFile |
                    //                                         FileSystemRights.Traverse |
                                                 FileSystemRights.DeleteSubdirectoriesAndFiles |
                                                 FileSystemRights.WriteAttributes |
                                                 FileSystemRights.ChangePermissions |
                                                 FileSystemRights.TakeOwnership,

                                             inheritanceFlags:
                                                 InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                                             propagationFlags: PropagationFlags.None,
                                             type: AccessControlType.Deny)
                    );
            }

            // Set the new access settings.
            directoryInfo.SetAccessControl(directorySecurity);
        }
        private void GetDirectoryData(DirectoryInfo directoryInfo, DirectoryData parent)
        {
            // Get directory access control
            DirectorySecurity accessControl;
            try
            {
                accessControl = directoryInfo.GetAccessControl(AccessControlSections.Access);
            }
            catch (UnauthorizedAccessException ex)
            {
                OnErrorOccurred("Can't get access to directory " + directoryInfo.Name, ex);
                throw;
            }

            // Get current directory properties
            FileSystemObjectProperties properties = GetFileSystemObjectProperties(directoryInfo, accessControl);
            var directoryData = new DirectoryData(properties, parent);
            if (parent != null)
                parent.AddFileSystemObject(directoryData);
            OnGotNewFileSystemData(directoryData);

            // Get data for all nested files and directories
            foreach (DirectoryInfo directory in directoryInfo.GetDirectories())
            {
                if (_isAborted)
                    return;
                GetDirectoryData(directory, directoryData);
            }
            foreach (FileInfo file in directoryInfo.GetFiles())
            {
                if (_isAborted)
                    return;
                GetFileData(file, directoryData);
            }
        }
Example #19
0
		private static void AddFullAccessToDirectory(string user, string directoryPath)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);
			DirectorySecurity accessControl = directoryInfo.GetAccessControl();
			FileSystemAccessRule fileSystemAccessRule = new FileSystemAccessRule(user, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow);
			accessControl.AddAccessRule(fileSystemAccessRule);
			directoryInfo.SetAccessControl(accessControl);
		}
Example #20
0
        private void SetFolderPermission(string path)
        {
            var directoryInfo     = new System.IO.DirectoryInfo(path);
            var directorySecurity = directoryInfo.GetAccessControl();

            directorySecurity.AddAccessRule(new FileSystemAccessRule("ALL APPLICATION PACKAGES", FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.InheritOnly, AccessControlType.Allow));
            directoryInfo.SetAccessControl(directorySecurity);
        }
Example #21
0
 /// <summary>
 /// Opens up directory access for Everyone at FullAccess.
 /// </summary>
 /// <param name="path">Directory to updated.</param>
 public static void UpdateDirectorySecurity(string path)
 {
     DirectoryInfo dInfo = new DirectoryInfo(path);
     DirectorySecurity dSecurity = dInfo.GetAccessControl();
     dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
                             FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
     dInfo.SetAccessControl(dSecurity);
 }
    private static bool HasDirectoryPermissions(string path, IdentityReference identity, FileSystemRights permissions)
    {
      DirectoryInfo dirInfo = new DirectoryInfo(path);
      DirectorySecurity dirSecurity = dirInfo.GetAccessControl(AccessControlSections.All);
      AuthorizationRuleCollection rules = dirSecurity.GetAccessRules(true, true, typeof(NTAccount));

      return HasPermissions(rules, identity, permissions);
    }
Example #23
0
 public static bool CheckAccessRight(DirectoryInfo directory, FileSystemRights right)
 {
     var user = WindowsIdentity.GetCurrent();
     var p = new WindowsPrincipal(user);
     AuthorizationRuleCollection acl =
     directory.GetAccessControl().GetAccessRules(true, true, typeof(System.Security.Principal.SecurityIdentifier));
     return CheckAccessRight(user, p, acl, right);
 }
 public void ElevatePermissions(string directory)
 {
     var account = new NTAccount(WindowsIdentity.GetCurrent().Name);
     var existingDirectory = new DirectoryInfo(directory);
     var existingDirectorySecurity = existingDirectory.GetAccessControl();
     existingDirectorySecurity.SetOwner(account);
     existingDirectory.SetAccessControl(existingDirectorySecurity);
 }
Example #25
0
 public static bool SetFolderACL(String FolderPath, String UserName, FileSystemRights Rights, AccessControlType AllowOrDeny, InheritanceFlags Inherits, PropagationFlags PropagateToChildren, AccessControlModification AddResetOrRemove)
 {
     bool ret;
     DirectoryInfo folder = new DirectoryInfo(FolderPath);
     DirectorySecurity dSecurity = folder.GetAccessControl(AccessControlSections.All);
     FileSystemAccessRule accRule = new FileSystemAccessRule(UserName, Rights, Inherits, PropagateToChildren, AllowOrDeny); dSecurity.ModifyAccessRule(AddResetOrRemove, accRule, out ret);
     folder.SetAccessControl(dSecurity);
     return ret;
 }
Example #26
0
 private static void RemoveInheritablePermissions(string folderName)
 {
     DirectoryInfo info = new DirectoryInfo(folderName);
     DirectorySecurity dSecurity = info.GetAccessControl();
     const bool IsProtected = true;
     const bool PreserveInheritance = false;
     dSecurity.SetAccessRuleProtection(IsProtected, PreserveInheritance);
     info.SetAccessControl(dSecurity);
 }
Example #27
0
File: Utils.cs Project: niv/catflap
        public static void FixPermissions(string obj, bool recurse = true)
        {
            if (!Directory.Exists(obj))
                return;

            DirectoryInfo dInfo = new DirectoryInfo(obj);
            DirectorySecurity dSecurity = dInfo.GetAccessControl();
            ReplaceAllDescendantPermissionsFromObject(dInfo, dSecurity, recurse);
        }
Example #28
0
 public static bool mkdir(string path)
 {
     System.IO.Directory.CreateDirectory(path);
     DirectoryInfo info = new DirectoryInfo(path);
     System.Security.Principal.WindowsIdentity self = System.Security.Principal.WindowsIdentity.GetCurrent();
     System.Security.AccessControl.DirectorySecurity ds = info.GetAccessControl();
     ds.AddAccessRule(new FileSystemAccessRule(self.Name, FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.None, AccessControlType.Allow));
     info.SetAccessControl(ds);
     return true;
 }
Example #29
0
        public static void changeDirectoryPermissions(string path)
        {
            System.IO.DirectoryInfo di   = new System.IO.DirectoryInfo(path);
            FileSystemAccessRule    fsar = new FileSystemAccessRule(path, FileSystemRights.FullControl, AccessControlType.Allow);
            DirectorySecurity       ds   = null;

            ds = di.GetAccessControl();
            ds.AddAccessRule(fsar);
            di.SetAccessControl(ds); // nothing happens until you do this
        }
Example #30
0
 public static void HowToGrantAccess()
 {
     DirectoryInfo directoryInfo = new DirectoryInfo("TestDirectory");
     directoryInfo.Create();
     DirectorySecurity directorySecurity = directoryInfo.GetAccessControl();
     directorySecurity.AddAccessRule(
             new FileSystemAccessRule("everyone",
                 FileSystemRights.ReadAndExecute,
                 AccessControlType.Allow));
     directoryInfo.SetAccessControl(directorySecurity);
 }
        public override void Install(IDictionary stateSaver)
        {
            base.Install(stateSaver);

            // Fix Permissions
            var installDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Atmosphir");
            DirectoryInfo dInfo = new DirectoryInfo(installDir);
            DirectorySecurity dSecurity = dInfo.GetAccessControl();
            dSecurity.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), FileSystemRights.FullControl, InheritanceFlags.ObjectInherit | InheritanceFlags.ContainerInherit, PropagationFlags.NoPropagateInherit, AccessControlType.Allow));
            dInfo.SetAccessControl(dSecurity);
        }
Example #32
0
        public static string Add(string Path, string UserName, Roles Role)
        {
            try
            {
                DirectoryInfo dirinfo = new DirectoryInfo(Path);

                //ȡ�÷��ʿ����б�
                DirectorySecurity sec = dirinfo.GetAccessControl();
                switch (Role)
                {
                    case Roles.FullControl:
                        sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
                        break;
                    case Roles.Read:
                        sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Read, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
                        break;
                    case Roles.Write:
                        sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Write, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
                        break;
                    case Roles.Modify:
                        sec.AddAccessRule(new FileSystemAccessRule(UserName, FileSystemRights.Modify, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
                        break;
                }

                dirinfo.SetAccessControl(sec);
                return "OK";
            }
            catch (Exception ex)
            {
                return ex.Message;
            }

            //����

            //    * path Ҫ���� NTFS Ȩ�޵��ļ��С�
            //    * identity �û�����
            //    * rights FileSystemRights ����ֵΪ FileSystemRights.Read��FileSystemRights.Write��FileSystemRights.FullControl �ȣ������á�|�������Ȩ�޺�������

            //InheritanceFlags ָ����Щ����Ȩ�޼̳�

            //    * InheritanceFlags.ContainerInherit �¼��ļ���Ҫ�̳�Ȩ�ޡ�
            //    * InheritanceFlags.None �¼��ļ��С��ļ������̳�Ȩ�ޡ�
            //    * InheritanceFlags.ObjectInherit �¼��ļ�Ҫ�̳�Ȩ�ޡ�

            //�����ᵽ���ļ��С������ļ�������׼ȷ��˵��Ӧ���ǡ�����������Ҷ���󡱣���Ϊ�������������ļ��С��ļ������������������ط�������ע���Ȩ�ޡ�

            //PropagationFlags ��δ���Ȩ��

            //    * PropagationFlags.InheritOnly ���� path �����ã�ֻ�Ǵ������¼���
            //    * PropagationFlags.None �������ã����ȶ� path �����ã�Ҳ�������¼���
            //    * PropagationFlags.NoPropagateInherit ֻ�Ƕ� path �����ã����������¼���

            //PropagationFlags ֻ���� InheritanceFlags ��Ϊ None ʱ�������塣Ҳ����˵ InheritanceFlags ָ�����������ɽ���Ȩ�޼̳У����������� PropagationFlags ָ������δ�����ЩȨ�ޡ�
        }
Example #33
0
 /// <summary>
 /// Add a file system right to a directory
 /// </summary>
 /// 
 /// <param name="Path">Full path to directory</param>
 /// <param name="Account">UNC path to user profile</param>
 /// <param name="Rights">Desired file system rights</param>
 /// <param name="ControlType">Access control type</param>
 public static void AddSecurity(string Path, string Account, FileSystemRights Rights, AccessControlType ControlType)
 {
     // Create a new DirectoryInfo object
     DirectoryInfo dInfo = new DirectoryInfo(Path);
     // Get a DirectorySecurity object that represents the current security settings
     DirectorySecurity dSecurity = dInfo.GetAccessControl();
     // Add the FileSystemAccessRule to the security settings
     dSecurity.AddAccessRule(new FileSystemAccessRule(Account, Rights, ControlType));
     // Set the new access settings
     dInfo.SetAccessControl(dSecurity);
 }
Example #34
0
 public static void AllowPermissions(string userOrGroupNameWithDomainPrefix, DirectoryInfo directoryInfo, FileSystemRights rights)
 {
     DirectorySecurity dirSec = directoryInfo.GetAccessControl();
     FileSystemAccessRule newRule = new FileSystemAccessRule(userOrGroupNameWithDomainPrefix,
         rights,
         InheritanceFlags.ObjectInherit ^ InheritanceFlags.ContainerInherit,
         PropagationFlags.None, AccessControlType.Allow);
     dirSec.AddAccessRule(newRule);
     directoryInfo.SetAccessControl(dirSec);
     directoryInfo.Refresh();
 }
Example #35
0
 public static DirectoryInfo GetOrCreateApplicationTempFolder()
 {
     System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(GetDefaultApplicationTempFolder());
     if (!tmpPathDirInfo.Exists)
     {
         tmpPathDirInfo.Create();
         System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl();
         dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow));
         tmpPathDirInfo.SetAccessControl(dSecurity);
     }
     return(tmpPathDirInfo);
 }
Example #36
0
        public static void AddIUSRToWwwrootFolder(string path)
        {
            DirectoryInfo directoryInfo = new DirectoryInfo(path);
            DirectorySecurity directorySecurity = directoryInfo.GetAccessControl();

            directorySecurity.AddAccessRule(new FileSystemAccessRule(@"IUSR",FileSystemRights.ReadAndExecute,
                InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                PropagationFlags.None,
                AccessControlType.Allow));

            directoryInfo.SetAccessControl(directorySecurity);
        }
Example #37
0
        // 確定時の動作
        public override void Commit(System.Collections.IDictionary savedState)
        {
            // Alchemistディレクトリを取得する
            string dirName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "JAM\\Alchemist");

            var dirInfo = new DirectoryInfo(dirName);
            var dirSecurity = dirInfo.GetAccessControl();

            var rule = new FileSystemAccessRule("Users", FileSystemRights.CreateFiles |
                                                         FileSystemRights.Read |
                                                         FileSystemRights.Write |
                                                         FileSystemRights.Modify |
                                                         FileSystemRights.Delete |
                                                         FileSystemRights.ExecuteFile |
                                                         FileSystemRights.ListDirectory,
                InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                PropagationFlags.InheritOnly, AccessControlType.Allow);

            dirSecurity.AddAccessRule(rule);
            dirInfo.SetAccessControl(dirSecurity);

            #if OMOIKANE
            // 思兼使用時の処理
            string omoikanedirName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "JAM\\omoikane");

            var omoikanedirInfo = new DirectoryInfo(omoikanedirName);
            var omoikanedirSecurity = omoikanedirInfo.GetAccessControl();

            var omoikanerule = new FileSystemAccessRule("Users", FileSystemRights.CreateFiles |
                                                         FileSystemRights.Read |
                                                         FileSystemRights.Write |
                                                         FileSystemRights.Modify |
                                                         FileSystemRights.Delete |
                                                         FileSystemRights.ExecuteFile |
                                                         FileSystemRights.ListDirectory,
                InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                PropagationFlags.InheritOnly, AccessControlType.Allow);

            omoikanedirSecurity.AddAccessRule(omoikanerule);
            omoikanedirInfo.SetAccessControl(omoikanedirSecurity);
            #endif

            // InstallLocationを追加する
            string productId = savedState["ProductID"].ToString();
            RegistryKey applicationRegistry = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\" + productId, true);
            if (applicationRegistry != null)
            {
                applicationRegistry.SetValue("InstallLocation", savedState["TargetDir"].ToString());
                applicationRegistry.Close();
            }

            base.Commit(savedState);
        }
Example #38
0
        public void CopyElevated(string source, string dest)
        {
            if (!WinAPI.IsVista)
            {
                System.IO.File.Copy(source, dest);
                return;
            }
            var di           = new System.IO.DirectoryInfo(System.IO.Path.GetDirectoryName(dest));
            var security     = di.GetAccessControl();
            var fi           = new FileInfo(dest);
            var fileSecurity = fi.GetAccessControl();
            // Allow Users to Write.
            //SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null);
            //fileSecurity.AddAccessRule(new FileSystemAccessRule(sid, FileSystemRights.Write, AccessControlType.Allow));
            //fi.SetAccessControl(fileSecurity);
            var    rules   = security.GetAccessRules(true, true, typeof(System.Security.Principal.NTAccount));
            string message = string.Empty;

            foreach (var myacc in rules)
            {
                var acc = (FileSystemAccessRule)myacc;
                message += string.Format("IdentityReference: {0}\r\n", acc.IdentityReference.Value);
                message += string.Format("Access Control Type: {0}\r\n", acc.AccessControlType.ToString());
                message += string.Format("\t{0}\r\n", acc.FileSystemRights.ToString());
                //if ((acc.FileSystemRights & FileSystemRights.FullControl) == FileSystemRights.FullControl)
                //{
                //    Console.Write("FullControl");
                //}
                //if ((acc.FileSystemRights & FileSystemRights.ReadData) == FileSystemRights.ReadData)
                //{
                //    Console.Write("ReadData");
                //}
                //if ((acc.FileSystemRights & FileSystemRights.WriteData) == FileSystemRights.WriteData)
                //{
                //    Console.Write("WriteData");
                //}
                //if ((acc.FileSystemRights & FileSystemRights.ListDirectory) == FileSystemRights.ListDirectory)
                //{
                //    Console.Write("ListDirectory");
                //}
                //if ((acc.FileSystemRights & FileSystemRights.ExecuteFile) == FileSystemRights.ExecuteFile)
                //{
                //    Console.Write("ExecuteFile");
                //}
            }
            MessageBox.Show(message);
            //WindowsIdentity self = System.Security.Principal.WindowsIdentity.GetCurrent();
            //			 FileSystemAccessRule rule = new FileSystemAccessRule(
            //    self.Name,
            //    FileSystemRights.FullControl,
            //    AccessControlType.Allow);
        }
Example #39
0
 static public int GetAccessControl(IntPtr l)
 {
     try {
         System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l);
         var ret = self.GetAccessControl();
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Example #40
0
 static public int GetAccessControl__AccessControlSections(IntPtr l)
 {
     try {
         System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l);
         System.Security.AccessControl.AccessControlSections a1;
         checkEnum(l, 2, out a1);
         var ret = self.GetAccessControl(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Example #41
0
        /// <summary>
        /// Tao file dang text: doc, txt, html
        /// </summary>
        /// <param name="path">duong dan url</param>
        /// <param name="value">noi dung file</param>
        public static void WriteFile(string path, string value)
        {
            FileStream stream = null;

            try
            {
                stream = new FileStream(path, FileMode.Create);
                using (StreamWriter _sw = new StreamWriter(stream, Encoding.UTF8))
                {
                    _sw.WriteLine(value);
                    stream = null;
                }
            }
            finally
            {
                if (stream != null)
                {
                    stream.Dispose();
                }
            }

            try
            {
                System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(path);

                // Get a DirectorySecurity object that represents the
                // current security settings.
                DirectorySecurity dSecurity = dInfo.GetAccessControl();

                // Add the FileSystemAccessRule to the security settings.
                dSecurity.AddAccessRule(
                    new FileSystemAccessRule(
                        new System.Security.Principal.NTAccount("Everyone"),
                        FileSystemRights.DeleteSubdirectoriesAndFiles,
                        AccessControlType.Allow
                        )
                    );

                // Set the new access settings.
                dInfo.SetAccessControl(dSecurity);
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
            }
        }
Example #42
0
        static void Main(string[] args)
        {
            if (args.Length == 1 && args[0] == "INSTALLER")
            {
                System.IO.DirectoryInfo di   = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
                FileSystemAccessRule    fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow);
                DirectorySecurity       ds   = null;

                ds = di.GetAccessControl();
                ds.AddAccessRule(fsar);
                di.SetAccessControl(ds);

                Process.Start(Application.ExecutablePath);
                return;
            }

            Thread.Sleep(2000);
            Process[] runningProcesses = Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName);
            if (runningProcesses.Length == 1 || (args.Length == 1 && args[0] == "OVERRIDE_PROCESS_CHECK")) // if its just me or OVERRIDE is set, let me run!
            {
                //systray icon config
                components = new System.ComponentModel.Container();
                trayIcon   = new NotifyIcon(components)
                {
                    ContextMenuStrip = new ContextMenuStrip(),
                    Icon             = amber,
                    Text             = "PersistentHotspot loading..",
                    Visible          = true
                };
                trayIcon.ContextMenuStrip.Opening += ContextMenuStrip_Opening;
                trayIcon.MouseUp += trayIcon_MouseUp;

                if (Reg.auto_restart_hotspot > 0)
                {
                    timeWatch.Restart();
                }

                //Monitor hotspot thread
                var task = MonitorHotspot();
                HandleException(task);

                Updater.Run("PersistentHotspot");
                Application.Run();
            }
        }
Example #43
0
 public static DirectoryInfo GetOrCreateSessionTempFolder(string SessionID)
 {
     try
     {
         string tmpPath = System.IO.Path.Combine(GetOrCreateApplicationTempFolder().FullName, SessionID);
         System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(tmpPath);
         if (!tmpPathDirInfo.Exists)
         {
             tmpPathDirInfo.Create();
             System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl();
             dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow));
             tmpPathDirInfo.SetAccessControl(dSecurity);
         }
         return(tmpPathDirInfo);
     }
     catch
     {
     }
     return(new DirectoryInfo(System.IO.Path.GetTempPath()));
 }
Example #44
0
        static void Main(string[] args)
        {
            if (args.Length == 1 && args[0] == "INSTALLER")
            {
                System.IO.DirectoryInfo di   = new System.IO.DirectoryInfo(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
                FileSystemAccessRule    fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow);
                DirectorySecurity       ds   = null;

                ds = di.GetAccessControl();
                ds.AddAccessRule(fsar);
                di.SetAccessControl(ds);

                Process.Start(Application.ExecutablePath);
                return;
            }

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new NmapMT());
        }
Example #45
0
        public static void ClearApplicationTempFolder()
        {
            string tmpFolder = GetDefaultApplicationTempFolder();

            if (System.IO.Directory.Exists(tmpFolder))
            {
                try
                {
                    System.IO.Directory.Delete(tmpFolder, true);
                }
                catch (System.Security.SecurityException)
                {
                    System.IO.DirectoryInfo tmpPathDirInfo = new System.IO.DirectoryInfo(tmpFolder);
                    System.Security.AccessControl.DirectorySecurity dSecurity = tmpPathDirInfo.GetAccessControl();
                    try
                    {
                        bool tryModify = false;
                        dSecurity.ModifyAccessRule(System.Security.AccessControl.AccessControlModification.Reset, new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow), out tryModify);
                        if (tryModify)
                        {
                            tmpPathDirInfo.SetAccessControl(dSecurity);
                            tmpPathDirInfo.Delete(true);
                        }
                        else
                        {
                            dSecurity.AddAccessRule(new System.Security.AccessControl.FileSystemAccessRule("everyone", System.Security.AccessControl.FileSystemRights.FullControl, System.Security.AccessControl.InheritanceFlags.ObjectInherit | System.Security.AccessControl.InheritanceFlags.ContainerInherit, System.Security.AccessControl.PropagationFlags.None, System.Security.AccessControl.AccessControlType.Allow));
                            tmpPathDirInfo.SetAccessControl(dSecurity);
                            tmpPathDirInfo.Delete(true);
                        }
                    }
                    catch
                    {
                    }
                }
                catch
                {
                }
            }
        }
Example #46
0
 public static void _report(string TAG, string logtxt)
 {
     try
     {
         var logfolder = AppDomain.CurrentDomain.BaseDirectory + "\\Log\\Report";
         System.IO.DirectoryInfo di   = new System.IO.DirectoryInfo(logfolder);
         FileSystemAccessRule    fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow);
         DirectorySecurity       ds   = null;
         if (!di.Exists)
         {
             Directory.CreateDirectory(logfolder);
         }
         ds = di.GetAccessControl();
         ds.AddAccessRule(fsar);
         StreamWriter sw = new StreamWriter(logfolder + "\\report" + DateTime.Today.ToString("yyyyMMdd") + ".txt", true);
         sw.WriteLine(string.Format(@"{0} [{1}] {2}", DateTime.Now.ToString(ConstantValues.FORMAT_DATE_TIME_MILISECONDS), TAG, logtxt));
         sw.Close();
         logtxt = string.Empty;
     }
     catch (Exception ex)
     {
         ex.ToString();
     }
 }
Example #47
0
 /// <summary>
 /// Gets a System.Security.AccessControl.DirectorySecurity object that encapsulates
 /// the access control list (ACL) entries for the directory described by the
 /// current System.IO.DirectoryInfo object.
 /// </summary>
 /// <returns>
 /// A System.Security.AccessControl.DirectorySecurity object that encapsulates
 /// the access control rules for the directory.
 /// </returns>
 /// <exception cref="System.SystemException">
 /// The directory could not be found or modified.
 /// </exception>
 /// <exception cref="System.UnauthorizedAccessException">
 /// The current process does not have access to open the directory.
 /// </exception>
 /// <exception cref="System.IO.IOException">
 /// An I/O error occurred while opening the directory.
 /// </exception>
 /// <exception cref="System.PlatformNotSupportedException">
 /// The current operating system is not Microsoft Windows 2000 or later.
 /// </exception>
 /// <exception cref="System.UnauthorizedAccessException">
 /// The directory is read-only.-or- This operation is not supported on the current
 /// platform.-or- The caller does not have the required permission.
 /// </exception>
 public DirectorySecurity GetAccessControl()
 {
     return(_directoryInfo.GetAccessControl());
 }
Example #48
0
        public void CompressFile()
        {
            //int waitTime;

            frmmain.currentCopyFile = "Prepare to create a Android Book...";
            ExportAPK("d");

            if (Directory.Exists(Path.Combine(Application.StartupPath, "tool\\book")) == false)
            {
                frmmain.completeCompile = false;
                MessageBox.Show("کتابساز با خطا مواجه شد.خطا ممکن است از اجرای نرم افزار جاوا باشد.\nلطفا نرم افزار را فعال و یا دوباره نصب کنید", "خطا", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            string xmlPath = Path.Combine(Application.StartupPath, "tool\\book\\AndroidManifest.xml");

            #region Permission
            try
            {
                frmmain.currentCopyFile = "Change Permission Folder";
                Thread.Sleep(300);
                System.IO.DirectoryInfo dInfo = new System.IO.DirectoryInfo(Path.Combine(Application.StartupPath, "tool\\book"));

                // Get a DirectorySecurity object that represents the
                // current security settings.
                DirectorySecurity dSecurity = dInfo.GetAccessControl();

                // Add the FileSystemAccessRule to the security settings.
                dSecurity.AddAccessRule(
                    new FileSystemAccessRule(
                        new System.Security.Principal.SecurityIdentifier(
                            System.Security.Principal.WellKnownSidType.BuiltinUsersSid,
                            null
                            ),
                        FileSystemRights.DeleteSubdirectoriesAndFiles,
                        //FileSystemRights.FullControl,
                        AccessControlType.Allow
                        )
                    );

                // Set the new access settings.
                dInfo.SetAccessControl(dSecurity);
            }
            catch (Exception e2)
            {
                File.AppendAllText(Application.StartupPath + "\\log.txt", e2.Message + "\r\n");
            }
            #endregion


            try
            {
                foreach (string file in files)
                {
                    try
                    {
                        if (file.EndsWith("Thumbs.db"))
                        {
                            continue;
                        }
                        File.Copy(file, Path.Combine(Path.Combine(Application.StartupPath, "tool\\book\\assets"), new FileInfo(file).Name), true);
                        frmmain.currentCopyFile = file;
                    }
                    catch (Exception e1)
                    {
                        frmmain.completeCompile = false;
                        File.AppendAllText(Application.StartupPath + "\\log.txt", e1.Message + "\r\n");
                        return;
                    }
                    Application.DoEvents();
                }
                if (Directory.Exists(Application.StartupPath + "\\" + sProjectName + "\\lib"))
                {
                    string[] Libfile = Directory.GetFiles(Application.StartupPath + "\\" + sProjectName + "\\lib");
                    foreach (string Libfile1 in Libfile)
                    {
                        try
                        {
                            File.Copy(Libfile1, Path.Combine(Application.StartupPath + "\\tool\\book\\assets", new FileInfo(Libfile1).Name), true);
                            frmmain.currentCopyFile = "Copy Library File: " + Libfile1;
                            Thread.Sleep(300);
                        }
                        catch (Exception e1)
                        {
                            File.AppendAllText(Application.StartupPath + "\\log.txt", e1.Message + "\r\n");
                        }
                        Application.DoEvents();
                    }
                }

                if (File.Exists(Path.Combine(Application.StartupPath + "\\" + sProjectName, "icon.png")))
                {
                    File.Copy(Path.Combine(Application.StartupPath + "\\" + sProjectName, "icon.png"), Path.Combine(Application.StartupPath + "\\tool\\book\\res\\drawable", "icon.png"), true);
                    frmmain.currentCopyFile = Application.StartupPath + "\\" + sProjectName + "\\icon.png";
                }

                if (TypeBook == 1)
                {
                    File.WriteAllText(Application.StartupPath + "\\tool\\book\\assets\\short_book", "");
                }

                #region write manifest file
                XmlDocument doc = new XmlDocument();
                doc.Load(Path.Combine(Application.StartupPath + "\\tool\\book", "AndroidManifest.xml"));

                if (sVersions.Length < 3)
                {
                    sVersions = "1.0.0";
                }

                XmlNode versionNode = doc.SelectSingleNode(@"manifest");
                versionNode.Attributes["package"].InnerText             = "student." + sProjectName;
                versionNode.Attributes["android:versionName"].InnerText = sVersions;
                versionNode.Attributes["android:versionCode"].InnerText = sVersions.Substring(0, 1);

                XmlNode LabelNode1 = doc.SelectSingleNode(@"manifest/application");
                LabelNode1.Attributes["android:label"].InnerText = sBookNames;

                XmlNodeList Activities = doc.SelectSingleNode(@"manifest/application").ChildNodes;

                for (int i = 0; i < Activities.Count; i++)
                {
                    XmlNode x1 = Activities[i];
                    if (x1.Name.ToLower() == "activity")
                    {
                        try
                        {
                            x1.Attributes["android:label"].InnerText = sBookNames;
                        }
                        catch (Exception)
                        {
                        }
                    }
                }

                doc.Save(Path.Combine(Application.StartupPath + "\\tool\\book", "AndroidManifest.xml"));
                #endregion

                Directory.Move(Application.StartupPath + "\\tool\\book\\smali\\student\\templatebook", Application.StartupPath + "\\tool\\book\\smali\\student\\" + sProjectName);

                frmmain.currentCopyFile = "Change Book Package Name";
                changeAPKPackage(sProjectName);
                frmmain.currentCopyFile = "Starting Compile...";

                ExportAPK("b");

                File.Copy(Application.StartupPath + "\\tool\\book\\dist\\book.apk", Application.StartupPath + "\\tool\\output\\book_out.apk", true);
                Directory.Delete(Application.StartupPath + "\\tool\\book", true);

                SignAPK();
                File.Delete(Application.StartupPath + "\\tool\\output\\book_out.apk");

                //Thread.Sleep(waitTime);
                frmmain.completeCompile = true;
                myClass.clearFolder(Application.StartupPath + "\\tool\\book");

                if (Directory.Exists(Application.StartupPath + "\\tool\\book"))
                {
                    Directory.Delete(Application.StartupPath + "\\tool\\book");
                }
            }
            catch (Exception)
            {
                frmmain.completeCompile = false;
            }
        }
Example #49
0
        // 点击安装按钮
        private void btnBegin_Click(object sender, EventArgs e)
        {
            if (!chkAgreeLicense.Checked)
            {
                DialogForm.Show("系统提示", "需勾选同意用户许可协议。", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            string targetPath = txtInstallPath.Text;

            try
            {
                // 1.检测路径
                Directory.CreateDirectory(targetPath);

                // 设置权限
                System.IO.DirectoryInfo di   = new System.IO.DirectoryInfo(targetPath);
                FileSystemAccessRule    fsar = new FileSystemAccessRule("Users", FileSystemRights.FullControl, AccessControlType.Allow);
                DirectorySecurity       ds   = di.GetAccessControl();
                ds.AddAccessRule(fsar);
                di.SetAccessControl(ds);

                InstallDir = targetPath;

                // 反安装记录
                this.uninstInfo.DestDir  = targetPath;
                this.uninstInfo.Manifest = new List <InstalledFiles>();

                // 1.1检测zip文件
                string zipfile = "Release.zip";
                if (!System.IO.File.Exists(zipfile))
                {
                    DialogForm.Show("系统提示", "安装包不完整, 操作中止。");

                    try
                    {
                        Directory.Delete(targetPath);
                    }
                    catch
                    {
                    }

                    return;
                }

                // 2.开始
                HideFirstPage();
                ShowSecendPage();

                // 2.1解压到目标
                ExtractFile(zipfile, targetPath);
            }
            catch (UnauthorizedAccessException uacEx)
            {
                logger.Error(uacEx.StackTrace);

                DialogForm.Show("系统提示", "无法将文件安装到你选定的目录,请尝试用管理员身份运行。");
            }
            catch (Exception ex)
            {
                logger.Error(ex.StackTrace);

                DialogForm.Show("系统提示", "无法将文件安装到你选定的目录,请检查路径是否正确或者是否拥有写权限。");
            }
        }
Example #50
0
 public System.Security.AccessControl.DirectorySecurity GetAccessControl()
 {
     return(inner.GetAccessControl());
 }
Example #51
-1
 public static void Add(string Path, string UserName, FileSystemRights Role)
 {
     DirectoryInfo dirinfo = new DirectoryInfo(Path);
     DirectorySecurity sec = dirinfo.GetAccessControl();
     sec.AddAccessRule(new FileSystemAccessRule(UserName, Role, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow));
     dirinfo.SetAccessControl(sec);
 }