[WMI实例]实现文件系统管理功能封装。提供共享文件和文件系统访问权限控制能力

/*

 * 实现文件系统管理功能封装。提供共享文件和文件系统访问权限控制能力。

 * 来源：思海网络（http://www.thinksea.com/）

 */

namespace Thinksea.Windows.FileSystem

{

    /// <summary>

    /// 共享资源类型。

    /// </summary>

    public enum ShareResourceType : uint

    {

        /// <summary>

        /// 磁盘驱动器

        /// </summary>

        DiskDrive = 0x0,

        PrintQueue = 0x1,

        Device = 0x2,

        IPC = 0x3,

        /// <summary>

        /// 为管理目的设置的磁盘驱动器共享。

        /// </summary>

        DiskDriveAdmin = 0x80000000,

        PrintQueueAdmin = 0x80000001,

        DeviceAdmin = 0x80000002,

        IPCAdmin = 0x80000003

    }



    /// <summary>

    /// 共享配置节。

    /// </summary>

    public class Share

    {

        /// <summary>

        /// 共享的目录路径。

        /// </summary>

        public string Path

        {

            get;

            set;

        }

        /// <summary>

        /// 共享名。

        /// </summary>

        public string Name

        {

            get;

            set;

        }

        private string _Description = null;

        /// <summary>

        /// 注释。

        /// </summary>

        public string Description

        {

            get

            {

                return this._Description;

            }

            set

            {

                this._Description = value;

            }

        }

        private ShareResourceType _Type = ShareResourceType.DiskDrive;

        /// <summary>

        /// 共享类型。

        /// </summary>

        public ShareResourceType Type

        {

            get

            {

                return this._Type;

            }

            set

            {

                this._Type = value;

            }

        }

        private int _MaximumAllowed = 0;

        /// <summary>

        /// 允许连接的最大用户数量。取值为 0 表示允许最多用户连接；否则设置为正整数表示允许连接的用户数量限制。

        /// </summary>

        public int MaximumAllowed

        {

            get

            {

                return this._MaximumAllowed;

            }

            set

            {

                this._MaximumAllowed = value;

            }

        }



        /// <summary>

        /// 一个构造方法。

        /// </summary>

        /// <param name="Path">共享的目录路径。</param>

        /// <param name="Name">共享名。</param>

        public Share(string Path, string Name)

        {

            this.Path = Path;

            this.Name = Name;

        }



        /// <summary>

        /// 一个构造方法。

        /// </summary>

        /// <param name="Path">共享的目录路径。</param>

        public Share(string Path)

        {

            this.Path = Path;

            this.Name = Path;

        }



    }



    /// <summary>

    /// 文件系统共享管理类。

    /// </summary>

    /// <example>

    /// <code>

    /// //获取指定目录的安全性设置

    ///string path = @"c:/testabc";

    ///AccessManagement fspm = new AccessManagement();

    ///AccessCollection dacl = fspm.GetPermission(path);

    ///foreach (var tmp in dacl)

    ///{

    ///    System.Console.WriteLine("[" + tmp.Domain + "]." + tmp.Name + ":" + tmp.SIDString);

    ///    System.Console.WriteLine("     " + tmp.AccessMask.ToString());

    ///    System.Console.WriteLine("     " + tmp.AceFlags.ToString());

    ///    System.Console.WriteLine("     " + tmp.AceType.ToString());

    ///}

    /// //允许用户 Everyone 持“完全访问权限”访问此目录。

    ///dacl.Clear();

    ///Access ace = new Access();

    ///ace.Name = "Everyone";

    ///ace.AccessMask = AccessPrivileges.AllAccess;

    ///ace.AceType = AccessType.AccessAllowed;

    ///dacl.Add(ace);

    ///fspm.SetPermission(path, dacl);

    /// </code>

    /// </example>

    public class ShareManagement

    {

        /// <summary>

        /// 获取指定名称的共享。

        /// </summary>

        /// <param name="ShareName">共享名称。</param>

        /// <returns>共享信息。找不到返回 null。</returns>

        public Share GetShare(string ShareName)

