开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaDskQuota.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：16k
源码类别：

Windows编程

开发平台：

Delphi

JwaDskQuota.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Disk Quota's API interface Unit for Object Pascal                            }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: dskquota.h, released June 2000. The original Pascal    }
  9. { code is: DskQuota.pas, released December 2000. The initial developer of the  }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaDskQuota;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "DskQuota.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   ActiveX {TODO}, JwaWinNT, JwaWinType;
  59. const
  61. //
  62. // Class IDs
  63. //
  64. // {7988B571-EC89-11cf-9C00-00AA00A14F56}
  66.   CLSID_DiskQuotaControl: TGUID = (
  67.     D1:$7988b571; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  68.   {$EXTERNALSYM CLSID_DiskQuotaControl}
  70. //
  71. // Interface IDs
  72. //
  73. // {7988B572-EC89-11cf-9C00-00AA00A14F56}
  75.   IID_IDiskQuotaControl: TGUID = (
  76.     D1:$7988b572; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  77.   {$EXTERNALSYM IID_IDiskQuotaControl}
  79. // {7988B574-EC89-11cf-9C00-00AA00A14F56}
  81.   IID_IDiskQuotaUser: TGUID = (
  82.     D1:$7988b574; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  83.   {$EXTERNALSYM IID_IDiskQuotaUser}
  85. // {7988B576-EC89-11cf-9C00-00AA00A14F56}
  87.   IID_IDiskQuotaUserBatch: TGUID = (
  88.     D1:$7988b576; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  89.   {$EXTERNALSYM IID_IDiskQuotaUserBatch}
  91. // {7988B577-EC89-11cf-9C00-00AA00A14F56}
  93.   IID_IEnumDiskQuotaUsers: TGUID = (
  94.     D1:$7988b577; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  95.   {$EXTERNALSYM IID_IEnumDiskQuotaUsers}
  97. // {7988B579-EC89-11cf-9C00-00AA00A14F56}
  99.   IID_IDiskQuotaEvents: TGUID = (
  100.     D1:$7988b579; D2:$ec89; D3:$11cf; D4:($9c, $0, $0, $aa, $0, $a1, $4f, $56));
  101.   {$EXTERNALSYM IID_IDiskQuotaEvents}
  103. //
  104. // Definitions for value and bits in DWORD returned by
  105. // IDiskQuotaControl::GetQuotaState.
  106. //
  108.   DISKQUOTA_STATE_DISABLED       = $00000000;
  109.   {$EXTERNALSYM DISKQUOTA_STATE_DISABLED}
  110.   DISKQUOTA_STATE_TRACK          = $00000001;
  111.   {$EXTERNALSYM DISKQUOTA_STATE_TRACK}
  112.   DISKQUOTA_STATE_ENFORCE        = $00000002;
  113.   {$EXTERNALSYM DISKQUOTA_STATE_ENFORCE}
  114.   DISKQUOTA_STATE_MASK           = $00000003;
  115.   {$EXTERNALSYM DISKQUOTA_STATE_MASK}
  116.   DISKQUOTA_FILESTATE_INCOMPLETE = $00000100;
  117.   {$EXTERNALSYM DISKQUOTA_FILESTATE_INCOMPLETE}
  118.   DISKQUOTA_FILESTATE_REBUILDING = $00000200;
  119.   {$EXTERNALSYM DISKQUOTA_FILESTATE_REBUILDING}
  120.   DISKQUOTA_FILESTATE_MASK       = $00000300;
  121.   {$EXTERNALSYM DISKQUOTA_FILESTATE_MASK}
  123. //
  124. // Helper macros for setting and testing state value.
  125. //
  127. function DISKQUOTA_SET_DISABLED(var s: DWORD): DWORD;
  128. {$EXTERNALSYM DISKQUOTA_SET_DISABLED}
  129. function DISKQUOTA_SET_TRACKED(var s: DWORD): DWORD;
  130. {$EXTERNALSYM DISKQUOTA_SET_TRACKED}
  131. function DISKQUOTA_SET_ENFORCED(var s: DWORD): DWORD;
  132. {$EXTERNALSYM DISKQUOTA_SET_ENFORCED}
  133. function DISKQUOTA_IS_DISABLED(s: DWORD): BOOL;
  134. {$EXTERNALSYM DISKQUOTA_IS_DISABLED}
  135. function DISKQUOTA_IS_TRACKED(s: DWORD): BOOL;
  136. {$EXTERNALSYM DISKQUOTA_IS_TRACKED}
  137. function DISKQUOTA_IS_ENFORCED(s: DWORD): BOOL;
  138. {$EXTERNALSYM DISKQUOTA_IS_ENFORCED}
  140. //
  141. // These file state flags are read-only.
  142. //
  144. function DISKQUOTA_FILE_INCOMPLETE(s: DWORD): BOOL;
  145. {$EXTERNALSYM DISKQUOTA_FILE_INCOMPLETE}
  146. function DISKQUOTA_FILE_REBUILDING(s: DWORD): BOOL;
  147. {$EXTERNALSYM DISKQUOTA_FILE_REBUILDING}
  149. //
  150. // Definitions for bits in DWORD returned by
  151. // IDiskQuotaControl::GetQuotaLogFlags.
  152. //
  154. const
  155.   DISKQUOTA_LOGFLAG_USER_THRESHOLD = $00000001;
  156.   {$EXTERNALSYM DISKQUOTA_LOGFLAG_USER_THRESHOLD}
  157.   DISKQUOTA_LOGFLAG_USER_LIMIT     = $00000002;
  158.   {$EXTERNALSYM DISKQUOTA_LOGFLAG_USER_LIMIT}
  160. //
  161. // Helper macros to interrogate a log flags DWORD.
  162. //
  164. function DISKQUOTA_IS_LOGGED_USER_THRESHOLD(f: DWORD): BOOL;
  165. {$EXTERNALSYM DISKQUOTA_IS_LOGGED_USER_THRESHOLD}
  166. function DISKQUOTA_IS_LOGGED_USER_LIMIT(f: DWORD): BOOL;
  167. {$EXTERNALSYM DISKQUOTA_IS_LOGGED_USER_LIMIT}
  169. //
  170. // Helper macros to set/clear bits in a log flags DWORD.
  171. //
  173. function DISKQUOTA_SET_LOG_USER_THRESHOLD(f: DWORD; yn: BOOL): DWORD;
  174. {$EXTERNALSYM DISKQUOTA_SET_LOG_USER_THRESHOLD}
  175. function DISKQUOTA_SET_LOG_USER_LIMIT(f: DWORD; yn: BOOL): DWORD;
  176. {$EXTERNALSYM DISKQUOTA_SET_LOG_USER_LIMIT}
  178. //
  179. // Per-user quota information.
  180. //
  182. type
  183.   PDISKQUOTA_USER_INFORMATION = ^DISKQUOTA_USER_INFORMATION;
  184.   {$EXTERNALSYM PDISKQUOTA_USER_INFORMATION}
  185.   DiskQuotaUserInformation = record
  186.     QuotaUsed: LONGLONG;
  187.     QuotaThreshold: LONGLONG;
  188.     QuotaLimit: LONGLONG;
  189.   end;
  190.   {$EXTERNALSYM DiskQuotaUserInformation}
  191.   DISKQUOTA_USER_INFORMATION = DiskQuotaUserInformation;
  192.   {$EXTERNALSYM DISKQUOTA_USER_INFORMATION}
  193.   TDiskQuotaUserInformation = DISKQUOTA_USER_INFORMATION;
  194.   PDiskQuotaUserInformation = PDISKQUOTA_USER_INFORMATION;
  196. //
  197. // Values for fNameResolution argument to:
  198. //
  199. //      IDiskQuotaControl::AddUserSid
  200. //      IDiskQuotaControl::AddUserName
  201. //      IDiskQuotaControl::FindUserSid
  202. //      IDiskQuotaControl::CreateEnumUsers
  203. //
  205. const
  206.   DISKQUOTA_USERNAME_RESOLVE_NONE  = 0;
  207.   {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_NONE}
  208.   DISKQUOTA_USERNAME_RESOLVE_SYNC  = 1;
  209.   {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_SYNC}
  210.   DISKQUOTA_USERNAME_RESOLVE_ASYNC = 2;
  211.   {$EXTERNALSYM DISKQUOTA_USERNAME_RESOLVE_ASYNC}
  213. //
  214. // Values for status returned by IDiskQuotaUser::GetAccountStatus.
  215. //
  217.   DISKQUOTA_USER_ACCOUNT_RESOLVED    = 0;
  218.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_RESOLVED}
  219.   DISKQUOTA_USER_ACCOUNT_UNAVAILABLE = 1;
  220.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNAVAILABLE}
  221.   DISKQUOTA_USER_ACCOUNT_DELETED     = 2;
  222.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_DELETED}
  223.   DISKQUOTA_USER_ACCOUNT_INVALID     = 3;
  224.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_INVALID}
  225.   DISKQUOTA_USER_ACCOUNT_UNKNOWN     = 4;
  226.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNKNOWN}
  227.   DISKQUOTA_USER_ACCOUNT_UNRESOLVED  = 5;
  228.   {$EXTERNALSYM DISKQUOTA_USER_ACCOUNT_UNRESOLVED}
  230. //
  231. // IDiskQuotaUser represents a single user quota record on a particular
  232. // NTFS volume.  Objects using this interface are instantiated
  233. // through several IDiskQuotaControl methods.
  234. //
  236. type
  237.   IDiskQuotaUser = interface (IUnknown)
  238.   ['{7988B574-EC89-11cf-9C00-00AA00A14F56}']
  239.     function GetID(var pulID: ULONG): HRESULT; stdcall;
  240.     function GetName(pszAccountContainer: LPWSTR; cchAccountContainer: DWORD;
  241.       pszLogonName: LPWSTR; cchLogonName: DWORD; pszDisplayName: LPWSTR;
  242.       cchDisplayName: DWORD): HRESULT; stdcall;
  243.     function GetSidLength(var pdwLength: DWORD): HRESULT; stdcall;
  244.     function GetSid(pbSidBuffer: LPBYTE; cbSidBuffer: DWORD): HRESULT; stdcall;
  245.     function GetQuotaThreshold(var pllThreshold: LONGLONG): HRESULT; stdcall;
  246.     function GetQuotaThresholdText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
  247.     function GetQuotaLimit(var pllLimit: LONGLONG): HRESULT; stdcall;
  248.     function GetQuotaLimitText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
  249.     function GetQuotaUsed(var pllUsed: LONGLONG): HRESULT; stdcall;
  250.     function GetQuotaUsedText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
  251.     function GetQuotaInformation(pbQuotaInfo: LPVOID; cbQuotaInfo: DWORD): HRESULT; stdcall;
  252.     function SetQuotaThreshold(llThreshold: LONGLONG; fWriteThrough: BOOL): HRESULT; stdcall;
  253.     function SetQuotaLimit(llLimit: LONGLONG; fWriteThrough: BOOL): HRESULT; stdcall;
  254.     function Invalidate: HRESULT; stdcall;
  255.     function GetAccountStatus(var pdwStatus: DWORD): HRESULT; stdcall;
  256.   end;
  257.   {$EXTERNALSYM IDiskQuotaUser}
  259.   DISKQUOTA_USER = IDiskQuotaUser;
  260.   {$EXTERNALSYM DISKQUOTA_USER}
  261.   PDISKQUOTA_USER = ^DISKQUOTA_USER;
  262.   {$EXTERNALSYM PDISKQUOTA_USER}
  264. //
  265. // IEnumDiskQuotaUsers represents an enumerator created by
  266. // IDiskQuotaControl for the purpose of enumerating individual user quota
  267. // records on a particular volume.  Each record is represented through
  268. // the IDiskQuotaUser interface.
  269. //
  271.   IEnumDiskQuotaUsers = interface (IUnknown)
  272.   ['{7988B577-EC89-11cf-9C00-00AA00A14F56}']
  273.     function Next(cUsers: DWORD; var rgUsers: IDiskQuotaUser; pcUsersFetched: LPDWORD): HRESULT; stdcall;
  274.     function Skip(cUsers: DWORD): HRESULT; stdcall;
  275.     function Reset: HRESULT; stdcall;
  276.     function Clone(out ppEnum: IEnumDiskQuotaUsers): HRESULT; stdcall;
  277.   end;
  278.   {$EXTERNALSYM IEnumDiskQuotaUsers}
  280.   ENUM_DISKQUOTA_USERS = IEnumDiskQuotaUsers;
  281.   {$EXTERNALSYM ENUM_DISKQUOTA_USERS}
  282.   PENUM_DISKQUOTA_USERS = ^ENUM_DISKQUOTA_USERS;
  283.   {$EXTERNALSYM PENUM_DISKQUOTA_USERS}
  285. //
  286. // IDiskQuotaUserBatch represents a collection of IDiskQuotaUser
  287. // pointers for the purpose of grouping updates to quota information.
  288. //
  290.   IDiskQuotaUserBatch = interface (IUnknown)
  291.   ['{7988B576-EC89-11cf-9C00-00AA00A14F56}']
  292.     function Add(pUser: IDiskQuotaUser): HRESULT; stdcall;
  293.     function Remove(pUser: IDiskQuotaUser): HRESULT; stdcall;
  294.     function RemoveAll: HRESULT; stdcall;
  295.     function FlushToDisk: HRESULT; stdcall;
  296.   end;
  297.   {$EXTERNALSYM IDiskQuotaUserBatch}
  299.   DISKQUOTA_USER_BATCH = IDiskQuotaUserBatch;
  300.   {$EXTERNALSYM DISKQUOTA_USER_BATCH}
  301.   PDISKQUOTA_USER_BATCH = ^DISKQUOTA_USER_BATCH;
  302.   {$EXTERNALSYM PDISKQUOTA_USER_BATCH}
  304. //
  305. // IDiskQuotaControl represents a disk volume, providing query and
  306. // control of that volume's quota information.
  307. //
  309.   IDiskQuotaControl = interface (IConnectionPointContainer)
  310.   ['{7988B571-EC89-11cf-9C00-00AA00A14F56}']
  311.     function Initialize(pszPath: LPCWSTR; bReadWrite: BOOL): HRESULT; stdcall;
  312.     function SetQuotaState(dwState: DWORD): HRESULT; stdcall;
  313.     function GetQuotaState(var pdwState: DWORD): HRESULT; stdcall;
  314.     function SetQuotaLogFlags(dwFlags: DWORD): HRESULT; stdcall;
  315.     function GetQuotaLogFlags(var pdwFlags: DWORD): HRESULT; stdcall;
  316.     function SetDefaultQuotaThreshold(llThreshold: LONGLONG): HRESULT; stdcall;
  317.     function GetDefaultQuotaThreshold(var pllThreshold: LONGLONG): HRESULT; stdcall;
  318.     function GetDefaultQuotaThresholdText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
  319.     function SetDefaultQuotaLimit(llLimit: LONGLONG): HRESULT; stdcall;
  320.     function GetDefaultQuotaLimit(var pllLimit: LONGLONG): HRESULT; stdcall;
  321.     function GetDefaultQuotaLimitText(pszText: LPWSTR; cchText: DWORD): HRESULT; stdcall;
  322.     function AddUserSid(pUserSid: PSID; fNameResolution: DWORD;
  323.       out ppUser: IDiskQuotaUser): HRESULT; stdcall;
  324.     function AddUserName(pszLogonName: LPCWSTR; fNameResolution: DWORD;
  325.       out ppUser: IDiskQuotaUser): HRESULT; stdcall;
  326.     function DeleteUser(pUser: IDiskQuotaUser): HRESULT; stdcall;
  327.     function FindUserSid(pUserSid: PSID; fNameResolution: DWORD;
  328.       out ppUser: IDiskQuotaUser): HRESULT; stdcall;
  329.     function FindUserName(pszLogonName: LPCWSTR; out ppUser: IDiskQuotaUser): HRESULT; stdcall;
  330.     function CreateEnumUsers(rgpUserSids: PSID; cpSids, fNameResolution: DWORD;
  331.       out ppEnum: IEnumDiskQuotaUsers): HRESULT; stdcall;
  332.     function CreateUserBatch(out ppBatch: IDiskQuotaUserBatch): HRESULT; stdcall;
  333.     function InvalidateSidNameCache: HRESULT; stdcall;
  334.     function GiveUserNameResolutionPriority(pUser: IDiskQuotaUser): HRESULT; stdcall;
  335.     function ShutdownNameResolution: HRESULT; stdcall;
  336.   end;
  337.   {$EXTERNALSYM IDiskQuotaControl}
  339.   DISKQUOTA_CONTROL = IDiskQuotaControl;
  340.   {$EXTERNALSYM DISKQUOTA_CONTROL}
  341.   PDISKQUOTA_CONTROL = ^DISKQUOTA_CONTROL;
  342.   {$EXTERNALSYM PDISKQUOTA_CONTROL}
  344.   IDiskQuotaEvents = interface (IUnknown)
  345.   ['{7988B579-EC89-11cf-9C00-00AA00A14F56}']
  346.     function OnUserNameChanged(pUser: IDiskQuotaUser): HRESULT; stdcall;
  347.   end;
  348.   {$EXTERNALSYM IDiskQuotaEvents}
  350.   DISKQUOTA_EVENTS = IDiskQuotaEvents;
  351.   {$EXTERNALSYM DISKQUOTA_EVENTS;}
  352.   PDISKQUOTA_EVENTS = ^DISKQUOTA_EVENTS;
  353.   {$EXTERNALSYM PDISKQUOTA_EVENTS;}
  355. implementation
  357. function DISKQUOTA_SET_DISABLED(var s: DWORD): DWORD;
  358. begin
  359.   s := DISKQUOTA_STATE_DISABLED;
  360.   Result := s;
  361. end;
  363. function DISKQUOTA_SET_TRACKED(var s: DWORD): DWORD;
  364. begin
  365.   s := DISKQUOTA_STATE_TRACK;
  366.   Result := s;
  367. end;
  369. function DISKQUOTA_SET_ENFORCED(var s: DWORD): DWORD;
  370. begin
  371.   s := DISKQUOTA_STATE_ENFORCE;
  372.   Result := s;
  373. end;
  375. function DISKQUOTA_IS_DISABLED(s: DWORD): BOOL;
  376. begin
  377.   Result := (DISKQUOTA_STATE_DISABLED = (s and DISKQUOTA_STATE_MASK));
  378. end;
  380. function DISKQUOTA_IS_TRACKED(s: DWORD): BOOL;
  381. begin
  382.   Result := (DISKQUOTA_STATE_TRACK = (s and DISKQUOTA_STATE_MASK));
  383. end;
  385. function DISKQUOTA_IS_ENFORCED(s: DWORD): BOOL;
  386. begin
  387.   Result := (DISKQUOTA_STATE_ENFORCE = (s and DISKQUOTA_STATE_MASK));
  388. end;
  390. function DISKQUOTA_FILE_INCOMPLETE(s: DWORD): BOOL;
  391. begin
  392.   Result := (0 <> (s and DISKQUOTA_FILESTATE_INCOMPLETE));
  393. end;
  395. function DISKQUOTA_FILE_REBUILDING(s: DWORD): BOOL;
  396. begin
  397.   Result := (0 <> (s and DISKQUOTA_FILESTATE_REBUILDING));
  398. end;
  400. function DISKQUOTA_IS_LOGGED_USER_THRESHOLD(f: DWORD): BOOL;
  401. begin
  402.   Result := (0 <> (f and DISKQUOTA_LOGFLAG_USER_THRESHOLD));
  403. end;
  405. function DISKQUOTA_IS_LOGGED_USER_LIMIT(f: DWORD): BOOL;
  406. begin
  407.   Result := (0 <> (f and DISKQUOTA_LOGFLAG_USER_LIMIT));
  408. end;
  410. function DISKQUOTA_SET_LOG_USER_THRESHOLD(f: DWORD; yn: BOOL): DWORD;
  411. begin
  412.   Result := f and (not DISKQUOTA_LOGFLAG_USER_THRESHOLD);
  413.   if yn then Result := Result or DISKQUOTA_LOGFLAG_USER_THRESHOLD;
  414. end;
  416. function DISKQUOTA_SET_LOG_USER_LIMIT(f: DWORD; yn: BOOL): DWORD;
  417. begin
  418.   Result := f and (not DISKQUOTA_LOGFLAG_USER_LIMIT);
  419.   if yn then Result := Result or DISKQUOTA_LOGFLAG_USER_LIMIT;
  420. end;
  422. end.