        {

            ShareName = ShareName.ToLower();

            System.Management.ManagementObjectSearcher searcher = new System.Management.ManagementObjectSearcher("SELECT * FROM Win32_share");

            foreach (System.Management.ManagementObject share in searcher.Get())

            {

                if (((string)share.GetPropertyValue("Name")).ToLower() == ShareName)

                {

                    Share s = new Share((string)share.GetPropertyValue("Path"), (string)share.GetPropertyValue("Name"));

                    s.Description = (string)share.GetPropertyValue("Description");

                    s.Type = (ShareResourceType)share.GetPropertyValue("Type");

                    if ((bool)share.GetPropertyValue("AllowMaximum"))

                    {

                        s.MaximumAllowed = 0;

                    }

                    else

                    {

                        s.MaximumAllowed = System.Convert.ToInt32(share.GetPropertyValue("MaximumAllowed"));

                    }

                    return s;

                }

            }

            return null;



        }



        /// <summary>

        /// 获取全部的共享信息。

        /// </summary>

        /// <returns>共享信息集合。</returns>

        public Share[] GetShares()

        {

            System.Collections.Generic.List<Share> l = new System.Collections.Generic.List<Share>();

            System.Management.ManagementObjectSearcher searcher = new System.Management.ManagementObjectSearcher("SELECT * FROM Win32_share");

            foreach (System.Management.ManagementObject share in searcher.Get())

            {

                Share s = new Share((string)share.GetPropertyValue("Path"), (string)share.GetPropertyValue("Name"));

                s.Description = (string)share.GetPropertyValue("Description");

                s.Type = (ShareResourceType)share.GetPropertyValue("Type");

                if ((bool)share.GetPropertyValue("AllowMaximum"))

                {

                    s.MaximumAllowed = 0;

                }

                else

                {

                    s.MaximumAllowed = System.Convert.ToInt32(share.GetPropertyValue("MaximumAllowed"));

                }

                l.Add(s);

                //l.Add(share.GetText(System.Management.TextFormat.Mof));

            }

            return l.ToArray();

        }



        /// <summary>

        /// 判断指定的共享是否存在。

        /// </summary>

        /// <param name="ShareName">共享名称。</param>

        /// <returns>存在返回 true；否则返回 false。</returns>

        public bool IsExistsShare(string ShareName)

        {

            ShareName = ShareName.ToLower();

            System.Management.ManagementObjectSearcher searcher = new System.Management.ManagementObjectSearcher("SELECT * FROM Win32_share");

            foreach (System.Management.ManagementObject share in searcher.Get())

            {

                if (((string)share.GetPropertyValue("Name")).ToLower() == ShareName)

                {

                    return true;

                }

            }

            return false;



        }



        /// <summary>

        /// 为指定的目录开启共享设置。

        /// </summary>

        /// <param name="sre">共享配置节</param>

        public void CreateShare(Share sre)

        {

            System.Management.ManagementClass mc = new System.Management.ManagementClass("win32_share");

            System.Management.ManagementBaseObject inParams = mc.GetMethodParameters("Create");

            inParams["Path"] = sre.Path;

            inParams["Name"] = sre.Name;

            inParams["Type"] = sre.Type;

            if (sre.MaximumAllowed == 0)

            {

                inParams["MaximumAllowed"] = null;      //null = 用户数连接无限制,否则指定一个正整数

            }

            else

            {

                inParams["MaximumAllowed"] = sre.MaximumAllowed;      //null = 用户数连接无限制,否则指定一个正整数

            }

            inParams["Description"] = sre.Description;

            inParams["Password"] = null;

            inParams["Access"] = null; //null = 使Everyone拥有完全控制权限



            System.Management.ManagementBaseObject outParams = mc.InvokeMethod("Create", inParams, null);

            switch ((uint)outParams.Properties["ReturnValue"].Value)

            {

                case 0: //Success

                    break;

                case 2: //Access denied 

                    throw new System.Exception("无权访问");

                case 8: //Unknown failure 

                    throw new System.Exception("未知失败");

                case 9: //Invalid name 

                    throw new System.Exception("非法的共享名");

                case 10: //Invalid level 

                    throw new System.Exception("非法的层次");

                case 21: //Invalid parameter 

                    throw new System.Exception("非法的参数");

                case 22: //Duplicate share

                    throw new System.Exception("重复共享");

                case 23: //Redirected path 

                    throw new System.Exception("重定向路径");

                case 24: //Unknown device or directory 

                    throw new System.Exception("未知的目录");

                case 25: //Net name not found 

                    throw new System.Exception("网络名不存在");

                default:

                    throw new System.Exception("未知异常信息");

            }



        }

        /// <summary>

        /// 取消共享指定目录。

        /// </summary>

        /// <param name="ShareName">共享名称。</param>

        public void DeleteShare(string ShareName)

        {

            System.Management.ManagementObject classInstance = new System.Management.ManagementObject(@"root/CIMV2", "Win32_Share.Name='" + ShareName + @"'", null);

            System.Management.ManagementBaseObject outParams = classInstance.InvokeMethod("Delete", null, null);

            switch ((uint)outParams.Properties["ReturnValue"].Value)

            {

                case 0: //Success

                    break;

                case 2: //Access denied 

                    throw new System.Exception("无权访问");

                case 8: //Unknown failure 

                    throw new System.Exception("未知失败");

                case 9: //Invalid name 

                    throw new System.Exception("非法的共享名");

                case 10: //Invalid level 

                    throw new System.Exception("非法的层次");

                case 21: //Invalid parameter 

                    throw new System.Exception("非法的参数");

                case 22: //Duplicate share

                    throw new System.Exception("重复共享");

                case 23: //Redirected path 

                    throw new System.Exception("重定向路径");

                case 24: //Unknown device or directory 

                    throw new System.Exception("未知的目录");

                case 25: //Net name not found 

                    throw new System.Exception("网络名不存在");

                default:

                    throw new System.Exception("未知异常信息");

            }



        }



    }



    /// <summary>

    /// 访问权限描述。

    /// </summary>

    [System.Flags]

    public enum AccessPrivileges : uint

    {

        /// <summary>

        /// 列出文件夹/读取数据

        /// </summary>

        FileReadData = 0x00000001,

        /// <summary>

        /// 创建文件/写入数据

        /// </summary>

        FileWriteData = 0x00000002,

        /// <summary>

        /// 创建文件夹/附加数据

        /// </summary>

        FileAppendData = 0x00000004,

        /// <summary>

        /// 读取扩展属性

        /// </summary>

        FileReadEA = 0x00000008,

        /// <summary>

        /// 写入扩展属性

        /// </summary>

        FileWriteEA = 0x00000010,

        /// <summary>

        /// 遍历文件夹/运行文件

        /// </summary>

        FileExecute = 0x00000020,

        /// <summary>

        /// 删除子文件夹及文件。

        /// </summary>

        FileDeleteChild = 0x00000040,

        /// <summary>

        /// 读取属性

        /// </summary>

        FileReadAttributes = 0x00000080,

        /// <summary>

        /// 写入属性

        /// </summary>

        FileWriteAttributes = 0x00000100,

        /// <summary>

        /// 删除

        /// </summary>

        Delete = 0x00010000,

        /// <summary>

        /// 读取权限

        /// </summary>

        ReadControl = 0x00020000,

        /// <summary>

        /// 更改权限

        /// </summary>

        WriteDac = 0x00040000,

        /// <summary>

        /// 取得所有权

        /// </summary>

        WriteOwner = 0x00080000,

        /// <summary>

        /// 完全控制

        /// </summary>

        AllAccess = FileReadData | FileWriteData | FileAppendData | FileReadEA | FileWriteEA | FileExecute | FileDeleteChild | FileReadAttributes | FileWriteAttributes | Delete | ReadControl | WriteDac | WriteOwner | Synchronize,

        /// <summary>

        /// 同步

        /// </summary>

        Synchronize = 0x00100000,

        /// <summary>

        /// 未知属性（此值保留备用）。

        /// </summary>

        Unknown = 0x10000000,

    }



    /// <summary>

    /// 指示访问权限应用范围。

    /// </summary>

    [System.Flags]

    public enum AccessFlags : uint

    {

        /// <summary>

        /// 无。

        /// </summary>

        NonInheritAce = 0,

        /// <summary>

        /// 该文件夹及文件

        /// </summary>

        ObjectInheritAce = 1,

        /// <summary>

        /// 该文件夹及子文件夹

        /// </summary>

        ContainerInheritAce = 2,

        /// <summary>

        /// 将这些权限只应用到这个容器中的对象和/容器上

        /// </summary>

        /// <remarks>

        /// 其实这也是继承访问权限的，如果设置此项，则向文件和子文件夹传播刚才设置的特殊访问权限；如果清除选择，则阻止权限的继承。

        /// </remarks>

        NoPropagateInheritAce = 4,

        InheritOnlyAce = 8,

        InheritedAce = 16

    }



    /// <summary>

    /// 权限作用类型。

    /// </summary>

    [System.Flags]

    public enum AccessType : uint

    {

        /// <summary>

        /// 允许

        /// </summary>

        AccessAllowed = 0,

        /// <summary>

        /// 否认

        /// </summary>

        AccessDenied = 1,

        /// <summary>

        /// 审核

        /// </summary>

        Audit = 2

    }



    /// <summary>

    /// 访问权限设置配置节。

    /// </summary>

    public class Access

    {

        internal string _SIDString = "";

        /// <summary>

        /// ID

        /// </summary>

        public string SIDString

        {

            get

            {

                return this._SIDString;

            }

        }

        /// <summary>

        /// 用户/组名称。

        /// </summary>

        public string Name

        {

            get;

            set;

        }

        private string _Domain = null;

        /// <summary>

        /// 域。

        /// </summary>

        public string Domain

        {

            get

            {

                return this._Domain;

            }

            set

            {

                this._Domain = value;

            }

        }



        /// <summary>

        /// 访问权限

        /// </summary>

        public AccessPrivileges AccessMask

        {

            get;

            set;

        }

        private AccessFlags _AceFlags = AccessFlags.ObjectInheritAce | AccessFlags.ContainerInheritAce;

        /// <summary>

        /// 访问权限应用范围。

        /// </summary>

        public AccessFlags AceFlags

        {

            get

            {

                return this._AceFlags;

            }

            set

            {

                this._AceFlags = value;

            }

        }

        private AccessType _AceType = AccessType.AccessAllowed;

        /// <summary>

        /// 权限作用类型。

        /// </summary>

        public AccessType AceType

        {

            get

            {

                return this._AceType;

            }

            set

            {

                this._AceType = value;

            }

        }

    }



    /// <summary>

    /// 访问权限设置集合。

    /// </summary>

    public class AccessCollection : System.Collections.Generic.ICollection<Access>

    {

        /// <summary>

        /// 权限集合。

        /// </summary>

        private System.Collections.Generic.List<Access> DaclCollection = new System.Collections.Generic.List<Access>();

        /// <summary>

        /// 为此集合对象提供索引访问。

        /// </summary>

        /// <param name="index"></param>

        /// <returns></returns>

        public Access this[int index]

        {

            get

            {

                return this.DaclCollection[index];

            }

        }



        #region ICollection<Access> 成员



        /// <summary>

        /// 将对象添加到集合的结尾处。

        /// </summary>

        /// <param name="item"></param>

        public void Add(Access item)

        {

            this.DaclCollection.Add(item);

        }



        /// <summary>

        /// 从集合中移除所有元素。

        /// </summary>

        public void Clear()

        {

            this.DaclCollection.Clear();

        }



        /// <summary>

        /// 确定指定的元素是否在集合中。

        /// </summary>

        /// <param name="item"></param>

        /// <returns></returns>

        public bool Contains(Access item)

        {

            return this.DaclCollection.Contains(item);

        }



        /// <summary>

        /// 将整个集合复制到兼容的一维数组中，从目标数组的指定索引位置开始放置。

        /// </summary>

        /// <param name="array"></param>

        /// <param name="arrayIndex"></param>

        public void CopyTo(Access[] array, int arrayIndex)

        {

            this.DaclCollection.CopyTo(array, arrayIndex);

        }



        /// <summary>

        /// 获取集合中实际包含的元素数。

        /// </summary>

        public int Count

        {

            get { return this.DaclCollection.Count; }

        }



        /// <summary>

        /// 获取一个值，判断集合是否为只读。

        /// </summary>

        public bool IsReadOnly

        {

            get { return false; }

        }



        /// <summary>

        /// 从集合中移除特定对象的第一个匹配项。

        /// </summary>

        /// <param name="item"></param>

        /// <returns></returns>

        public bool Remove(Access item)

        {

            return this.DaclCollection.Remove(item);

        }



        #endregion



        #region IEnumerable<Access> 成员



        /// <summary>

        /// 返回循环访问集合的枚举数。

        /// </summary>

        /// <returns></returns>

        public System.Collections.Generic.IEnumerator<Access> GetEnumerator()

        {

            return this.DaclCollection.GetEnumerator();

        }



        #endregion



        #region IEnumerable 成员



        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            return this.DaclCollection.GetEnumerator();

        }



        #endregion

    }



    /// <summary>

    /// 文件系统权限管理类。

    /// </summary>

    /// <example>

    /// <code>

    ///string path = @"c:/testabc";

    ///ShareManagement fss = new ShareManagement();

    /// //如果存在指定共享则删除

    ///if (fss.IsExistsShare(path))

    ///{

    ///    fss.DeleteShare(path);

    ///}

    ///

    /// //创建共享

    ///Share sre = new Share(path);

    ///sre.MaximumAllowed = 0;

    ///fss.CreateShare(sre);

    ///

    /// //获取全部的共享

    ///foreach (Share tmp in fss.GetShares())

    ///{

    ///    System.Console.WriteLine(tmp.Name + ":" + tmp.Type.ToString());

    ///}

    /// </code>

    /// </example>

    public class AccessManagement

    {

        /// <summary>

        /// 一个构造方法。

        /// </summary>

        public AccessManagement()

        {

        }



        /// <summary>

        /// 获取一个 WMI 操作对象。

        /// </summary>

        /// <param name="FilePath">文件/目录路径。</param>

        /// <returns></returns>

        private System.Management.ManagementObject GetManagementObject(string FilePath)

        {

            //ManagementPath path = new ManagementPath();

            //path.Server = ".";              // 机器名, .表示本机

            //path.NamespacePath = @"root/CIMV2";

            //path.RelativePath = string.Format("Win32_LogicalFileSecuritySetting.Path='{0}'", FilePath);

            //ManagementObject mo = new ManagementObject(path);



            return new System.Management.ManagementObject(string.Format("Win32_LogicalFileSecuritySetting.Path='{0}'", FilePath));



        }



        /// <summary>

        /// 获取指定文件或目录的访问权限设置。

        /// </summary>

        /// <param name="FilePath">文件/目录路径。</param>

        /// <returns></returns>

        /// <exception cref="System.Exception">无权访问；未知失败；缺少权限；非法的参数</exception>

        public AccessCollection GetPermission(string FilePath)

        {

            if (!System.IO.File.Exists(FilePath) && !System.IO.Directory.Exists(FilePath))

            {

                throw new System.IO.FileNotFoundException("指定的文件或目录不存在。", FilePath);

            }

            AccessCollection dacl = new AccessCollection();

            System.Management.ManagementObject mo = this.GetManagementObject(FilePath);

            System.Management.ManagementBaseObject outParams = mo.InvokeMethod("GetSecurityDescriptor", null, null);



            //if ((uint)outParams.Properties["ReturnValue"].Value != 0)

            //{

            //    return null;

            //}

            switch ((uint)outParams.Properties["ReturnValue"].Value)

            {

                case 0: //Success

                    break;

                case 2: //Access denied 

                    throw new System.Exception("无权访问");

                case 8: //Unknown failure 

                    throw new System.Exception("未知失败");

                case 9: //Privilege missing 

                    throw new System.Exception("缺少权限");

                case 21: //Invalid parameter 

                    throw new System.Exception("非法的参数");

                default:

                    throw new System.Exception("未知异常信息");

            }



            System.Management.ManagementBaseObject Descriptor = (System.Management.ManagementBaseObject)outParams.Properties["Descriptor"].Value;

            foreach (System.Management.ManagementBaseObject mbo in (System.Management.ManagementBaseObject[])Descriptor.Properties["Dacl"].Value)

            {

                Access ace = new Access();

                ace.AccessMask = (AccessPrivileges)mbo["AccessMask"];

                ace.AceFlags = (AccessFlags)mbo["AceFlags"];

                ace.AceType = (AccessType)mbo["AceType"];

                System.Management.ManagementBaseObject Trustee = ((System.Management.ManagementBaseObject)(mbo["Trustee"]));

                ace.Name = (string)Trustee.Properties["Name"].Value;

                ace.Domain = (string)Trustee.Properties["Domain"].Value;

                ace._SIDString = (string)Trustee.Properties["SIDString"].Value;

                dacl.Add(ace);

            }



            return dacl;



        }



        /// <summary>

        /// 设置指定文件或目录的访问权限设置。

        /// </summary>

        /// <param name="FilePath">文件/目录路径。</param>

        /// <param name="dacl">权限组。</param>

        public void SetPermission(string FilePath, AccessCollection dacl)

        {

            if (!System.IO.File.Exists(FilePath) && !System.IO.Directory.Exists(FilePath))

            {

                throw new System.IO.FileNotFoundException("指定的文件或目录不存在。", FilePath);

            }

            System.Management.ManagementObject mo = this.GetManagementObject(FilePath);

            System.Management.ManagementBaseObject outParams = mo.InvokeMethod("GetSecurityDescriptor", null, null);



            switch ((uint)outParams.Properties["ReturnValue"].Value)

            {

                case 0: //Success

                    break;

                case 2: //Access denied 

                    throw new System.Exception("无权访问");

                case 8: //Unknown failure 

                    throw new System.Exception("未知失败");

                case 9: //Privilege missing 

                    throw new System.Exception("缺少权限");

                case 21: //Invalid parameter 

                    throw new System.Exception("非法的参数");

                default:

                    throw new System.Exception("未知异常信息");

            }



            System.Collections.Generic.List<System.Management.ManagementBaseObject> newDacl = new System.Collections.Generic.List<System.Management.ManagementBaseObject>();



            foreach (var tmp in dacl)

            {

                //增加用户

                System.Management.ManagementClass trustee = new System.Management.ManagementClass("win32_trustee");

                trustee.Properties["Name"].Value = tmp.Name;

                trustee.Properties["Domain"].Value = tmp.Domain;



                //设置权限

                System.Management.ManagementClass ace = new System.Management.ManagementClass("win32_ace");

                ace.Properties["AccessMask"].Value = tmp.AccessMask;

                ace.Properties["AceFlags"].Value = tmp.AceFlags;

                ace.Properties["AceType"].Value = tmp.AceType;

                ace.Properties["Trustee"].Value = trustee;

                newDacl.Add(ace);

            }



            System.Management.ManagementBaseObject Descriptor = (System.Management.ManagementBaseObject)outParams.Properties["Descriptor"].Value;

            Descriptor.Properties["Dacl"].Value = newDacl.ToArray();

            //Descriptor.Properties["Group"].Value = null;

            //Descriptor.Properties["Owner"].Value = null;



            System.Management.ManagementBaseObject inParams = mo.GetMethodParameters("SetSecurityDescriptor");

            inParams["Descriptor"] = Descriptor;

            System.Management.ManagementBaseObject ret = mo.InvokeMethod("SetSecurityDescriptor", inParams, null);



            switch ((uint)ret.Properties["ReturnValue"].Value)

            {

                case 0: //Success

                    break;

                case 2: //Access denied 

                    throw new System.Exception("无权访问");

                case 8: //Unknown failure 

                    throw new System.Exception("未知失败");

                case 9: //Privilege missing 

                    throw new System.Exception("缺少权限");

                case 21: //Invalid parameter 

                    throw new System.Exception("非法的参数");

                default:

                    throw new System.Exception("未知异常信息");

            }



        }



    }



}