1 |
// Upgraded to Delphi 2009: Sebastian Zierer
|
2 |
|
3 |
(* ***** BEGIN LICENSE BLOCK *****
|
4 |
* Version: MPL 1.1
|
5 |
*
|
6 |
* The contents of this file are subject to the Mozilla Public License Version
|
7 |
* 1.1 (the "License"); you may not use this file except in compliance with
|
8 |
* the License. You may obtain a copy of the License at
|
9 |
* http://www.mozilla.org/MPL/
|
10 |
*
|
11 |
* Software distributed under the License is distributed on an "AS IS" basis,
|
12 |
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
13 |
* for the specific language governing rights and limitations under the
|
14 |
* License.
|
15 |
*
|
16 |
* The Original Code is TurboPower SysTools
|
17 |
*
|
18 |
* The Initial Developer of the Original Code is
|
19 |
* TurboPower Software
|
20 |
*
|
21 |
* Portions created by the Initial Developer are Copyright (C) 1996-2002
|
22 |
* the Initial Developer. All Rights Reserved.
|
23 |
*
|
24 |
* Contributor(s):
|
25 |
*
|
26 |
* ***** END LICENSE BLOCK ***** *)
|
27 |
|
28 |
{*********************************************************}
|
29 |
{* SysTools: StNetAPI.pas 4.04 *}
|
30 |
{*********************************************************}
|
31 |
{* SysTools: Network API Defines *}
|
32 |
{*********************************************************}
|
33 |
|
34 |
{$I StDefine.inc}
|
35 |
|
36 |
{$H+} {Huge strings}
|
37 |
|
38 |
unit StNetAPI;
|
39 |
|
40 |
interface
|
41 |
|
42 |
uses
|
43 |
Windows, StBase;
|
44 |
|
45 |
{-------------------- LMERR.H------------------------------------------------}
|
46 |
const
|
47 |
NERR_SUCCESS = 0; {Success}
|
48 |
|
49 |
{ NERR_BASE is the base of error codes from network utilities, }
|
50 |
{ chosen to avoid conflict with system and redirector error codes. }
|
51 |
{ 2100 is a value that has been assigned to us by system. }
|
52 |
|
53 |
NERR_BASE = 2100;
|
54 |
|
55 |
{ INTERNAL_ONLY }
|
56 |
|
57 |
{ ***********WARNING **************** }
|
58 |
{ *See the comment in lmcons.h for * }
|
59 |
{ *info on the allocation of errors * }
|
60 |
{ *********************************** }
|
61 |
|
62 |
{ ***********WARNING **************** }
|
63 |
{ *The range 2750-2799 has been * }
|
64 |
{ *allocated to the IBM LAN Server * }
|
65 |
{ *********************************** }
|
66 |
|
67 |
{ ***********WARNING **************** }
|
68 |
{ *The range 2900-2999 has been * }
|
69 |
{ *reserved for Microsoft OEMs * }
|
70 |
{ *********************************** }
|
71 |
|
72 |
{ END_INTERNAL }
|
73 |
|
74 |
{ UNUSED BASE+0 }
|
75 |
{ UNUSED BASE+1 }
|
76 |
|
77 |
NERR_NetNotStarted = (NERR_BASE+2); { The workstation driver is not installed. }
|
78 |
NERR_UnknownServer = (NERR_BASE+3); { The server could not be located. }
|
79 |
NERR_ShareMem = (NERR_BASE+4); { An internal error occurred. The network cannot access a shared memory segment. }
|
80 |
|
81 |
NERR_NoNetworkResource = (NERR_BASE+5); { A network resource shortage occurred. }
|
82 |
NERR_RemoteOnly = (NERR_BASE+6); { This operation is not supported on workstations. }
|
83 |
NERR_DevNotRedirected = (NERR_BASE+7); { The device is not connected. }
|
84 |
|
85 |
{ UNUSED BASE+8 }
|
86 |
{ UNUSED BASE+9 }
|
87 |
{ UNUSED BASE+10 }
|
88 |
{ UNUSED BASE+11 }
|
89 |
{ UNUSED BASE+12 }
|
90 |
{ UNUSED BASE+13 }
|
91 |
|
92 |
NERR_ServerNotStarted = (NERR_BASE+14); { The Server service is not started. }
|
93 |
NERR_ItemNotFound = (NERR_BASE+15); { The queue is empty. }
|
94 |
NERR_UnknownDevDir = (NERR_BASE+16); { The device or directory does not exist. }
|
95 |
NERR_RedirectedPath = (NERR_BASE+17); { The operation is invalid on a redirected resource. }
|
96 |
NERR_DuplicateShare = (NERR_BASE+18); { The name has already been shared. }
|
97 |
NERR_NoRoom = (NERR_BASE+19); { The server is currently out of the requested resource. }
|
98 |
|
99 |
{ UNUSED BASE+20 }
|
100 |
|
101 |
NERR_TooManyItems = (NERR_BASE+21); { Requested addition of items exceeds the maximum allowed. */ }
|
102 |
NERR_InvalidMaxUsers = (NERR_BASE+22); { The Peer service supports only two simultaneous users. */ }
|
103 |
NERR_BufTooSmall = (NERR_BASE+23); { The API return buffer is too small. }
|
104 |
|
105 |
{ UNUSED BASE+24 }
|
106 |
{ UNUSED BASE+25 }
|
107 |
{ UNUSED BASE+26 }
|
108 |
|
109 |
NERR_RemoteErr = (NERR_BASE+27); { A remote API error occurred. }
|
110 |
|
111 |
{ UNUSED BASE+28 }
|
112 |
{ UNUSED BASE+29 }
|
113 |
{ UNUSED BASE+30 }
|
114 |
|
115 |
NERR_LanmanIniError = (NERR_BASE+31); { An error occurred when opening or reading the configuration file. }
|
116 |
|
117 |
{ UNUSED BASE+32 }
|
118 |
{ UNUSED BASE+33 }
|
119 |
{ UNUSED BASE+34 }
|
120 |
{ UNUSED BASE+35 }
|
121 |
|
122 |
NERR_NetworkError = (NERR_BASE+36); { A general network error occurred. }
|
123 |
NERR_WkstaInconsistentState = (NERR_BASE+37); { The Workstation service is in an inconsistent state. Restart the computer before restarting the Workstation service. }
|
124 |
NERR_WkstaNotStarted = (NERR_BASE+38); { The Workstation service has not been started. }
|
125 |
NERR_BrowserNotStarted = (NERR_BASE+39); { The requested information is not available. }
|
126 |
NERR_InternalError = (NERR_BASE+40); { An internal Windows NT error occurred. }
|
127 |
NERR_BadTransactConfig = (NERR_BASE+41); { The server is not configured for transactions. }
|
128 |
NERR_InvalidAPI = (NERR_BASE+42); { The requested API is not supported on the remote server. }
|
129 |
NERR_BadEventName = (NERR_BASE+43); { The event name is invalid. }
|
130 |
NERR_DupNameReboot = (NERR_BASE+44); { The computer name already exists on the network. Change it and restart the computer. }
|
131 |
|
132 |
{ Config API related (Error codes from BASE+45 to BASE+49) }
|
133 |
|
134 |
{ UNUSED BASE+45 }
|
135 |
|
136 |
NERR_CfgCompNotFound = (NERR_BASE+46); { The specified component could not be found in the configuration information. }
|
137 |
NERR_CfgParamNotFound = (NERR_BASE+47); { The specified parameter could not be found in the configuration information. }
|
138 |
NERR_LineTooLong = (NERR_BASE+49); { A line in the configuration file is too long. }
|
139 |
|
140 |
{ Spooler API related (Error codes from BASE+50 to BASE+79) }
|
141 |
|
142 |
NERR_QNotFound = (NERR_BASE+50); { The printer does not exist. }
|
143 |
NERR_JobNotFound = (NERR_BASE+51); { The print job does not exist. }
|
144 |
NERR_DestNotFound = (NERR_BASE+52); { The printer destination cannot be found. }
|
145 |
NERR_DestExists = (NERR_BASE+53); { The printer destination already exists. }
|
146 |
NERR_QExists = (NERR_BASE+54); { The printer queue already exists. }
|
147 |
NERR_QNoRoom = (NERR_BASE+55); { No more printers can be added. }
|
148 |
NERR_JobNoRoom = (NERR_BASE+56); { No more print jobs can be added. }
|
149 |
NERR_DestNoRoom = (NERR_BASE+57); { No more printer destinations can be added. }
|
150 |
NERR_DestIdle = (NERR_BASE+58); { This printer destination is idle and cannot accept control operations. }
|
151 |
NERR_DestInvalidOp = (NERR_BASE+59); { This printer destination request contains an invalid control function. }
|
152 |
NERR_ProcNoRespond = (NERR_BASE+60); { The print processor is not responding. }
|
153 |
NERR_SpoolerNotLoaded = (NERR_BASE+61); { The spooler is not running. }
|
154 |
NERR_DestInvalidState = (NERR_BASE+62); { This operation cannot be performed on the print destination in its current state. }
|
155 |
NERR_QInvalidState = (NERR_BASE+63); { This operation cannot be performed on the printer queue in its current state. }
|
156 |
NERR_JobInvalidState = (NERR_BASE+64); { This operation cannot be performed on the print job in its current state. }
|
157 |
NERR_SpoolNoMemory = (NERR_BASE+65); { A spooler memory allocation failure occurred. }
|
158 |
NERR_DriverNotFound = (NERR_BASE+66); { The device driver does not exist. }
|
159 |
NERR_DataTypeInvalid = (NERR_BASE+67); { The data type is not supported by the print processor. }
|
160 |
NERR_ProcNotFound = (NERR_BASE+68); { The print processor is not installed. }
|
161 |
|
162 |
{ Service API related (Error codes from BASE+80 to BASE+99) }
|
163 |
|
164 |
NERR_ServiceTableLocked = (NERR_BASE+80); { The service database is locked. }
|
165 |
NERR_ServiceTableFull = (NERR_BASE+81); { The service table is full. }
|
166 |
NERR_ServiceInstalled = (NERR_BASE+82); { The requested service has already been started. }
|
167 |
NERR_ServiceEntryLocked = (NERR_BASE+83); { The service does not respond to control actions. }
|
168 |
NERR_ServiceNotInstalled= (NERR_BASE+84); { The service has not been started. }
|
169 |
NERR_BadServiceName = (NERR_BASE+85); { The service name is invalid. }
|
170 |
NERR_ServiceCtlTimeout = (NERR_BASE+86); { The service is not responding to the control function. }
|
171 |
NERR_ServiceCtlBusy = (NERR_BASE+87); { The service control is busy. }
|
172 |
NERR_BadServiceProgName = (NERR_BASE+88); { The configuration file contains an invalid service program name. }
|
173 |
NERR_ServiceNotCtrl = (NERR_BASE+89); { The service could not be controlled in its present state. }
|
174 |
NERR_ServiceKillProc = (NERR_BASE+90); { The service ended abnormally. }
|
175 |
NERR_ServiceCtlNotValid = (NERR_BASE+91); { The requested pause or stop is not valid for this service. }
|
176 |
NERR_NotInDispatchTbl = (NERR_BASE+92); { The service control dispatcher could not find the service name in the dispatch table. }
|
177 |
NERR_BadControlRecv = (NERR_BASE+93); { The service control dispatcher pipe read failed. }
|
178 |
NERR_ServiceNotStarting = (NERR_BASE+94); { A thread for the new service could not be created. }
|
179 |
|
180 |
{ Wksta and Logon API related (Error codes from BASE+100 to BASE+118) }
|
181 |
|
182 |
NERR_AlreadyLoggedOn = (NERR_BASE+100); { This workstation is already logged on to the local-area network. }
|
183 |
NERR_NotLoggedOn = (NERR_BASE+101); { The workstation is not logged on to the local-area network. }
|
184 |
NERR_BadUsername = (NERR_BASE+102); { The user name or group name parameter is invalid. }
|
185 |
NERR_BadPassword = (NERR_BASE+103); { The password parameter is invalid. }
|
186 |
NERR_UnableToAddName_W = (NERR_BASE+104); { @W The logon processor did not add the message alias. }
|
187 |
NERR_UnableToAddName_F = (NERR_BASE+105); { The logon processor did not add the message alias. }
|
188 |
NERR_UnableToDelName_W = (NERR_BASE+106); { @W The logoff processor did not delete the message alias. }
|
189 |
NERR_UnableToDelName_F = (NERR_BASE+107); { The logoff processor did not delete the message alias. }
|
190 |
|
191 |
{ UNUSED BASE+108 }
|
192 |
|
193 |
NERR_LogonsPaused = (NERR_BASE+109); { Network logons are paused. }
|
194 |
NERR_LogonServerConflict= (NERR_BASE+110); { A centralized logon-server conflict occurred. }
|
195 |
NERR_LogonNoUserPath = (NERR_BASE+111); { The server is configured without a valid user path. }
|
196 |
NERR_LogonScriptError = (NERR_BASE+112); { An error occurred while loading or running the logon script. }
|
197 |
|
198 |
{ UNUSED BASE+113 }
|
199 |
|
200 |
NERR_StandaloneLogon = (NERR_BASE+114); { The logon server was not specified. Your computer will be logged on as STANDALONE. }
|
201 |
NERR_LogonServerNotFound= (NERR_BASE+115); { The logon server could not be found. }
|
202 |
NERR_LogonDomainExists = (NERR_BASE+116); { There is already a logon domain for this computer. }
|
203 |
NERR_NonValidatedLogon = (NERR_BASE+117); { The logon server could not validate the logon. }
|
204 |
|
205 |
{ ACF API related (access, user, group) (Error codes from BASE+119 to BASE+149) }
|
206 |
|
207 |
NERR_ACFNotFound = (NERR_BASE+119); { The security database could not be found. }
|
208 |
NERR_GroupNotFound = (NERR_BASE+120); { The group name could not be found. }
|
209 |
NERR_UserNotFound = (NERR_BASE+121); { The user name could not be found. }
|
210 |
NERR_ResourceNotFound = (NERR_BASE+122); { The resource name could not be found. }
|
211 |
NERR_GroupExists = (NERR_BASE+123); { The group already exists. }
|
212 |
NERR_UserExists = (NERR_BASE+124); { The user account already exists. }
|
213 |
NERR_ResourceExists = (NERR_BASE+125); { The resource permission list already exists. }
|
214 |
NERR_NotPrimary = (NERR_BASE+126); { This operation is only allowed on the primary domain controller of the domain. }
|
215 |
NERR_ACFNotLoaded = (NERR_BASE+127); { The security database has not been started. }
|
216 |
NERR_ACFNoRoom = (NERR_BASE+128); { There are too many names in the user accounts database. }
|
217 |
NERR_ACFFileIOFail = (NERR_BASE+129); { A disk I/O failure occurred. }
|
218 |
NERR_ACFTooManyLists = (NERR_BASE+130); { The limit of 64 entries per resource was exceeded. }
|
219 |
NERR_UserLogon = (NERR_BASE+131); { Deleting a user with a session is not allowed. }
|
220 |
NERR_ACFNoParent = (NERR_BASE+132); { The parent directory could not be located. }
|
221 |
NERR_CanNotGrowSegment = (NERR_BASE+133); { Unable to add to the security database session cache segment. }
|
222 |
NERR_SpeGroupOp = (NERR_BASE+134); { This operation is not allowed on this special group. }
|
223 |
NERR_NotInCache = (NERR_BASE+135); { This user is not cached in user accounts database session cache. }
|
224 |
NERR_UserInGroup = (NERR_BASE+136); { The user already belongs to this group. }
|
225 |
NERR_UserNotInGroup = (NERR_BASE+137); { The user does not belong to this group. }
|
226 |
NERR_AccountUndefined = (NERR_BASE+138); { This user account is undefined. }
|
227 |
NERR_AccountExpired = (NERR_BASE+139); { This user account has expired. }
|
228 |
NERR_InvalidWorkstation = (NERR_BASE+140); { The user is not allowed to log on from this workstation. }
|
229 |
NERR_InvalidLogonHours = (NERR_BASE+141); { The user is not allowed to log on at this time. }
|
230 |
NERR_PasswordExpired = (NERR_BASE+142); { The password of this user has expired. }
|
231 |
NERR_PasswordCantChange = (NERR_BASE+143); { The password of this user cannot change. }
|
232 |
NERR_PasswordHistConflict=(NERR_BASE+144); { This password cannot be used now. }
|
233 |
NERR_PasswordTooShort = (NERR_BASE+145); { The password is shorter than required. }
|
234 |
NERR_PasswordTooRecent = (NERR_BASE+146); { The password of this user is too recent to change. }
|
235 |
NERR_InvalidDatabase = (NERR_BASE+147); { The security database is corrupted. }
|
236 |
NERR_DatabaseUpToDate = (NERR_BASE+148); { No updates are necessary to this replicant network/local security database. }
|
237 |
NERR_SyncRequired = (NERR_BASE+149); { This replicant database is outdated; synchronization is required. }
|
238 |
|
239 |
{ Use API related (Error codes from BASE+150 to BASE+169) }
|
240 |
|
241 |
NERR_UseNotFound = (NERR_BASE+150); { The network connection could not be found. }
|
242 |
NERR_BadAsgType = (NERR_BASE+151); { This asg_type is invalid. }
|
243 |
NERR_DeviceIsShared = (NERR_BASE+152); { This device is currently being shared. }
|
244 |
|
245 |
{ Message Server related (Error codes BASE+170 to BASE+209) }
|
246 |
|
247 |
NERR_NoComputerName = (NERR_BASE+170); { The computer name could not be added as a message alias. The name may already exist on the network. }
|
248 |
NERR_MsgAlreadyStarted = (NERR_BASE+171); { The Messenger service is already started. }
|
249 |
NERR_MsgInitFailed = (NERR_BASE+172); { The Messenger service failed to start. }
|
250 |
NERR_NameNotFound = (NERR_BASE+173); { The message alias could not be found on the network. }
|
251 |
NERR_AlreadyForwarded = (NERR_BASE+174); { This message alias has already been forwarded. }
|
252 |
NERR_AddForwarded = (NERR_BASE+175); { This message alias has been added but is still forwarded. }
|
253 |
NERR_AlreadyExists = (NERR_BASE+176); { This message alias already exists locally. }
|
254 |
NERR_TooManyNames = (NERR_BASE+177); { The maximum number of added message aliases has been exceeded. }
|
255 |
NERR_DelComputerName = (NERR_BASE+178); { The computer name could not be deleted. }
|
256 |
NERR_LocalForward = (NERR_BASE+179); { Messages cannot be forwarded back to the same workstation. }
|
257 |
NERR_GrpMsgProcessor = (NERR_BASE+180); { An error occurred in the domain message processor. }
|
258 |
NERR_PausedRemote = (NERR_BASE+181); { The message was sent, but the recipient has paused the Messenger service. }
|
259 |
NERR_BadReceive = (NERR_BASE+182); { The message was sent but not received. }
|
260 |
NERR_NameInUse = (NERR_BASE+183); { The message alias is currently in use. Try again later. }
|
261 |
NERR_MsgNotStarted = (NERR_BASE+184); { The Messenger service has not been started. }
|
262 |
NERR_NotLocalName = (NERR_BASE+185); { The name is not on the local computer. }
|
263 |
NERR_NoForwardName = (NERR_BASE+186); { The forwarded message alias could not be found on the network. }
|
264 |
NERR_RemoteFull = (NERR_BASE+187); { The message alias table on the remote station is full. }
|
265 |
NERR_NameNotForwarded = (NERR_BASE+188); { Messages for this alias are not currently being forwarded. }
|
266 |
NERR_TruncatedBroadcast = (NERR_BASE+189); { The broadcast message was truncated. }
|
267 |
NERR_InvalidDevice = (NERR_BASE+194); { This is an invalid device name. }
|
268 |
NERR_WriteFault = (NERR_BASE+195); { A write fault occurred. }
|
269 |
|
270 |
{ UNUSED BASE+196 }
|
271 |
|
272 |
NERR_DuplicateName = (NERR_BASE+197); { A duplicate message alias exists on the network. }
|
273 |
NERR_DeleteLater = (NERR_BASE+198); { @W This message alias will be deleted later. }
|
274 |
NERR_IncompleteDel = (NERR_BASE+199); { The message alias was not successfully deleted from all networks. }
|
275 |
NERR_MultipleNets = (NERR_BASE+200); { This operation is not supported on computers with multiple networks. }
|
276 |
|
277 |
{ Server API related (Error codes BASE+210 to BASE+229) }
|
278 |
|
279 |
NERR_NetNameNotFound = (NERR_BASE+210); { This shared resource does not exist. }
|
280 |
NERR_DeviceNotShared = (NERR_BASE+211); { This device is not shared. }
|
281 |
NERR_ClientNameNotFound = (NERR_BASE+212); { A session does not exist with that computer name. }
|
282 |
NERR_FileIdNotFound = (NERR_BASE+214); { There is not an open file with that identification number. }
|
283 |
NERR_ExecFailure = (NERR_BASE+215); { A failure occurred when executing a remote administration command. }
|
284 |
NERR_TmpFile = (NERR_BASE+216); { A failure occurred when opening a remote temporary file. }
|
285 |
NERR_TooMuchData = (NERR_BASE+217); { The data returned from a remote administration command has been truncated to 64K. }
|
286 |
NERR_DeviceShareConflict= (NERR_BASE+218); { This device cannot be shared as both a spooled and a non-spooled resource. }
|
287 |
NERR_BrowserTableIncomplete= (NERR_BASE+219); { The information in the list of servers may be incorrect. }
|
288 |
NERR_NotLocalDomain = (NERR_BASE+220); { The computer is not active in this domain. }
|
289 |
|
290 |
{ CharDev API related (Error codes BASE+230 to BASE+249) }
|
291 |
|
292 |
{ UNUSED BASE+230 }
|
293 |
|
294 |
NERR_DevInvalidOpCode = (NERR_BASE+231); { The operation is invalid for this device. }
|
295 |
NERR_DevNotFound = (NERR_BASE+232); { This device cannot be shared. }
|
296 |
NERR_DevNotOpen = (NERR_BASE+233); { This device was not open. }
|
297 |
NERR_BadQueueDevString = (NERR_BASE+234); { This device name list is invalid. }
|
298 |
NERR_BadQueuePriority = (NERR_BASE+235); { The queue priority is invalid. }
|
299 |
NERR_NoCommDevs = (NERR_BASE+237); { There are no shared communication devices. }
|
300 |
NERR_QueueNotFound = (NERR_BASE+238); { The queue you specified does not exist. }
|
301 |
NERR_BadDevString = (NERR_BASE+240); { This list of devices is invalid. }
|
302 |
NERR_BadDev = (NERR_BASE+241); { The requested device is invalid. }
|
303 |
NERR_InUseBySpooler = (NERR_BASE+242); { This device is already in use by the spooler. }
|
304 |
NERR_CommDevInUse = (NERR_BASE+243); { This device is already in use as a communication device. }
|
305 |
|
306 |
{ NetICanonicalize and NetIType and NetIMakeLMFileName }
|
307 |
{ NetIListCanon and NetINameCheck }
|
308 |
{ (Error codes BASE+250 to BASE+269) }
|
309 |
|
310 |
NERR_InvalidComputer = (NERR_BASE+251); { This computer name is invalid. }
|
311 |
|
312 |
{ UNUSED BASE+252 }
|
313 |
{ UNUSED BASE+253 }
|
314 |
|
315 |
NERR_MaxLenExceeded = (NERR_BASE+254); { The string and prefix specified are too long. }
|
316 |
|
317 |
{ UNUSED BASE+255 }
|
318 |
|
319 |
NERR_BadComponent = (NERR_BASE+256); { This path component is invalid. }
|
320 |
NERR_CantType = (NERR_BASE+257); { Could not determine the type of input. }
|
321 |
|
322 |
{ UNUSED BASE+258 }
|
323 |
{ UNUSED BASE+259 }
|
324 |
|
325 |
NERR_TooManyEntries = (NERR_BASE+262); { The buffer for types is not big enough. }
|
326 |
|
327 |
{ NetProfile (Error codes BASE+270 to BASE+276) }
|
328 |
|
329 |
NERR_ProfileFileTooBig = (NERR_BASE+270); { Profile files cannot exceed 64K. }
|
330 |
NERR_ProfileOffset = (NERR_BASE+271); { The start offset is out of range. }
|
331 |
NERR_ProfileCleanup = (NERR_BASE+272); { The system cannot delete current connections to network resources. }
|
332 |
NERR_ProfileUnknownCmd = (NERR_BASE+273); { The system was unable to parse the command line in this file. }
|
333 |
NERR_ProfileLoadErr = (NERR_BASE+274); { An error occurred while loading the profile file. }
|
334 |
NERR_ProfileSaveErr = (NERR_BASE+275); { @W Errors occurred while saving the profile file. The profile was partially saved. }
|
335 |
|
336 |
{ NetAudit and NetErrorLog (Error codes BASE+277 to BASE+279) }
|
337 |
|
338 |
NERR_LogOverflow = (NERR_BASE+277); { Log file %1 is full. }
|
339 |
NERR_LogFileChanged = (NERR_BASE+278); { This log file has changed between reads. }
|
340 |
NERR_LogFileCorrupt = (NERR_BASE+279); { Log file %1 is corrupt. }
|
341 |
|
342 |
{ NetRemote (Error codes BASE+280 to BASE+299) }
|
343 |
|
344 |
NERR_SourceIsDir = (NERR_BASE+280); { The source path cannot be a directory. }
|
345 |
NERR_BadSource = (NERR_BASE+281); { The source path is illegal. }
|
346 |
NERR_BadDest = (NERR_BASE+282); { The destination path is illegal. }
|
347 |
NERR_DifferentServers = (NERR_BASE+283); { The source and destination paths are on different servers. }
|
348 |
|
349 |
{ UNUSED BASE+284 }
|
350 |
|
351 |
NERR_RunSrvPaused = (NERR_BASE+285); { The Run server you requested is paused. }
|
352 |
|
353 |
{ UNUSED BASE+286 }
|
354 |
{ UNUSED BASE+287 }
|
355 |
{ UNUSED BASE+288 }
|
356 |
|
357 |
NERR_ErrCommRunSrv = (NERR_BASE+289); { An error occurred when communicating with a Run server. }
|
358 |
|
359 |
{ UNUSED BASE+290 }
|
360 |
|
361 |
NERR_ErrorExecingGhost = (NERR_BASE+291); { An error occurred when starting a background process. }
|
362 |
NERR_ShareNotFound = (NERR_BASE+292); { The shared resource you are connected to could not be found. }
|
363 |
|
364 |
{ UNUSED BASE+293 }
|
365 |
{ UNUSED BASE+294 }
|
366 |
|
367 |
{ NetWksta.sys (redir) returned error codes. (NERR_BASE + (300-329)) }
|
368 |
|
369 |
NERR_InvalidLana = (NERR_BASE+300); { The LAN adapter number is invalid. }
|
370 |
NERR_OpenFiles = (NERR_BASE+301); { There are open files on the connection. }
|
371 |
NERR_ActiveConns = (NERR_BASE+302); { Active connections still exist. }
|
372 |
NERR_BadPasswordCore = (NERR_BASE+303); { This share name or password is invalid. }
|
373 |
NERR_DevInUse = (NERR_BASE+304); { The device is being accessed by an active process. }
|
374 |
NERR_LocalDrive = (NERR_BASE+305); { The drive letter is in use locally. }
|
375 |
|
376 |
{ Alert error codes. (NERR_BASE + (330-339)) }
|
377 |
|
378 |
NERR_AlertExists = (NERR_BASE+330); { The specified client is already registered for the specified event. }
|
379 |
NERR_TooManyAlerts = (NERR_BASE+331); { The alert table is full. }
|
380 |
NERR_NoSuchAlert = (NERR_BASE+332); { An invalid or nonexistent alert name was raised. }
|
381 |
NERR_BadRecipient = (NERR_BASE+333); { The alert recipient is invalid. }
|
382 |
NERR_AcctLimitExceeded = (NERR_BASE+334); { A user's session with this server has been deleted }
|
383 |
{ because the user's logon hours are no longer valid. }
|
384 |
|
385 |
{ Additional Error and Audit log codes. (NERR_BASE +(340-343)) }
|
386 |
|
387 |
NERR_InvalidLogSeek = (NERR_BASE+340); { The log file does not contain the requested record number. }
|
388 |
|
389 |
{ UNUSED BASE+341 }
|
390 |
{ UNUSED BASE+342 }
|
391 |
{ UNUSED BASE+343 }
|
392 |
|
393 |
{ Additional UAS and NETLOGON codes (NERR_BASE +(350-359)) }
|
394 |
|
395 |
NERR_BadUasConfig = (NERR_BASE+350); { The user accounts database is not configured correctly. }
|
396 |
NERR_InvalidUASOp = (NERR_BASE+351); { This operation is not permitted when the Netlogon service is running. }
|
397 |
NERR_LastAdmin = (NERR_BASE+352); { This operation is not allowed on the last administrative account. }
|
398 |
NERR_DCNotFound = (NERR_BASE+353); { Could not find domain controller for this domain. }
|
399 |
NERR_LogonTrackingError = (NERR_BASE+354); { Could not set logon information for this user. }
|
400 |
NERR_NetlogonNotStarted = (NERR_BASE+355); { The Netlogon service has not been started. }
|
401 |
NERR_CanNotGrowUASFile = (NERR_BASE+356); { Unable to add to the user accounts database. }
|
402 |
NERR_TimeDiffAtDC = (NERR_BASE+357); { This server's clock is not synchronized with the primary domain controller's clock. }
|
403 |
NERR_PasswordMismatch = (NERR_BASE+358); { A password mismatch has been detected. }
|
404 |
|
405 |
{ Server Integration error codes. (NERR_BASE +(360-369)) }
|
406 |
|
407 |
NERR_NoSuchServer = (NERR_BASE+360); { The server identification does not specify a valid server. }
|
408 |
NERR_NoSuchSession = (NERR_BASE+361); { The session identification does not specify a valid session. }
|
409 |
NERR_NoSuchConnection = (NERR_BASE+362); { The connection identification does not specify a valid connection. }
|
410 |
NERR_TooManyServers = (NERR_BASE+363); { There is no space for another entry in the table of available servers. }
|
411 |
NERR_TooManySessions = (NERR_BASE+364); { The server has reached the maximum number of sessions it supports. }
|
412 |
NERR_TooManyConnections = (NERR_BASE+365); { The server has reached the maximum number of connections it supports. }
|
413 |
NERR_TooManyFiles = (NERR_BASE+366); { The server cannot open more files because it has reached its maximum number. }
|
414 |
NERR_NoAlternateServers = (NERR_BASE+367); { There are no alternate servers registered on this server. }
|
415 |
|
416 |
{ UNUSED BASE+368 }
|
417 |
{ UNUSED BASE+369 }
|
418 |
|
419 |
NERR_TryDownLevel = (NERR_BASE+370); { Try down-level (remote admin protocol) version of API instead. }
|
420 |
|
421 |
{ UPS error codes. (NERR_BASE + (380-384)) }
|
422 |
|
423 |
NERR_UPSDriverNotStarted= (NERR_BASE+380); { The UPS driver could not be accessed by the UPS service. }
|
424 |
NERR_UPSInvalidConfig = (NERR_BASE+381); { The UPS service is not configured correctly. }
|
425 |
NERR_UPSInvalidCommPort = (NERR_BASE+382); { The UPS service could not access the specified Comm Port. }
|
426 |
NERR_UPSSignalAsserted = (NERR_BASE+383); { The UPS indicated a line fail or low battery situation. Service not started. }
|
427 |
NERR_UPSShutdownFailed = (NERR_BASE+384); { The UPS service failed to perform a system shut down. }
|
428 |
|
429 |
{ Remoteboot error codes. (NERR_BASE + (400-419)) }
|
430 |
{ Error codes 400 - 405 are used by RPLBOOT.SYS. }
|
431 |
{ Error codes 403, 407 - 416 are used by RPLLOADR.COM, }
|
432 |
{ Error code 417 is the alerter message of REMOTEBOOT (RPLSERVR.EXE). }
|
433 |
{ Error code 418 is for when REMOTEBOOT can't start }
|
434 |
{ Error code 419 is for a disallowed 2nd rpl connection }
|
435 |
|
436 |
NERR_BadDosRetCode = (NERR_BASE+400); { The program below returned an MS-DOS error code: }
|
437 |
NERR_ProgNeedsExtraMem = (NERR_BASE+401); { The program below needs more memory: }
|
438 |
NERR_BadDosFunction = (NERR_BASE+402); { The program below called an unsupported MS-DOS function: }
|
439 |
NERR_RemoteBootFailed = (NERR_BASE+403); { The workstation failed to boot. }
|
440 |
NERR_BadFileCheckSum = (NERR_BASE+404); { The file below is corrupt. }
|
441 |
NERR_NoRplBootSystem = (NERR_BASE+405); { No loader is specified in the boot-block definition file. }
|
442 |
NERR_RplLoadrNetBiosErr = (NERR_BASE+406); { NetBIOS returned an error: The NCB and SMB are dumped above. }
|
443 |
NERR_RplLoadrDiskErr = (NERR_BASE+407); { A disk I/O error occurred. }
|
444 |
NERR_ImageParamErr = (NERR_BASE+408); { Image parameter substitution failed. }
|
445 |
NERR_TooManyImageParams = (NERR_BASE+409); { Too many image parameters cross disk sector boundaries. }
|
446 |
NERR_NonDosFloppyUsed = (NERR_BASE+410); { The image was not generated from an MS-DOS diskette formatted with /S. }
|
447 |
NERR_RplBootRestart = (NERR_BASE+411); { Remote boot will be restarted later. }
|
448 |
NERR_RplSrvrCallFailed = (NERR_BASE+412); { The call to the Remoteboot server failed. }
|
449 |
NERR_CantConnectRplSrvr = (NERR_BASE+413); { Cannot connect to the Remoteboot server. }
|
450 |
NERR_CantOpenImageFile = (NERR_BASE+414); { Cannot open image file on the Remoteboot server. }
|
451 |
NERR_CallingRplSrvr = (NERR_BASE+415); { Connecting to the Remoteboot server... }
|
452 |
NERR_StartingRplBoot = (NERR_BASE+416); { Connecting to the Remoteboot server... }
|
453 |
NERR_RplBootServiceTerm = (NERR_BASE+417); { Remote boot service was stopped; check the error log for the cause of the problem. }
|
454 |
NERR_RplBootStartFailed = (NERR_BASE+418); { Remote boot startup failed; check the error log for the cause of the problem. }
|
455 |
NERR_RPL_CONNECTED = (NERR_BASE+419); { A second connection to a Remoteboot resource is not allowed. }
|
456 |
|
457 |
{ FTADMIN API error codes (NERR_BASE + (425-434)) }
|
458 |
{ (Currently not used in NT) }
|
459 |
|
460 |
{ Browser service API error codes (NERR_BASE + (450-475)) }
|
461 |
|
462 |
NERR_BrowserConfiguredToNotRun= (NERR_BASE+450); { * The browser service was configured with MaintainServerList=No. }
|
463 |
|
464 |
{ Additional Remoteboot error codes. (NERR_BASE + (510-550)) }
|
465 |
|
466 |
NERR_RplNoAdaptersStarted = (NERR_BASE+510); { Service failed to start since none of the network adapters started with this service. }
|
467 |
NERR_RplBadRegistry = (NERR_BASE+511); { Service failed to start due to bad startup information in the registry. }
|
468 |
NERR_RplBadDatabase = (NERR_BASE+512); { Service failed to start because its database is absent or corrupt. }
|
469 |
NERR_RplRplfilesShare = (NERR_BASE+513); { Service failed to start because RPLFILES share is absent. }
|
470 |
NERR_RplNotRplServer = (NERR_BASE+514); { Service failed to start because RPLUSER group is absent. }
|
471 |
NERR_RplCannotEnum = (NERR_BASE+515); { Cannot enumerate service records. }
|
472 |
NERR_RplWkstaInfoCorrupted = (NERR_BASE+516); { Workstation record information has been corrupted. }
|
473 |
NERR_RplWkstaNotFound = (NERR_BASE+517); { Workstation record was not found. }
|
474 |
NERR_RplWkstaNameUnavailable = (NERR_BASE+518); { Workstation name is in use by some other workstation. }
|
475 |
NERR_RplProfileInfoCorrupted = (NERR_BASE+519); { Profile record information has been corrupted. }
|
476 |
NERR_RplProfileNotFound = (NERR_BASE+520); { Profile record was not found. }
|
477 |
NERR_RplProfileNameUnavailable = (NERR_BASE+521); { Profile name is in use by some other profile. }
|
478 |
NERR_RplProfileNotEmpty = (NERR_BASE+522); { There are workstations using this profile. }
|
479 |
NERR_RplConfigInfoCorrupted = (NERR_BASE+523); { Configuration record information has been corrupted. }
|
480 |
NERR_RplConfigNotFound = (NERR_BASE+524); { Configuration record was not found. }
|
481 |
NERR_RplAdapterInfoCorrupted = (NERR_BASE+525); { Adapter id record information has been corrupted. }
|
482 |
NERR_RplInternal = (NERR_BASE+526); { An internal service error has occured. }
|
483 |
NERR_RplVendorInfoCorrupted = (NERR_BASE+527); { Vendor id record information has been corrupted. }
|
484 |
NERR_RplBootInfoCorrupted = (NERR_BASE+528); { Boot block record information has been corrupted. }
|
485 |
NERR_RplWkstaNeedsUserAcct = (NERR_BASE+529); { The user account for this workstation record is missing. }
|
486 |
NERR_RplNeedsRPLUSERAcct = (NERR_BASE+530); { The RPLUSER local group could not be found. }
|
487 |
NERR_RplBootNotFound = (NERR_BASE+531); { Boot block record was not found. }
|
488 |
NERR_RplIncompatibleProfile = (NERR_BASE+532); { Chosen profile is incompatible with this workstation. }
|
489 |
NERR_RplAdapterNameUnavailable = (NERR_BASE+533); { Chosen network adapter id is in use by some other workstation. }
|
490 |
NERR_RplConfigNotEmpty = (NERR_BASE+534); { There are profiles using this configuration. }
|
491 |
NERR_RplBootInUse = (NERR_BASE+535); { There are workstations, profiles or configurations using this boot block. }
|
492 |
NERR_RplBackupDatabase = (NERR_BASE+536); { Service failed to backup remoteboot database. }
|
493 |
NERR_RplAdapterNotFound = (NERR_BASE+537); { Adapter record was not found. }
|
494 |
NERR_RplVendorNotFound = (NERR_BASE+538); { Vendor record was not found. }
|
495 |
NERR_RplVendorNameUnavailable = (NERR_BASE+539); { Vendor name is in use by some other vendor record. }
|
496 |
NERR_RplBootNameUnavailable = (NERR_BASE+540); { (boot name, vendor id) is in use by some other boot block record. }
|
497 |
NERR_RplConfigNameUnavailable = (NERR_BASE+541); { Configuration name is in use by some other configuration. }
|
498 |
|
499 |
{ INTERNAL_ONLY }
|
500 |
|
501 |
{ Dfs API error codes. (NERR_BASE + (560-590)) }
|
502 |
|
503 |
NERR_DfsInternalCorruption = (NERR_BASE+560); { The internal database maintained by the Dfs service is corrupt }
|
504 |
NERR_DfsVolumeDataCorrupt = (NERR_BASE+561); { One of the records in the internal Dfs database is corrupt }
|
505 |
NERR_DfsNoSuchVolume = (NERR_BASE+562); { There is no volume whose entry path matches the input Entry Path }
|
506 |
NERR_DfsVolumeAlreadyExists = (NERR_BASE+563); { A volume with the given name already exists }
|
507 |
NERR_DfsAlreadyShared = (NERR_BASE+564); { The server share specified is already shared in the Dfs }
|
508 |
NERR_DfsNoSuchShare = (NERR_BASE+565); { The indicated server share does not support the indicated Dfs volume }
|
509 |
NERR_DfsNotALeafVolume = (NERR_BASE+566); { The operation is not valid on a non-leaf volume }
|
510 |
NERR_DfsLeafVolume = (NERR_BASE+567); { The operation is not valid on a leaf volume }
|
511 |
NERR_DfsVolumeHasMultipleServers = (NERR_BASE+568); { The operation is ambiguous because the volume has multiple servers }
|
512 |
NERR_DfsCantCreateJunctionPoint= (NERR_BASE+569); { Unable to create a junction point }
|
513 |
NERR_DfsServerNotDfsAware = (NERR_BASE+570); { The server is not Dfs Aware }
|
514 |
NERR_DfsBadRenamePath = (NERR_BASE+571); { The specified rename target path is invalid }
|
515 |
NERR_DfsVolumeIsOffline = (NERR_BASE+572); { The specified Dfs volume is offline }
|
516 |
NERR_DfsNoSuchServer = (NERR_BASE+573); { The specified server is not a server for this volume }
|
517 |
NERR_DfsCyclicalName = (NERR_BASE+574); { A cycle in the Dfs name was detected }
|
518 |
NERR_DfsNotSupportedInServerDfs= (NERR_BASE+575); { The operation is not supported on a server-based Dfs }
|
519 |
NERR_DfsInternalError = (NERR_BASE+590); { Dfs internal error }
|
520 |
|
521 |
{ ***********WARNING **************** }
|
522 |
{ *The range 2750-2799 has been * }
|
523 |
{ *allocated to the IBM LAN Server * }
|
524 |
{ *********************************** }
|
525 |
|
526 |
{ ***********WARNING **************** }
|
527 |
{ *The range 2900-2999 has been * }
|
528 |
{ *reserved for Microsoft OEMs * }
|
529 |
{ *********************************** }
|
530 |
|
531 |
{ END_INTERNAL* }
|
532 |
|
533 |
MAX_NERR = (NERR_BASE+899); { This is the last error in NERR range. }
|
534 |
|
535 |
{ WARNING: Do not exceed MAX_NERR; values above this are used by }
|
536 |
{ other error code ranges (errlog.h, service.h, apperr.h). }
|
537 |
|
538 |
|
539 |
{-------------------- LMCONS.H ----------------------------------------------}
|
540 |
const
|
541 |
CNLEN = 15; { Computer name length }
|
542 |
LM20_CNLEN = 15; { LM 2.0 Computer name length }
|
543 |
DNLEN = CNLEN; { Maximum domain name length }
|
544 |
LM20_DNLEN = LM20_CNLEN; { LM 2.0 Maximum domain name length }
|
545 |
|
546 |
UNCLEN = (CNLEN+2); { UNC computer name length }
|
547 |
LM20_UNCLEN = (LM20_CNLEN+2); { LM 2.0 UNC computer name length }
|
548 |
|
549 |
NNLEN = 80; { Net name length (share name) }
|
550 |
LM20_NNLEN = 12; { LM 2.0 Net name length }
|
551 |
|
552 |
RMLEN = (UNCLEN+1+NNLEN); { Max remote name length }
|
553 |
LM20_RMLEN = (LM20_UNCLEN+1+LM20_NNLEN); { LM 2.0 Max remote name length }
|
554 |
|
555 |
SNLEN = 80; { Service name length }
|
556 |
LM20_SNLEN = 15; { LM 2.0 Service name length }
|
557 |
STXTLEN = 256; { Service text length }
|
558 |
LM20_STXTLEN= 63; { LM 2.0 Service text length }
|
559 |
|
560 |
PATHLEN = 256; { Max. path (not including drive name) }
|
561 |
LM20_PATHLEN= 256; { LM 2.0 Max. path }
|
562 |
|
563 |
DEVLEN = 80; { Device name length }
|
564 |
LM20_DEVLEN = 8; { LM 2.0 Device name length }
|
565 |
|
566 |
EVLEN = 16; { Event name length }
|
567 |
|
568 |
|
569 |
{ User, Group and Password lengths }
|
570 |
|
571 |
|
572 |
UNLEN = 256; { Maximum user name length }
|
573 |
LM20_UNLEN = 20; { LM 2.0 Maximum user name length }
|
574 |
|
575 |
GNLEN = UNLEN; { Group name }
|
576 |
LM20_GNLEN = LM20_UNLEN; { LM 2.0 Group name }
|
577 |
|
578 |
PWLEN = 256; { Maximum password length }
|
579 |
LM20_PWLEN = 14; { LM 2.0 Maximum password length }
|
580 |
|
581 |
SHPWLEN = 8; { Share password length (bytes) }
|
582 |
|
583 |
CLTYPE_LEN = 12; { Length of client type string }
|
584 |
|
585 |
MAXCOMMENTSZ = 256; { Multipurpose comment length }
|
586 |
LM20_MAXCOMMENTSZ = 48; { LM 2.0 Multipurpose comment length }
|
587 |
|
588 |
QNLEN = NNLEN; { Queue name maximum length }
|
589 |
LM20_QNLEN = LM20_NNLEN; { LM 2.0 Queue name maximum length }
|
590 |
|
591 |
{ The ALERTSZ and MAXDEVENTRIES defines have not yet been NT'ized. }
|
592 |
{ Whoever ports these components should change these values appropriately. }
|
593 |
|
594 |
ALERTSZ = 128; { size of alert string in server }
|
595 |
MAXDEVENTRIES = SizeOf(Integer)*8;{ Max number of device entries }
|
596 |
|
597 |
NETBIOS_NAME_LEN = 16; { NetBIOS net name (bytes) }
|
598 |
|
599 |
{ Value to be used with APIs which have a "preferred maximum length" }
|
600 |
{ parameter. This value indicates that the API should just allocate }
|
601 |
{ "as much as it takes." }
|
602 |
|
603 |
MAX_PREFERRED_LENGTH = DWord(-1);
|
604 |
|
605 |
{ Constants used with encryption }
|
606 |
|
607 |
CRYPT_KEY_LEN = 7;
|
608 |
CRYPT_TXT_LEN = 8;
|
609 |
ENCRYPTED_PWLEN = 16;
|
610 |
SESSION_PWLEN = 24;
|
611 |
SESSION_CRYPT_KLEN = 21;
|
612 |
|
613 |
{ Value to be used with SetInfo calls to allow setting of all }
|
614 |
{ settable parameters (parmnum zero option) }
|
615 |
PARMNUM_ALL = 0;
|
616 |
|
617 |
PARM_ERROR_UNKNOWN = DWord(-1);
|
618 |
PARM_ERROR_NONE = 0;
|
619 |
PARMNUM_BASE_INFOLEVEL = 1000;
|
620 |
|
621 |
{ Message File Names }
|
622 |
|
623 |
MESSAGE_FILENAME = 'NETMSG';
|
624 |
OS2MSG_FILENAME = 'BASE';
|
625 |
HELP_MSG_FILENAME = 'NETH';
|
626 |
|
627 |
{**INTERNAL_ONLY }
|
628 |
|
629 |
{ The backup message file named here is a duplicate of net.msg. It }
|
630 |
{ is not shipped with the product, but is used at buildtime to }
|
631 |
{ msgbind certain messages to netapi.dll and some of the services. }
|
632 |
{ This allows for OEMs to modify the message text in net.msg and }
|
633 |
{ have those changes show up. Only in case there is an error in }
|
634 |
{ retrieving the messages from net.msg do we then get the bound }
|
635 |
{ messages out of bak.msg (really out of the message segment). }
|
636 |
|
637 |
BACKUP_MSG_FILENAME = 'BAK.MSG';
|
638 |
|
639 |
{**END_INTERNAL }
|
640 |
|
641 |
{ Keywords used in Function Prototypes }
|
642 |
|
643 |
type
|
644 |
NET_API_STATUS = DWord;
|
645 |
API_RET_TYPE = NET_API_STATUS; { Old value: do not use }
|
646 |
|
647 |
{ The platform ID indicates the levels to use for platform-specific }
|
648 |
{ information. }
|
649 |
|
650 |
const
|
651 |
PLATFORM_ID_DOS = 300;
|
652 |
PLATFORM_ID_OS2 = 400;
|
653 |
PLATFORM_ID_NT = 500;
|
654 |
PLATFORM_ID_OSF = 600;
|
655 |
PLATFORM_ID_VMS = 700;
|
656 |
|
657 |
{ There message numbers assigned to different LANMAN components }
|
658 |
{ are as defined below. }
|
659 |
|
660 |
{ lmerr.h: 2100 - 2999 NERR_BASE }
|
661 |
{ alertmsg.h: 3000 - 3049 ALERT_BASE }
|
662 |
{ lmsvc.h: 3050 - 3099 SERVICE_BASE }
|
663 |
{ lmerrlog.h: 3100 - 3299 ERRLOG_BASE }
|
664 |
{ msgtext.h: 3300 - 3499 MTXT_BASE }
|
665 |
{ apperr.h: 3500 - 3999 APPERR_BASE }
|
666 |
{ apperrfs.h: 4000 - 4299 APPERRFS_BASE }
|
667 |
{ apperr2.h: 4300 - 5299 APPERR2_BASE }
|
668 |
{ ncberr.h: 5300 - 5499 NRCERR_BASE }
|
669 |
{ alertmsg.h: 5500 - 5599 ALERT2_BASE }
|
670 |
{ lmsvc.h: 5600 - 5699 SERVICE2_BASE }
|
671 |
{ lmerrlog.h 5700 - 5799 ERRLOG2_BASE }
|
672 |
|
673 |
MIN_LANMAN_MESSAGE_ID = NERR_BASE;
|
674 |
MAX_LANMAN_MESSAGE_ID = 5799;
|
675 |
|
676 |
{-------------------- LMACCESS.H --------------------------------------------}
|
677 |
type
|
678 |
TNetUserAdd = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
679 |
TNetUserEnum = function(ServerName: LPCWSTR; Level, Filter: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
680 |
TNetUserGetInfo = function(ServerName, UserName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
681 |
TNetUserSetInfo = function(ServerName, UserName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
682 |
TNetUserDel = function(ServerName, UserName: LPCWSTR): NET_API_STATUS; stdcall;
|
683 |
TNetUserGetGroups = function(ServerName, UserName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries : DWord): NET_API_STATUS; stdcall;
|
684 |
TNetUserSetGroups = function(ServerName, UserName: LPCWSTR; Level: DWord; Buffer: Pointer; NumEntries: DWord): NET_API_STATUS; stdcall;
|
685 |
TNetUserGetLocalGroups = function(ServerName, UserName: LPCWSTR; Level: DWord; Flags: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries : DWord): NET_API_STATUS; stdcall;
|
686 |
TNetUserModalsGet = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
687 |
TNetUserModalsSet = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
688 |
TNetUserChangePassword = function(DomainName, UserName, OldPassword, NewPassword: LPCWSTR): NET_API_STATUS; stdcall;
|
689 |
|
690 |
TNetGroupAdd = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
691 |
TNetGroupAddUser = function(ServerName, GroupName, UserName: LPCWSTR): NET_API_STATUS; stdcall;
|
692 |
TNetGroupEnum = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
693 |
TNetGroupGetInfo = function(ServerName, GroupName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
694 |
TNetGroupSetInfo = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
695 |
TNetGroupDel = function(ServerName, GroupName: LPCWSTR): NET_API_STATUS; stdcall;
|
696 |
TNetGroupDelUser = function(ServerName, GroupName, UserName: LPCWSTR): NET_API_STATUS; stdcall;
|
697 |
TNetGroupGetUsers = function(ServerName, GroupName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: Pointer): NET_API_STATUS; stdcall;
|
698 |
TNetGroupSetUsers = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; var TotalEntries : DWord): NET_API_STATUS; stdcall;
|
699 |
|
700 |
TNetLocalGroupAdd = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
701 |
TNetLocalGroupAddMember = function(ServerName, GroupName: LPCWSTR; MembersID: PSID): NET_API_STATUS; stdcall;
|
702 |
TNetLocalGroupEnum = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; var ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
703 |
TNetLocalGroupGetInfo = function(ServerName, GroupName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
704 |
TNetLocalGroupSetInfo = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
705 |
TNetLocalGroupDel = function(ServerName, GroupName: LPCWSTR): NET_API_STATUS; stdcall;
|
706 |
TNetLocalGroupDelMember = function(ServerName, GroupName: LPCWSTR; MembersID: PSID): NET_API_STATUS; stdcall;
|
707 |
TNetLocalGroupGetMembers = function(ServerName, GroupName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: Pointer): NET_API_STATUS; stdcall;
|
708 |
TNetLocalGroupSetMembers = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; var TotalEntries: DWord): NET_API_STATUS; stdcall;
|
709 |
TNetLocalGroupAddMembers = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; TotalEntries: DWord): NET_API_STATUS; stdcall;
|
710 |
TNetLocalGroupDelMembers = function(ServerName, GroupName: LPCWSTR; Level: DWord; Buffer: Pointer; TotalEntries: DWord): NET_API_STATUS; stdcall;
|
711 |
|
712 |
TNetQueryDisplayInformation = function(ServerName: LPCWSTR; Level, Index, EntriesRequested, PrefMaxLen: DWord; var ReturnedCount: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
713 |
TNetGetDisplayInformationIndex = function(ServerName: LPCWSTR; Level: DWord; Prefix: LPCWSTR; var Index: DWord): NET_API_STATUS; stdcall;
|
714 |
|
715 |
TNetAccessAdd = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
716 |
TNetAccessEnum = function(ServerName, BasePath: LPCWSTR; Recursive, Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
717 |
TNetAccessGetInfo = function(ServerName, Resource: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
718 |
TNetAccessSetInfo = function(ServerName, Resource: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
719 |
TNetAccessDel = function(ServerName, Resource: LPCWSTR): NET_API_STATUS; stdcall;
|
720 |
TNetAccessGetUserPerms = function(ServerName, UGname, Resource: LPCWSTR; var Perms: DWord): NET_API_STATUS; stdcall;
|
721 |
|
722 |
TNetGetDCName = function(ServerName, DomainName: LPCWSTR; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
723 |
TNetGetAnyDCName = function(ServerName, DomainName: LPCWSTR; var Buffer: PByte): NET_API_STATUS; stdcall;
|
724 |
TI_NetLogonControl = function(ServerName: LPCWSTR; FunctionCode, QueryLevel: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
725 |
TI_NetLogonControl2 = function(ServerName: LPCWSTR; FunctionCode, QueryLevel: DWord; Data: Pointer; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
726 |
TNetEnumerateTrustedDomains = function(ServerName: LPCWSTR; var Buffer: Pointer): LongInt; StdCall;
|
727 |
|
728 |
const
|
729 |
USER_POSIX_ID_PARMNUM = 1;
|
730 |
GROUP_POSIX_ID_PARMNUM = 1;
|
731 |
|
732 |
type
|
733 |
PUSER_INFO_0 = ^TUSER_INFO_0;
|
734 |
TUSER_INFO_0 = record
|
735 |
usri0_name : LPWSTR;
|
736 |
end;
|
737 |
|
738 |
PUSER_INFO_1 = ^TUSER_INFO_1;
|
739 |
TUSER_INFO_1 = record
|
740 |
usri1_name : LPWSTR;
|
741 |
usri1_password : LPWSTR{LPSTR};
|
742 |
usri1_password_age : DWord;
|
743 |
usri1_priv : DWord;
|
744 |
usri1_home_dir : LPWSTR;
|
745 |
usri1_comment : LPWSTR;
|
746 |
usri1_flags : DWord;
|
747 |
usri1_script_path : LPWSTR;
|
748 |
end;
|
749 |
|
750 |
PUSER_INFO_2 = ^TUSER_INFO_2;
|
751 |
TUSER_INFO_2 = record
|
752 |
usri2_name : LPWSTR;
|
753 |
usri2_password : LPWSTR;
|
754 |
usri2_password_age : DWord;
|
755 |
usri2_priv : DWord;
|
756 |
usri2_home_dir : LPWSTR;
|
757 |
usri2_comment : LPWSTR;
|
758 |
usri2_flags : DWord;
|
759 |
usri2_script_path : LPWSTR;
|
760 |
usri2_auth_flags : DWord;
|
761 |
usri2_full_name : LPWSTR;
|
762 |
usri2_usr_comment : LPWSTR;
|
763 |
usri2_parms : LPWSTR;
|
764 |
usri2_workstations : LPWSTR;
|
765 |
usri2_last_logon : DWord;
|
766 |
usri2_last_logoff : DWord;
|
767 |
usri2_acct_expires : DWord;
|
768 |
usri2_max_storage : DWord;
|
769 |
usri2_units_per_week : DWord;
|
770 |
usri2_logon_hours : PByte;
|
771 |
usri2_bad_pw_count : DWord;
|
772 |
usri2_num_logons : DWord;
|
773 |
usri2_logon_server : LPWSTR;
|
774 |
usri2_country_code : DWord;
|
775 |
usri2_code_page : DWord;
|
776 |
end;
|
777 |
|
778 |
PUSER_INFO_3 = ^TUSER_INFO_3;
|
779 |
TUSER_INFO_3 = record
|
780 |
usri3_name : LPWSTR;
|
781 |
usri3_password : LPWSTR;
|
782 |
usri3_password_age : DWord;
|
783 |
usri3_priv : DWord;
|
784 |
usri3_home_dir : LPWSTR;
|
785 |
usri3_comment : LPWSTR;
|
786 |
usri3_flags : DWord;
|
787 |
usri3_script_path : LPWSTR;
|
788 |
usri3_auth_flags : DWord;
|
789 |
usri3_full_name : LPWSTR;
|
790 |
usri3_usr_comment : LPWSTR;
|
791 |
usri3_parms : LPWSTR;
|
792 |
usri3_workstations : LPWSTR;
|
793 |
usri3_last_logon : DWord;
|
794 |
usri3_last_logoff : DWord;
|
795 |
usri3_acct_expires : DWord;
|
796 |
usri3_max_storage : DWord;
|
797 |
usri3_units_per_week : DWord;
|
798 |
usri3_logon_hours : Pointer;
|
799 |
usri3_bad_pw_count : DWord;
|
800 |
usri3_num_logons : DWord;
|
801 |
usri3_logon_server : LPWSTR;
|
802 |
usri3_country_code : DWord;
|
803 |
usri3_code_page : DWord;
|
804 |
usri3_user_id : DWord;
|
805 |
usri3_primary_group_id: DWord;
|
806 |
usri3_profile : LPWSTR;
|
807 |
usri3_home_dir_drive : LPWSTR;
|
808 |
usri3_password_expired: DWord;
|
809 |
end;
|
810 |
|
811 |
PUSER_INFO_10 = ^TUSER_INFO_10;
|
812 |
TUSER_INFO_10 = record
|
813 |
usri10_name : LPWSTR;
|
814 |
usri10_comment : LPWSTR;
|
815 |
usri10_usr_comment : LPWSTR;
|
816 |
usri10_full_name : LPWSTR;
|
817 |
end;
|
818 |
|
819 |
PUSER_INFO_11 = ^TUSER_INFO_11;
|
820 |
TUSER_INFO_11 = record
|
821 |
usri11_name : LPWSTR;
|
822 |
usri11_comment : LPWSTR;
|
823 |
usri11_usr_comment : LPWSTR;
|
824 |
usri11_full_name : LPWSTR;
|
825 |
usri11_priv : DWord;
|
826 |
usri11_auth_flags : DWord;
|
827 |
usri11_password_age : DWord;
|
828 |
usri11_home_dir : LPWSTR;
|
829 |
usri11_parms : LPWSTR;
|
830 |
usri11_last_logon : DWord;
|
831 |
usri11_last_logoff : DWord;
|
832 |
usri11_bad_pw_count : DWord;
|
833 |
usri11_num_logons : DWord;
|
834 |
usri11_logon_server : LPWSTR;
|
835 |
usri11_country_code : DWord;
|
836 |
usri11_workstations : LPWSTR;
|
837 |
usri11_max_storage : DWord;
|
838 |
usri11_units_per_week : DWord;
|
839 |
usri11_logon_hours : PByte;
|
840 |
usri11_code_page : DWord;
|
841 |
end;
|
842 |
|
843 |
PUSER_INFO_20 = ^TUSER_INFO_20;
|
844 |
TUSER_INFO_20 = record
|
845 |
usri20_name : LPWSTR;
|
846 |
usri20_full_name : LPWSTR;
|
847 |
usri20_comment : LPWSTR;
|
848 |
usri20_flags : DWord;
|
849 |
usri20_user_id : DWord;
|
850 |
end;
|
851 |
|
852 |
PUSER_INFO_21 = ^TUSER_INFO_21;
|
853 |
TUSER_INFO_21 = record
|
854 |
usri21_password : array[0..ENCRYPTED_PWLEN-1] of byte;
|
855 |
end;
|
856 |
|
857 |
PUSER_INFO_22 = ^TUSER_INFO_22;
|
858 |
TUSER_INFO_22 = record
|
859 |
usri22_name : LPWSTR;
|
860 |
usri22_password : array[0..ENCRYPTED_PWLEN-1] of byte;
|
861 |
usri22_password_age : DWord;
|
862 |
usri22_priv : DWord;
|
863 |
usri22_home_dir : LPWSTR;
|
864 |
usri22_comment : LPWSTR;
|
865 |
usri22_flags : DWord;
|
866 |
usri22_script_path : LPWSTR;
|
867 |
usri22_auth_flags : DWord;
|
868 |
usri22_full_name : LPWSTR;
|
869 |
usri22_usr_comment : LPWSTR;
|
870 |
usri22_parms : LPWSTR;
|
871 |
usri22_workstations : LPWSTR;
|
872 |
usri22_last_logon : DWord;
|
873 |
usri22_last_logoff : DWord;
|
874 |
usri22_acct_expires : DWord;
|
875 |
usri22_max_storage : DWord;
|
876 |
usri22_units_per_week : DWord;
|
877 |
usri22_logon_hours : PByte;
|
878 |
usri22_bad_pw_count : DWord;
|
879 |
usri22_num_logons : DWord;
|
880 |
usri22_logon_server : LPWSTR;
|
881 |
usri22_country_code : DWord;
|
882 |
usri22_code_page : DWord;
|
883 |
end;
|
884 |
|
885 |
PUSER_INFO_1003 = ^TUSER_INFO_1003;
|
886 |
TUSER_INFO_1003 = record
|
887 |
usri1003_password: LPWSTR;
|
888 |
end;
|
889 |
|
890 |
PUSER_INFO_1005 = ^TUSER_INFO_1005;
|
891 |
TUSER_INFO_1005 = record
|
892 |
usri1005_priv : DWord;
|
893 |
end;
|
894 |
|
895 |
PUSER_INFO_1006 = ^TUSER_INFO_1006;
|
896 |
TUSER_INFO_1006 = record
|
897 |
usri1006_home_dir: LPWSTR;
|
898 |
end;
|
899 |
|
900 |
PUSER_INFO_1007 = ^TUSER_INFO_1007;
|
901 |
TUSER_INFO_1007 = record
|
902 |
usri1007_comment : LPWSTR;
|
903 |
end;
|
904 |
|
905 |
PUSER_INFO_1008 = ^TUSER_INFO_1008;
|
906 |
TUSER_INFO_1008 = record
|
907 |
usri1008_flags: DWord;
|
908 |
end;
|
909 |
|
910 |
PUSER_INFO_1009 = ^TUSER_INFO_1009;
|
911 |
TUSER_INFO_1009 = record
|
912 |
usri1009_script_path: LPWSTR;
|
913 |
end;
|
914 |
|
915 |
PUSER_INFO_1010 = ^TUSER_INFO_1010;
|
916 |
TUSER_INFO_1010 = record
|
917 |
usri1010_auth_flags: DWord;
|
918 |
end;
|
919 |
|
920 |
PUSER_INFO_1011 = ^TUSER_INFO_1011;
|
921 |
TUSER_INFO_1011 = record
|
922 |
usri1011_full_name : LPWSTR;
|
923 |
end;
|
924 |
|
925 |
PUSER_INFO_1012 = ^TUSER_INFO_1012;
|
926 |
TUSER_INFO_1012 = record
|
927 |
usri1012_usr_comment : LPWSTR;
|
928 |
end;
|
929 |
|
930 |
PUSER_INFO_1013 = ^TUSER_INFO_1013;
|
931 |
TUSER_INFO_1013 = record
|
932 |
usri1013_parms : LPWSTR;
|
933 |
end;
|
934 |
|
935 |
PUSER_INFO_1014 = ^TUSER_INFO_1014;
|
936 |
TUSER_INFO_1014 = record
|
937 |
usri1014_workstations : LPWSTR;
|
938 |
end;
|
939 |
|
940 |
PUSER_INFO_1017 = ^TUSER_INFO_1017;
|
941 |
TUSER_INFO_1017 = record
|
942 |
usri1017_acct_expires : DWord;
|
943 |
end;
|
944 |
|
945 |
PUSER_INFO_1018 = ^TUSER_INFO_1018;
|
946 |
TUSER_INFO_1018 = record
|
947 |
usri1018_max_storage: DWord;
|
948 |
end;
|
949 |
|
950 |
PUSER_INFO_1020 = ^TUSER_INFO_1020;
|
951 |
TUSER_INFO_1020 = record
|
952 |
usri1020_units_per_week : DWord;
|
953 |
usri1020_logon_hours: PByte;
|
954 |
end;
|
955 |
|
956 |
PUSER_INFO_1023 = ^TUSER_INFO_1023;
|
957 |
TUSER_INFO_1023 = record
|
958 |
usri1023_logon_server : LPWSTR;
|
959 |
end;
|
960 |
|
961 |
PUSER_INFO_1024 = ^TUSER_INFO_1024;
|
962 |
TUSER_INFO_1024 = record
|
963 |
usri1024_country_code: DWord;
|
964 |
end;
|
965 |
|
966 |
PUSER_INFO_1025 = ^TUSER_INFO_1025;
|
967 |
TUSER_INFO_1025 = record
|
968 |
usri1025_code_page: DWord;
|
969 |
end;
|
970 |
|
971 |
PUSER_INFO_1051 = ^TUSER_INFO_1051;
|
972 |
TUSER_INFO_1051 = record
|
973 |
usri1051_primary_group_id: DWord;
|
974 |
end;
|
975 |
|
976 |
PUSER_INFO_1052 = ^TUSER_INFO_1052;
|
977 |
TUSER_INFO_1052 = record
|
978 |
usri1052_profile : LPWSTR;
|
979 |
end;
|
980 |
|
981 |
PUSER_INFO_1053 = ^TUSER_INFO_1053;
|
982 |
TUSER_INFO_1053 = record
|
983 |
usri1053_home_dir_drive : LPWSTR;
|
984 |
end;
|
985 |
|
986 |
PUSER_MODALS_INFO_0 = ^TUSER_MODALS_INFO_0;
|
987 |
TUSER_MODALS_INFO_0 = record
|
988 |
usrmod0_min_passwd_len : DWord;
|
989 |
usrmod0_max_passwd_age : DWord;
|
990 |
usrmod0_min_passwd_age : DWord;
|
991 |
usrmod0_force_logoff : DWord;
|
992 |
usrmod0_password_hist_len : DWord;
|
993 |
end;
|
994 |
|
995 |
PUSER_MODALS_INFO_1 = ^TUSER_MODALS_INFO_1;
|
996 |
TUSER_MODALS_INFO_1 = record
|
997 |
usrmod1_role : DWord;
|
998 |
usrmod1_primary : LPWSTR;
|
999 |
end;
|
1000 |
|
1001 |
PUSER_MODALS_INFO_2 = ^TUSER_MODALS_INFO_2;
|
1002 |
TUSER_MODALS_INFO_2 = record
|
1003 |
usrmod2_domain_name : LPWSTR;
|
1004 |
usrmod2_domain_id : PSID;
|
1005 |
end;
|
1006 |
|
1007 |
PUSER_MODALS_INFO_3 = ^TUSER_MODALS_INFO_3;
|
1008 |
TUSER_MODALS_INFO_3 = record
|
1009 |
usrmod3_lockout_duration : DWord;
|
1010 |
usrmod3_lockout_observation_window : DWord;
|
1011 |
usrmod3_lockout_threshold : DWord;
|
1012 |
end;
|
1013 |
|
1014 |
PUSER_MODALS_INFO_1001 = ^TUSER_MODALS_INFO_1001;
|
1015 |
TUSER_MODALS_INFO_1001 = record
|
1016 |
usrmod1001_min_passwd_len : DWord;
|
1017 |
end;
|
1018 |
|
1019 |
PUSER_MODALS_INFO_1002 = ^TUSER_MODALS_INFO_1002;
|
1020 |
TUSER_MODALS_INFO_1002 = record
|
1021 |
usrmod1002_max_passwd_age : DWord;
|
1022 |
end;
|
1023 |
|
1024 |
PUSER_MODALS_INFO_1003 = ^TUSER_MODALS_INFO_1003;
|
1025 |
TUSER_MODALS_INFO_1003 = record
|
1026 |
usrmod1003_min_passwd_age : DWord;
|
1027 |
end;
|
1028 |
|
1029 |
PUSER_MODALS_INFO_1004 = ^TUSER_MODALS_INFO_1004;
|
1030 |
TUSER_MODALS_INFO_1004 = record
|
1031 |
usrmod1004_force_logoff : DWord;
|
1032 |
end;
|
1033 |
|
1034 |
PUSER_MODALS_INFO_1005 = ^TUSER_MODALS_INFO_1005;
|
1035 |
TUSER_MODALS_INFO_1005 = record
|
1036 |
usrmod1005_password_hist_len : DWord;
|
1037 |
end;
|
1038 |
|
1039 |
PUSER_MODALS_INFO_1006 = ^TUSER_MODALS_INFO_1006;
|
1040 |
TUSER_MODALS_INFO_1006 = record
|
1041 |
usrmod1006_role : DWord;
|
1042 |
end;
|
1043 |
|
1044 |
PUSER_MODALS_INFO_1007 = ^TUSER_MODALS_INFO_1007;
|
1045 |
TUSER_MODALS_INFO_1007 = record
|
1046 |
usrmod1007_primary : LPWSTR;
|
1047 |
end;
|
1048 |
|
1049 |
const
|
1050 |
{ Bit masks for field usriX_flags of USER_INFO_X (X = 0/1). }
|
1051 |
UF_SCRIPT = $0001;
|
1052 |
UF_ACCOUNTDISABLE = $0002;
|
1053 |
UF_HOMEDIR_REQUIRED = $0008;
|
1054 |
UF_LOCKOUT = $0010;
|
1055 |
UF_PASSWD_NOTREQD = $0020;
|
1056 |
UF_PASSWD_CANT_CHANGE = $0040;
|
1057 |
|
1058 |
{ Account type bits as part of usri_flags. }
|
1059 |
UF_TEMP_DUPLICATE_ACCOUNT = $0100;
|
1060 |
UF_NORMAL_ACCOUNT = $0200;
|
1061 |
UF_INTERDOMAIN_TRUST_ACCOUNT = $0800;
|
1062 |
UF_WORKSTATION_TRUST_ACCOUNT = $1000;
|
1063 |
UF_SERVER_TRUST_ACCOUNT = $2000;
|
1064 |
|
1065 |
UF_MACHINE_ACCOUNT_MASK = (UF_INTERDOMAIN_TRUST_ACCOUNT or
|
1066 |
UF_WORKSTATION_TRUST_ACCOUNT or
|
1067 |
UF_SERVER_TRUST_ACCOUNT);
|
1068 |
|
1069 |
UF_ACCOUNT_TYPE_MASK = (UF_TEMP_DUPLICATE_ACCOUNT or
|
1070 |
UF_NORMAL_ACCOUNT or
|
1071 |
UF_INTERDOMAIN_TRUST_ACCOUNT or
|
1072 |
UF_WORKSTATION_TRUST_ACCOUNT or
|
1073 |
UF_SERVER_TRUST_ACCOUNT);
|
1074 |
|
1075 |
UF_DONT_EXPIRE_PASSWD = $10000;
|
1076 |
UF_MNS_LOGON_ACCOUNT = $20000;
|
1077 |
|
1078 |
|
1079 |
UF_SETTABLE_BITS = (UF_SCRIPT or
|
1080 |
UF_ACCOUNTDISABLE or
|
1081 |
UF_LOCKOUT or
|
1082 |
UF_HOMEDIR_REQUIRED or
|
1083 |
UF_PASSWD_NOTREQD or
|
1084 |
UF_PASSWD_CANT_CHANGE or
|
1085 |
UF_ACCOUNT_TYPE_MASK or
|
1086 |
UF_DONT_EXPIRE_PASSWD or
|
1087 |
UF_MNS_LOGON_ACCOUNT);
|
1088 |
|
1089 |
{ bit masks for the NetUserEnum filter parameter. }
|
1090 |
FILTER_TEMP_DUPLICATE_ACCOUNT = $0001;
|
1091 |
FILTER_NORMAL_ACCOUNT = $0002;
|
1092 |
{FILTER_PROXY_ACCOUNT = $0004;}
|
1093 |
FILTER_INTERDOMAIN_TRUST_ACCOUNT = $0008;
|
1094 |
FILTER_WORKSTATION_TRUST_ACCOUNT = $0010;
|
1095 |
FILTER_SERVER_TRUST_ACCOUNT = $0020;
|
1096 |
|
1097 |
{ bit masks for the NetUserGetLocalGroups flags }
|
1098 |
LG_INCLUDE_INDIRECT = $0001;
|
1099 |
|
1100 |
{ Bit masks for field usri2_auth_flags of USER_INFO_2. }
|
1101 |
AF_OP_PRINT = $1;
|
1102 |
AF_OP_COMM = $2;
|
1103 |
AF_OP_SERVER = $4;
|
1104 |
AF_OP_ACCOUNTS = $8;
|
1105 |
AF_SETTABLE_BITS = (AF_OP_PRINT or AF_OP_COMM or
|
1106 |
AF_OP_SERVER or AF_OP_ACCOUNTS);
|
1107 |
|
1108 |
{ UAS role manifests under NETLOGON }
|
1109 |
UAS_ROLE_STANDALONE = 0;
|
1110 |
UAS_ROLE_MEMBER = 1;
|
1111 |
UAS_ROLE_BACKUP = 2;
|
1112 |
UAS_ROLE_PRIMARY = 3;
|
1113 |
|
1114 |
{ Values for ParmError for NetUserSetInfo. }
|
1115 |
USER_NAME_PARMNUM = 1;
|
1116 |
USER_PASSWORD_PARMNUM = 3;
|
1117 |
USER_PASSWORD_AGE_PARMNUM = 4;
|
1118 |
USER_PRIV_PARMNUM = 5;
|
1119 |
USER_HOME_DIR_PARMNUM = 6;
|
1120 |
USER_COMMENT_PARMNUM = 7;
|
1121 |
USER_FLAGS_PARMNUM = 8;
|
1122 |
USER_SCRIPT_PATH_PARMNUM = 9;
|
1123 |
USER_AUTH_FLAGS_PARMNUM = 10;
|
1124 |
USER_FULL_NAME_PARMNUM = 11;
|
1125 |
USER_USR_COMMENT_PARMNUM = 12;
|
1126 |
USER_PARMS_PARMNUM = 13;
|
1127 |
USER_WORKSTATIONS_PARMNUM = 14;
|
1128 |
USER_LAST_LOGON_PARMNUM = 15;
|
1129 |
USER_LAST_LOGOFF_PARMNUM = 16;
|
1130 |
USER_ACCT_EXPIRES_PARMNUM = 17;
|
1131 |
USER_MAX_STORAGE_PARMNUM = 18;
|
1132 |
USER_UNITS_PER_WEEK_PARMNUM = 19;
|
1133 |
USER_LOGON_HOURS_PARMNUM = 20;
|
1134 |
USER_PAD_PW_COUNT_PARMNUM = 21;
|
1135 |
USER_NUM_LOGONS_PARMNUM = 22;
|
1136 |
USER_LOGON_SERVER_PARMNUM = 23;
|
1137 |
USER_COUNTRY_CODE_PARMNUM = 24;
|
1138 |
USER_CODE_PAGE_PARMNUM = 25;
|
1139 |
USER_PRIMARY_GROUP_PARMNUM = 51;
|
1140 |
USER_PROFILE = 52;
|
1141 |
USER_PROFILE_PARMNUM = 52;
|
1142 |
USER_HOME_DIR_DRIVE_PARMNUM = 53;
|
1143 |
|
1144 |
{ the new infolevel counterparts of the old info level + parmnum }
|
1145 |
USER_NAME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_NAME_PARMNUM);
|
1146 |
USER_PASSWORD_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PASSWORD_PARMNUM);
|
1147 |
USER_PASSWORD_AGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PASSWORD_AGE_PARMNUM);
|
1148 |
USER_PRIV_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PRIV_PARMNUM);
|
1149 |
USER_HOME_DIR_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_HOME_DIR_PARMNUM);
|
1150 |
USER_COMMENT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_COMMENT_PARMNUM);
|
1151 |
USER_FLAGS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_FLAGS_PARMNUM);
|
1152 |
USER_SCRIPT_PATH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_SCRIPT_PATH_PARMNUM);
|
1153 |
USER_AUTH_FLAGS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_AUTH_FLAGS_PARMNUM);
|
1154 |
USER_FULL_NAME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_FULL_NAME_PARMNUM);
|
1155 |
USER_USR_COMMENT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_USR_COMMENT_PARMNUM);
|
1156 |
USER_PARMS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PARMS_PARMNUM);
|
1157 |
USER_WORKSTATIONS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_WORKSTATIONS_PARMNUM);
|
1158 |
USER_LAST_LOGON_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_LAST_LOGON_PARMNUM);
|
1159 |
USER_LAST_LOGOFF_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_LAST_LOGOFF_PARMNUM);
|
1160 |
USER_ACCT_EXPIRES_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_ACCT_EXPIRES_PARMNUM);
|
1161 |
USER_MAX_STORAGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_MAX_STORAGE_PARMNUM);
|
1162 |
USER_UNITS_PER_WEEK_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_UNITS_PER_WEEK_PARMNUM);
|
1163 |
USER_LOGON_HOURS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_LOGON_HOURS_PARMNUM);
|
1164 |
USER_PAD_PW_COUNT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PAD_PW_COUNT_PARMNUM);
|
1165 |
USER_NUM_LOGONS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_NUM_LOGONS_PARMNUM);
|
1166 |
USER_LOGON_SERVER_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_LOGON_SERVER_PARMNUM);
|
1167 |
USER_COUNTRY_CODE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_COUNTRY_CODE_PARMNUM);
|
1168 |
USER_CODE_PAGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_CODE_PAGE_PARMNUM);
|
1169 |
USER_PRIMARY_GROUP_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_PRIMARY_GROUP_PARMNUM);
|
1170 |
USER_POSIX_ID_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_POSIX_ID_PARMNUM);
|
1171 |
USER_HOME_DIR_DRIVE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + USER_HOME_DIR_DRIVE_PARMNUM);
|
1172 |
|
1173 |
{ For SetInfo call (parmnum 0) when password change not required }
|
1174 |
NULL_USERSETINFO_PASSWD = ' ';
|
1175 |
|
1176 |
TIMEQ_FOREVER = ULong(-1);
|
1177 |
USER_MAXSTORAGE_UNLIMITED = ULong(-1);
|
1178 |
USER_NO_LOGOFF = ULong(-1);
|
1179 |
UNITS_PER_DAY = 24;
|
1180 |
UNITS_PER_WEEK = UNITS_PER_DAY * 7;
|
1181 |
|
1182 |
{ Privilege levels (USER_INFO_X field usriX_priv (X = 0/1)). }
|
1183 |
USER_PRIV_MASK = $3;
|
1184 |
USER_PRIV_GUEST = 0;
|
1185 |
USER_PRIV_USER = 1;
|
1186 |
USER_PRIV_ADMIN = 2;
|
1187 |
|
1188 |
{ user modals related defaults }
|
1189 |
MAX_PASSWD_LEN = PWLEN;
|
1190 |
DEF_MIN_PWLEN = 6;
|
1191 |
DEF_PWUNIQUENESS = 5;
|
1192 |
DEF_MAX_PWHIST = 8;
|
1193 |
|
1194 |
DEF_MAX_PWAGE = TIMEQ_FOREVER; { forever }
|
1195 |
DEF_MIN_PWAGE = ULong(0); { 0 days }
|
1196 |
DEF_FORCE_LOGOFF = ULong($ffffffff); { never }
|
1197 |
DEF_MAX_BADPW = 0; { no limit }
|
1198 |
ONE_DAY = ULong(01*24*3600); { 01 day }
|
1199 |
|
1200 |
{ User Logon Validation (codes returned) }
|
1201 |
VALIDATED_LOGON = 0;
|
1202 |
PASSWORD_EXPIRED = 2;
|
1203 |
NON_VALIDATED_LOGON = 3;
|
1204 |
|
1205 |
VALID_LOGOFF = 1;
|
1206 |
|
1207 |
{ parmnum manifests for user modals }
|
1208 |
MODALS_MIN_PASSWD_LEN_PARMNUM = 1;
|
1209 |
MODALS_MAX_PASSWD_AGE_PARMNUM = 2;
|
1210 |
MODALS_MIN_PASSWD_AGE_PARMNUM = 3;
|
1211 |
MODALS_FORCE_LOGOFF_PARMNUM = 4;
|
1212 |
MODALS_PASSWD_HIST_LEN_PARMNUM = 5;
|
1213 |
MODALS_ROLE_PARMNUM = 6;
|
1214 |
MODALS_PRIMARY_PARMNUM = 7;
|
1215 |
MODALS_DOMAIN_NAME_PARMNUM = 8;
|
1216 |
MODALS_DOMAIN_ID_PARMNUM = 9;
|
1217 |
MODALS_LOCKOUT_DURATION_PARMNUM = 10;
|
1218 |
MODALS_LOCKOUT_OBSERVATION_WINDOW_PARMNUM = 11;
|
1219 |
MODALS_LOCKOUT_THRESHOLD_PARMNUM = 12;
|
1220 |
|
1221 |
{ the new infolevel counterparts of the old info level + parmnum }
|
1222 |
MODALS_MIN_PASSWD_LEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_MIN_PASSWD_LEN_PARMNUM);
|
1223 |
MODALS_MAX_PASSWD_AGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_MAX_PASSWD_AGE_PARMNUM);
|
1224 |
MODALS_MIN_PASSWD_AGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_MIN_PASSWD_AGE_PARMNUM);
|
1225 |
MODALS_FORCE_LOGOFF_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_FORCE_LOGOFF_PARMNUM);
|
1226 |
MODALS_PASSWD_HIST_LEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_PASSWD_HIST_LEN_PARMNUM);
|
1227 |
MODALS_ROLE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_ROLE_PARMNUM);
|
1228 |
MODALS_PRIMARY_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_PRIMARY_PARMNUM);
|
1229 |
MODALS_DOMAIN_NAME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_DOMAIN_NAME_PARMNUM);
|
1230 |
MODALS_DOMAIN_ID_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + MODALS_DOMAIN_ID_PARMNUM);
|
1231 |
|
1232 |
type
|
1233 |
PGROUP_INFO_0 = ^TGROUP_INFO_0;
|
1234 |
TGROUP_INFO_0 = record
|
1235 |
grpi0_name : LPWSTR;
|
1236 |
end;
|
1237 |
|
1238 |
PGROUP_INFO_1 = ^TGROUP_INFO_1;
|
1239 |
TGROUP_INFO_1 = record
|
1240 |
grpi1_name : LPWSTR;
|
1241 |
grpi1_comment : LPWSTR;
|
1242 |
end;
|
1243 |
|
1244 |
PGROUP_INFO_2 = ^TGROUP_INFO_2;
|
1245 |
TGROUP_INFO_2 = record
|
1246 |
grpi2_name : LPWSTR;
|
1247 |
grpi2_comment : LPWSTR;
|
1248 |
grpi2_group_id : DWord;
|
1249 |
grpi2_attributes : DWord;
|
1250 |
end;
|
1251 |
|
1252 |
PGROUP_INFO_1002 = ^TGROUP_INFO_1002;
|
1253 |
TGROUP_INFO_1002 = record
|
1254 |
grpi1002_comment : LPWSTR;
|
1255 |
end;
|
1256 |
|
1257 |
PGROUP_INFO_1005 = ^TGROUP_INFO_1005;
|
1258 |
TGROUP_INFO_1005 = record
|
1259 |
grpi1005_attributes : DWord;
|
1260 |
end;
|
1261 |
|
1262 |
PGROUP_USERS_INFO_0 = ^TGROUP_USERS_INFO_0;
|
1263 |
TGROUP_USERS_INFO_0 = record
|
1264 |
grui0_name : LPWSTR;
|
1265 |
end;
|
1266 |
|
1267 |
PGROUP_USERS_INFO_1 = ^TGROUP_USERS_INFO_1;
|
1268 |
TGROUP_USERS_INFO_1 = record
|
1269 |
grui1_name : LPWSTR;
|
1270 |
grui1_attributes : DWord;
|
1271 |
end;
|
1272 |
|
1273 |
{ Special Values and Constants - Group }
|
1274 |
const
|
1275 |
GROUPIDMASK = $8000; { MSB set if uid refers to a group }
|
1276 |
|
1277 |
{ Predefined group for all normal users, administrators and guests }
|
1278 |
{ LOCAL is a special group for pinball local security. }
|
1279 |
GROUP_SPECIALGRP_USERS = 'USERS';
|
1280 |
GROUP_SPECIALGRP_ADMINS = 'ADMINS';
|
1281 |
GROUP_SPECIALGRP_GUESTS = 'GUESTS';
|
1282 |
GROUP_SPECIALGRP_LOCAL = 'LOCAL';
|
1283 |
|
1284 |
{ parmnum manifests for SetInfo calls (only comment is settable) }
|
1285 |
GROUP_ALL_PARMNUM = 0;
|
1286 |
GROUP_NAME_PARMNUM = 1;
|
1287 |
GROUP_COMMENT_PARMNUM = 2;
|
1288 |
GROUP_ATTRIBUTES_PARMNUM = 3;
|
1289 |
|
1290 |
{ the new infolevel counterparts of the old info level + parmnum }
|
1291 |
GROUP_ALL_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + GROUP_ALL_PARMNUM);
|
1292 |
GROUP_NAME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + GROUP_NAME_PARMNUM);
|
1293 |
GROUP_COMMENT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + GROUP_COMMENT_PARMNUM);
|
1294 |
GROUP_ATTRIBUTES_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + GROUP_ATTRIBUTES_PARMNUM);
|
1295 |
GROUP_POSIX_ID_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + GROUP_POSIX_ID_PARMNUM);
|
1296 |
|
1297 |
type
|
1298 |
PLOCALGROUP_INFO_0 = ^TLOCALGROUP_INFO_0;
|
1299 |
TLOCALGROUP_INFO_0 = record
|
1300 |
lgrpi0_name : LPWSTR;
|
1301 |
end;
|
1302 |
|
1303 |
PLOCALGROUP_INFO_1 = ^TLOCALGROUP_INFO_1;
|
1304 |
TLOCALGROUP_INFO_1 = record
|
1305 |
lgrpi1_name : LPWSTR;
|
1306 |
lgrpi1_comment : LPWSTR;
|
1307 |
end;
|
1308 |
|
1309 |
PLOCALGROUP_INFO_1002 = ^TLOCALGROUP_INFO_1002;
|
1310 |
TLOCALGROUP_INFO_1002 = record
|
1311 |
lgrpi1002_comment : LPWSTR;
|
1312 |
end;
|
1313 |
|
1314 |
PLOCALGROUP_MEMBERS_INFO_0 = ^TLOCALGROUP_MEMBERS_INFO_0;
|
1315 |
TLOCALGROUP_MEMBERS_INFO_0 = record
|
1316 |
lgrmi0_sid : PSID;
|
1317 |
end;
|
1318 |
|
1319 |
PLOCALGROUP_MEMBERS_INFO_1 = ^TLOCALGROUP_MEMBERS_INFO_1;
|
1320 |
TLOCALGROUP_MEMBERS_INFO_1 = record
|
1321 |
lgrmi1_sid : PSID;
|
1322 |
lgrmi1_sidusage : SID_NAME_USE;
|
1323 |
lgrmi1_name : LPWSTR;
|
1324 |
end;
|
1325 |
|
1326 |
PLOCALGROUP_MEMBERS_INFO_2 = ^TLOCALGROUP_MEMBERS_INFO_2;
|
1327 |
TLOCALGROUP_MEMBERS_INFO_2 = record
|
1328 |
lgrmi2_sid : PSID;
|
1329 |
lgrmi2_sidusage : SID_NAME_USE;
|
1330 |
lgrmi2_domainandname : LPWSTR;
|
1331 |
end;
|
1332 |
|
1333 |
PLOCALGROUP_MEMBERS_INFO_3 = ^TLOCALGROUP_MEMBERS_INFO_3;
|
1334 |
TLOCALGROUP_MEMBERS_INFO_3 = record
|
1335 |
lgrmi3_domainandname : LPWSTR;
|
1336 |
end;
|
1337 |
|
1338 |
PLOCALGROUP_USERS_INFO_0 = ^TLOCALGROUP_USERS_INFO_0;
|
1339 |
TLOCALGROUP_USERS_INFO_0 = record
|
1340 |
lgrui0_name : LPWSTR;
|
1341 |
end;
|
1342 |
|
1343 |
const
|
1344 |
LOCALGROUP_NAME_PARMNUM = 1;
|
1345 |
LOCALGROUP_COMMENT_PARMNUM = 2;
|
1346 |
|
1347 |
{ QueryDisplayInformation levels }
|
1348 |
type
|
1349 |
PNET_DISPLAY_USER = ^TNET_DISPLAY_USER;
|
1350 |
TNET_DISPLAY_USER = record
|
1351 |
usri1_name : LPWSTR;
|
1352 |
usri1_comment : LPWSTR;
|
1353 |
usri1_flags : DWord;
|
1354 |
usri1_full_name : LPWSTR;
|
1355 |
usri1_user_id : DWord;
|
1356 |
usri1_next_index : DWord;
|
1357 |
end;
|
1358 |
|
1359 |
PNET_DISPLAY_MACHINE = ^TNET_DISPLAY_MACHINE;
|
1360 |
TNET_DISPLAY_MACHINE = record
|
1361 |
usri2_name : LPWSTR;
|
1362 |
usri2_comment : LPWSTR;
|
1363 |
usri2_flags : DWord;
|
1364 |
usri2_user_id : DWord;
|
1365 |
usri2_next_index : DWord;
|
1366 |
end;
|
1367 |
|
1368 |
PNET_DISPLAY_GROUP = ^TNET_DISPLAY_GROUP;
|
1369 |
TNET_DISPLAY_GROUP = record
|
1370 |
grpi3_name : LPWSTR;
|
1371 |
grpi3_comment : LPWSTR;
|
1372 |
grpi3_group_id : DWord;
|
1373 |
grpi3_attributes : DWord;
|
1374 |
grpi3_next_index : DWord;
|
1375 |
end;
|
1376 |
|
1377 |
{ Data Structures - Access }
|
1378 |
PACCESS_INFO_0 = ^TACCESS_INFO_0;
|
1379 |
TACCESS_INFO_0 = record
|
1380 |
acc0_resource_name : LPWSTR;
|
1381 |
end;
|
1382 |
|
1383 |
PACCESS_INFO_1 = ^TACCESS_INFO_1;
|
1384 |
TACCESS_INFO_1 = record
|
1385 |
acc1_resource_name : LPWSTR;
|
1386 |
acc1_attr : DWord;
|
1387 |
acc1_count : DWord;
|
1388 |
end;
|
1389 |
|
1390 |
PACCESS_INFO_1002 = ^TACCESS_INFO_1002;
|
1391 |
TACCESS_INFO_1002 = record
|
1392 |
acc1002_attr : DWord;
|
1393 |
end;
|
1394 |
|
1395 |
PACCESS_LIST = ^TACCESS_LIST;
|
1396 |
TACCESS_LIST = record
|
1397 |
acl_ugname : LPWSTR;
|
1398 |
acl_access : DWord;
|
1399 |
end;
|
1400 |
|
1401 |
{ Special Values and Constants - Access }
|
1402 |
|
1403 |
{ Maximum number of permission entries for each resource. }
|
1404 |
const
|
1405 |
MAXPERMENTRIES = 64;
|
1406 |
|
1407 |
|
1408 |
{ Bit values for the access permissions. ACCESS_ALL is a handy
|
1409 |
way to specify maximum permissions. These are used in
|
1410 |
acl_access field of access_list structures.
|
1411 |
}
|
1412 |
ACCESS_NONE = 0;
|
1413 |
|
1414 |
ACCESS_READ = $01;
|
1415 |
ACCESS_WRITE = $02;
|
1416 |
ACCESS_CREATE = $04;
|
1417 |
ACCESS_EXEC = $08;
|
1418 |
ACCESS_DELETE = $10;
|
1419 |
ACCESS_ATRIB = $20;
|
1420 |
ACCESS_PERM = $40;
|
1421 |
|
1422 |
ACCESS_ALL = (ACCESS_READ or
|
1423 |
ACCESS_WRITE or
|
1424 |
ACCESS_CREATE or
|
1425 |
ACCESS_EXEC or
|
1426 |
ACCESS_DELETE or
|
1427 |
ACCESS_ATRIB or
|
1428 |
ACCESS_PERM);
|
1429 |
|
1430 |
|
1431 |
ACCESS_GROUP = $8000;
|
1432 |
|
1433 |
{ Bit values for the acc1_attr field of the ACCESS_INFO_1 structure. }
|
1434 |
ACCESS_AUDIT = $1;
|
1435 |
|
1436 |
ACCESS_SUCCESS_OPEN = $10;
|
1437 |
ACCESS_SUCCESS_WRITE = $20;
|
1438 |
ACCESS_SUCCESS_DELETE = $40;
|
1439 |
ACCESS_SUCCESS_ACL = $80;
|
1440 |
ACCESS_SUCCESS_MASK = $F0;
|
1441 |
|
1442 |
ACCESS_FAIL_OPEN = $100;
|
1443 |
ACCESS_FAIL_WRITE = $200;
|
1444 |
ACCESS_FAIL_DELETE = $400;
|
1445 |
ACCESS_FAIL_ACL = $800;
|
1446 |
ACCESS_FAIL_MASK = $F00;
|
1447 |
|
1448 |
ACCESS_FAIL_SHIFT = 4;
|
1449 |
|
1450 |
{ Parmnum value for NetAccessSetInfo. }
|
1451 |
ACCESS_RESOURCE_NAME_PARMNUM = 1;
|
1452 |
ACCESS_ATTR_PARMNUM = 2;
|
1453 |
ACCESS_COUNT_PARMNUM = 3;
|
1454 |
ACCESS_ACCESS_LIST_PARMNUM = 4;
|
1455 |
|
1456 |
{ the new infolevel counterparts of the old info level + parmnum }
|
1457 |
ACCESS_RESOURCE_NAME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + ACCESS_RESOURCE_NAME_PARMNUM);
|
1458 |
ACCESS_ATTR_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + ACCESS_ATTR_PARMNUM);
|
1459 |
ACCESS_COUNT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + ACCESS_COUNT_PARMNUM);
|
1460 |
ACCESS_ACCESS_LIST_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + ACCESS_ACCESS_LIST_PARMNUM);
|
1461 |
|
1462 |
{
|
1463 |
ACCESS_LETTERS defines a letter for each bit position in
|
1464 |
the acl_access field of struct access_list. Note that some
|
1465 |
bits have a corresponding letter of ' ' (space).
|
1466 |
}
|
1467 |
ACCESS_LETTERS = 'RWCXDAP ';
|
1468 |
|
1469 |
{ FunctionCode values for I_NetLogonControl. }
|
1470 |
const
|
1471 |
NETLOGON_CONTROL_QUERY = 1; { No-op: just query }
|
1472 |
NETLOGON_CONTROL_REPLICATE = 2; { Force replicate on BDC }
|
1473 |
NETLOGON_CONTROL_SYNCHRONIZE = 3; { Force synchronize on BDC }
|
1474 |
NETLOGON_CONTROL_PDC_REPLICATE = 4; { Force PDC to broadcast change }
|
1475 |
NETLOGON_CONTROL_REDISCOVER = 5; { Force to re-discover trusted domain DCs }
|
1476 |
NETLOGON_CONTROL_TC_QUERY = 6; { Query status of specified trusted channel status }
|
1477 |
NETLOGON_CONTROL_TRANSPORT_NOTIFY = 7; { Notify netlogon that a new transport has come online }
|
1478 |
NETLOGON_CONTROL_FIND_USER = 8; { Find named user in trusted domain }
|
1479 |
|
1480 |
{ Debug function codes }
|
1481 |
NETLOGON_CONTROL_UNLOAD_NETLOGON_DLL=$FFFB;
|
1482 |
NETLOGON_CONTROL_BACKUP_CHANGE_LOG = $FFFC;
|
1483 |
NETLOGON_CONTROL_TRUNCATE_LOG = $FFFD;
|
1484 |
NETLOGON_CONTROL_SET_DBFLAG = $FFFE;
|
1485 |
NETLOGON_CONTROL_BREAKPOINT = $FFFF;
|
1486 |
|
1487 |
{ Query level 1 for I_NetLogonControl }
|
1488 |
type
|
1489 |
PNETLOGON_INFO_1 = ^TNETLOGON_INFO_1;
|
1490 |
TNETLOGON_INFO_1 = record
|
1491 |
netlog1_flags : DWord;
|
1492 |
netlog1_pdc_connection_status : NET_API_STATUS;
|
1493 |
end;
|
1494 |
|
1495 |
PNETLOGON_INFO_2 = ^TNETLOGON_INFO_2;
|
1496 |
TNETLOGON_INFO_2 = record
|
1497 |
netlog2_flags : DWord;
|
1498 |
netlog2_pdc_connection_status : NET_API_STATUS;
|
1499 |
{$ifdef MIDL_PASS}
|
1500 |
[string] wchar_t * netlog2_trusted_dc_name;
|
1501 |
{$else}
|
1502 |
netlog2_trusted_dc_name : LPWSTR;
|
1503 |
{$endif}
|
1504 |
netlog2_tc_connection_status : NET_API_STATUS;
|
1505 |
end;
|
1506 |
|
1507 |
PNETLOGON_INFO_3 = ^TNETLOGON_INFO_3;
|
1508 |
TNETLOGON_INFO_3 = record
|
1509 |
netlog3_flags : DWord;
|
1510 |
netlog3_logon_attempts : DWord;
|
1511 |
netlog3_reserved1 : DWord;
|
1512 |
netlog3_reserved2 : DWord;
|
1513 |
netlog3_reserved3 : DWord;
|
1514 |
netlog3_reserved4 : DWord;
|
1515 |
netlog3_reserved5 : DWord;
|
1516 |
end;
|
1517 |
|
1518 |
PNETLOGON_INFO_4 = ^TNETLOGON_INFO_4;
|
1519 |
TNETLOGON_INFO_4 = record
|
1520 |
{$IFDEF MIDL_PASS}
|
1521 |
[string] wchar_t * netlog4_trusted_dc_name;
|
1522 |
[string] wchar_t * netlog4_trusted_domain_name;
|
1523 |
{$ELSE}
|
1524 |
netlog4_trusted_dc_name : LPWSTR;
|
1525 |
netlog4_trusted_domain_name : LPWSTR;
|
1526 |
{$ENDIF}
|
1527 |
end;
|
1528 |
|
1529 |
{ Values of netlog1_flags }
|
1530 |
const
|
1531 |
NETLOGON_REPLICATION_NEEDED = $01; { Database is out of date }
|
1532 |
NETLOGON_REPLICATION_IN_PROGRESS = $02; { Replication is happening now }
|
1533 |
NETLOGON_FULL_SYNC_REPLICATION = $04; { full sync replication required/progress }
|
1534 |
NETLOGON_REDO_NEEDED = $08; { Redo of previous replication needed }
|
1535 |
|
1536 |
{-------------------- LMALERT.H ---------------------------------------------}
|
1537 |
type
|
1538 |
TNetAlertRaise = function(AlertEventName: LPCWSTR; Buffer: Pointer; BufferSize: DWord): NET_API_STATUS; stdcall;
|
1539 |
TNetAlertRaiseEx = function(AlertEventName: LPCWSTR; VariableInfo: Pointer; VariableInfoSize: DWord; ServiceName: LPCWSTR): NET_API_STATUS; stdcall;
|
1540 |
|
1541 |
type
|
1542 |
PSTD_ALERT = ^TSTD_ALERT;
|
1543 |
TSTD_ALERT = record
|
1544 |
alrt_timestamp : DWord;
|
1545 |
alrt_eventname : array[0..EVLEN] of char;
|
1546 |
alrt_servicename : array[0..SNLEN] of char;
|
1547 |
end;
|
1548 |
|
1549 |
PADMIN_OTHER_INFO = ^TADMIN_OTHER_INFO;
|
1550 |
TADMIN_OTHER_INFO = record
|
1551 |
alrtad_errcode : DWord;
|
1552 |
alrtad_numstrings : DWord;
|
1553 |
end;
|
1554 |
|
1555 |
PERRLOG_OTHER_INFO = ^TERRLOG_OTHER_INFO;
|
1556 |
TERRLOG_OTHER_INFO = record
|
1557 |
alrter_errcode : DWord;
|
1558 |
alrter_offset : DWord;
|
1559 |
end;
|
1560 |
|
1561 |
PPRINT_OTHER_INFO = ^TPRINT_OTHER_INFO;
|
1562 |
TPRINT_OTHER_INFO = record
|
1563 |
alrtpr_jobid : DWord;
|
1564 |
alrtpr_status : DWord;
|
1565 |
alrtpr_submitted : DWord;
|
1566 |
alrtpr_size : DWord;
|
1567 |
end;
|
1568 |
|
1569 |
PUSER_OTHER_INFO = ^TUSER_OTHER_INFO;
|
1570 |
TUSER_OTHER_INFO = record
|
1571 |
alrtus_errcode : DWord;
|
1572 |
alrtus_numstrings : DWord;
|
1573 |
end;
|
1574 |
|
1575 |
{ Name of mailslot to send alert notifications }
|
1576 |
const
|
1577 |
ALERTER_MAILSLOT = '\\.\MAILSLOT\Alerter';
|
1578 |
|
1579 |
(*
|
1580 |
The following macro gives a pointer to the other_info data.
|
1581 |
It takes an alert structure and returns a pointer to structure
|
1582 |
beyond the standard portion.
|
1583 |
|
1584 |
ALERT_OTHER_INFO(x) ((LPBYTE)(x) + sizeof(STD_ALERT))
|
1585 |
|
1586 |
The following macro gives a pointer to the variable-length data.
|
1587 |
It takes a pointer to one of the other-info structs and returns a
|
1588 |
pointer to the variable data portion.
|
1589 |
|
1590 |
ALERT_VAR_DATA(p) ((LPBYTE)(p) + sizeof(*p))
|
1591 |
*)
|
1592 |
|
1593 |
{ Names of standard Microsoft-defined alert events. }
|
1594 |
ALERT_PRINT_EVENT = 'PRINTING';
|
1595 |
ALERT_MESSAGE_EVENT = 'MESSAGE';
|
1596 |
ALERT_ERRORLOG_EVENT = 'ERRORLOG';
|
1597 |
ALERT_ADMIN_EVENT = 'ADMIN';
|
1598 |
ALERT_USER_EVENT = 'USER';
|
1599 |
|
1600 |
{ Bitmap masks for prjob_status field of PRINTJOB. }
|
1601 |
{ 2-7 bits also used in device status }
|
1602 |
PRJOB_QSTATUS = $3; { Bits 0,1 }
|
1603 |
PRJOB_DEVSTATUS = $1fc; { 2-8 bits }
|
1604 |
PRJOB_COMPLETE = $4; { Bit 2 }
|
1605 |
PRJOB_INTERV = $8; { Bit 3 }
|
1606 |
PRJOB_ERROR = $10; { Bit 4 }
|
1607 |
PRJOB_DESTOFFLINE = $20; { Bit 5 }
|
1608 |
PRJOB_DESTPAUSED = $40; { Bit 6 }
|
1609 |
PRJOB_NOTIFY = $80; { Bit 7 }
|
1610 |
PRJOB_DESTNOPAPER = $100; { Bit 8 }
|
1611 |
PRJOB_DELETED = $8000;{ Bit 15 }
|
1612 |
|
1613 |
{ Values of PRJOB_QSTATUS bits in prjob_status field of PRINTJOB. }
|
1614 |
PRJOB_QS_QUEUED = 0;
|
1615 |
PRJOB_QS_PAUSED = 1;
|
1616 |
PRJOB_QS_SPOOLING = 2;
|
1617 |
PRJOB_QS_PRINTING = 3;
|
1618 |
|
1619 |
{-------------------- LMSHARE.H ---------------------------------------------}
|
1620 |
type
|
1621 |
TNetShareAdd = function(ServerName: LPWSTR; Level: DWORD; Buffer: Pointer; var ParmErr: DWORD): NET_API_STATUS; stdcall;
|
1622 |
TNetShareEnum = function(ServerName: LPWSTR; Level: DWORD; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; var ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1623 |
TNetShareEnumSticky = function(ServerName: LPWSTR; Level: DWORD; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1624 |
TNetShareGetInfo = function(ServerName, NetName: LPWSTR; Level: DWORD; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1625 |
TNetShareSetInfo = function(ServerName, NetName: LPWSTR; Level: DWORD; var Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
1626 |
TNetShareDel = function(ServerName, NetName: LPWSTR; Reserved: DWord): NET_API_STATUS; stdcall;
|
1627 |
TNetShareDelSticky = function(ServerName, NetName: LPWSTR; Reserved: DWord): NET_API_STATUS; stdcall;
|
1628 |
TNetShareCheck = function(ServerName, Device: LPWSTR; var ShareType: DWord): NET_API_STATUS; stdcall;
|
1629 |
|
1630 |
TNetSessionEnum = function(ServerName, UncClientName, UserName: LPWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1631 |
TNetSessionDel = function(ServerName, UncClientName, UserName: LPWSTR): NET_API_STATUS; stdcall;
|
1632 |
TNetSessionGetInfo = function(ServerName, UncClientName, UserName: LPWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1633 |
|
1634 |
TNetConnectionEnum = function(ServerName, Qualifier: LPWSTR; Level: DWord; var Buffer : Pointer; PrefMaxLen : DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1635 |
|
1636 |
TNetFileClose = function(ServerName: LPWSTR; FileID: DWord): NET_API_STATUS; stdcall;
|
1637 |
TNetFileEnum = function(ServerName, BasePath, UserName: LPWSTR; Level: DWord; var Buffer: Pointer; PrefMexLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1638 |
TNetFileGetInfo = function(ServerName: LPWSTR; FileID, Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1639 |
|
1640 |
type
|
1641 |
PShare_Info_0 = ^TShare_Info_0;
|
1642 |
TShare_Info_0 = record
|
1643 |
shi0_netname: LPWSTR;
|
1644 |
end;
|
1645 |
|
1646 |
PShare_Info_1 = ^TShare_Info_1;
|
1647 |
TShare_Info_1 = record
|
1648 |
shi1_netname: LPWSTR;
|
1649 |
shi1_type: DWord;
|
1650 |
shi1_remark: LPWSTR;
|
1651 |
end;
|
1652 |
|
1653 |
PShare_Info_2 = ^TShare_Info_2;
|
1654 |
TShare_Info_2 = record
|
1655 |
shi2_netname: LPWSTR;
|
1656 |
shi2_type: DWord;
|
1657 |
shi2_remark: LPWSTR;
|
1658 |
shi2_permissions: DWord;
|
1659 |
shi2_max_uses: DWord;
|
1660 |
shi2_current_uses: DWord;
|
1661 |
shi2_path: LPWSTR;
|
1662 |
shi2_passwd: LPWSTR;
|
1663 |
end;
|
1664 |
|
1665 |
PShare_Info_501 = ^TShare_Info_501;
|
1666 |
TShare_Info_501 = record
|
1667 |
shi501_netname: LPWSTR;
|
1668 |
shi501_type: DWord;
|
1669 |
shi501_remark: LPWSTR;
|
1670 |
shi501_flags: DWord;
|
1671 |
end;
|
1672 |
|
1673 |
PShare_Info_502 = ^TShare_Info_502;
|
1674 |
TShare_Info_502 = record
|
1675 |
shi502_netname: LPWSTR;
|
1676 |
shi502_type: DWord;
|
1677 |
shi502_remark: LPWSTR;
|
1678 |
shi502_permissions: DWord;
|
1679 |
shi502_max_uses: DWord;
|
1680 |
shi502_current_uses: DWord;
|
1681 |
shi502_path: LPWSTR;
|
1682 |
shi502_passwd: LPWSTR;
|
1683 |
shi502_reserved: DWord;
|
1684 |
shi502_security_descriptor: PSECURITY_DESCRIPTOR;
|
1685 |
end;
|
1686 |
|
1687 |
PShare_Info_1004 = ^TShare_Info_1004;
|
1688 |
TShare_Info_1004 = record
|
1689 |
shi1004_remark: LPWSTR;
|
1690 |
end;
|
1691 |
|
1692 |
PShare_Info_1005 = ^TShare_Info_1005;
|
1693 |
TShare_Info_1005 = record
|
1694 |
shi1005_flags: DWord;
|
1695 |
end;
|
1696 |
|
1697 |
PShare_Info_1006 = ^TShare_Info_1006;
|
1698 |
TShare_Info_1006 = record
|
1699 |
shi1006_max_uses: DWord;
|
1700 |
end;
|
1701 |
|
1702 |
PShare_Info_1501 = ^TShare_Info_1501;
|
1703 |
TShare_Info_1501 = record
|
1704 |
shi1501_reserved: DWord;
|
1705 |
shi1501_security_descriptor: PSECURITY_DESCRIPTOR;
|
1706 |
end;
|
1707 |
|
1708 |
{ Special Values and Constants - Share }
|
1709 |
|
1710 |
{ Values for parm_err parameter. }
|
1711 |
const
|
1712 |
SHARE_NETNAME_PARMNUM = 1;
|
1713 |
SHARE_TYPE_PARMNUM = 3;
|
1714 |
SHARE_REMARK_PARMNUM = 4;
|
1715 |
SHARE_PERMISSIONS_PARMNUM = 5;
|
1716 |
SHARE_MAX_USES_PARMNUM = 6;
|
1717 |
SHARE_CURRENT_USES_PARMNUM = 7;
|
1718 |
SHARE_PATH_PARMNUM = 8;
|
1719 |
SHARE_PASSWD_PARMNUM = 9;
|
1720 |
SHARE_FILE_SD_PARMNUM = 501;
|
1721 |
|
1722 |
{ Single-field infolevels for NetShareSetInfo. }
|
1723 |
SHARE_REMARK_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SHARE_REMARK_PARMNUM);
|
1724 |
SHARE_MAX_USES_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SHARE_MAX_USES_PARMNUM);
|
1725 |
SHARE_FILE_SD_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SHARE_FILE_SD_PARMNUM);
|
1726 |
|
1727 |
SHI1_NUM_ELEMENTS = 4;
|
1728 |
SHI2_NUM_ELEMENTS = 10;
|
1729 |
|
1730 |
{ Share types (shi1_type and shi2_type fields). }
|
1731 |
STYPE_DISKTREE = 0;
|
1732 |
STYPE_PRINTQ = 1;
|
1733 |
STYPE_DEVICE = 2;
|
1734 |
STYPE_IPC = 3;
|
1735 |
|
1736 |
STYPE_SPECIAL = $80000000;
|
1737 |
|
1738 |
SHI_USES_UNLIMITED = DWord(-1);
|
1739 |
|
1740 |
{ Flags values for the 501 and 1005 levels }
|
1741 |
SHI1005_FLAGS_DFS = $01; { Share is in the DFS }
|
1742 |
SHI1005_FLAGS_DFS_ROOT = $02; { Share is root of DFS}
|
1743 |
|
1744 |
CSC_MASK = $30; { Used to mask off the following states}
|
1745 |
|
1746 |
CSC_CACHE_MANUAL_REINT = $00; { No automatic file by file reintegration}
|
1747 |
CSC_CACHE_AUTO_REINT = $10; { File by file reintegration is OK}
|
1748 |
CSC_CACHE_VDO = $20; { no need to flow opens}
|
1749 |
CSC_CACHE_NONE = $30; { no CSC for this share}
|
1750 |
|
1751 |
{ The subset of 1005 infolevel flags that can be set via the API }
|
1752 |
SHI1005_VALID_FLAGS_SET = CSC_MASK;
|
1753 |
|
1754 |
type
|
1755 |
PSession_Info_0 = ^TSession_Info_0;
|
1756 |
TSession_Info_0 = record
|
1757 |
sesi0_cname: LPWSTR; { client name (no backslashes) }
|
1758 |
end;
|
1759 |
|
1760 |
PSession_Info_1 = ^TSession_Info_1;
|
1761 |
TSession_Info_1 = record
|
1762 |
sesi1_cname: LPWSTR; { client name (no backslashes) }
|
1763 |
sesi1_username: LPWSTR;
|
1764 |
sesi1_num_opens: DWord;
|
1765 |
sesi1_time: DWord;
|
1766 |
sesi1_idle_time: DWord;
|
1767 |
sesi1_user_flags: DWord;
|
1768 |
end;
|
1769 |
|
1770 |
PSession_Info_2 = ^TSession_Info_2;
|
1771 |
TSession_Info_2 = record
|
1772 |
sesi2_cname: LPWSTR; { client name (no backslashes) }
|
1773 |
sesi2_username: LPWSTR;
|
1774 |
sesi2_num_opens: DWord;
|
1775 |
sesi2_time: DWord;
|
1776 |
sesi2_idle_time: DWord;
|
1777 |
sesi2_user_flags: DWord;
|
1778 |
sesi2_cltype_name: LPWSTR;
|
1779 |
end;
|
1780 |
|
1781 |
PSession_Info_10 = ^TSession_Info_10;
|
1782 |
TSession_Info_10 = record
|
1783 |
sesi10_cname: LPWSTR; { client name (no backslashes) }
|
1784 |
sesi10_username: LPWSTR;
|
1785 |
sesi10_time: DWord;
|
1786 |
sesi10_idle_time: DWord;
|
1787 |
end;
|
1788 |
|
1789 |
PSession_Info_502 = ^TSession_Info_502;
|
1790 |
TSession_Info_502 = record
|
1791 |
sesi502_cname: LPWSTR; { client name (no backslashes) }
|
1792 |
sesi502_username: LPWSTR;
|
1793 |
sesi502_num_opens: DWord;
|
1794 |
sesi502_time: DWord;
|
1795 |
sesi502_idle_time: DWord;
|
1796 |
sesi502_user_flags: DWord;
|
1797 |
sesi502_cltype_name: LPWSTR;
|
1798 |
sesi502_transport: LPWSTR;
|
1799 |
end;
|
1800 |
|
1801 |
{ Special Values and Constants - Session }
|
1802 |
|
1803 |
{ Bits defined in sesi1_user_flags. }
|
1804 |
const
|
1805 |
SESS_GUEST = $00000001; { session is logged on as a guest }
|
1806 |
SESS_NOENCRYPTION = $00000002; { session is not using encryption }
|
1807 |
|
1808 |
SESI1_NUM_ELEMENTS = 8;
|
1809 |
SESI2_NUM_ELEMENTS = 9;
|
1810 |
|
1811 |
type
|
1812 |
PConnection_Info_0 = ^TConnection_Info_0;
|
1813 |
TConnection_Info_0 = record
|
1814 |
coni0_id: DWord;
|
1815 |
end;
|
1816 |
|
1817 |
PConnection_Info_1 = ^TConnection_Info_1;
|
1818 |
TConnection_Info_1 = record
|
1819 |
coni1_id: DWord;
|
1820 |
coni1_type: DWord;
|
1821 |
coni1_num_opens: DWord;
|
1822 |
coni1_num_users: DWord;
|
1823 |
coni1_time: DWord;
|
1824 |
coni1_username: LPWSTR;
|
1825 |
coni1_netname: LPWSTR;
|
1826 |
end;
|
1827 |
|
1828 |
{ File APIs are available at information levels 2 & 3 only. Levels 0 & }
|
1829 |
{ 1 are not supported. }
|
1830 |
type
|
1831 |
PFile_Info_2 = ^TFile_Info_2;
|
1832 |
TFile_Info_2 = record
|
1833 |
fi2_id: DWord;
|
1834 |
end;
|
1835 |
|
1836 |
PFile_Info_3 = ^TFile_Info_3;
|
1837 |
TFile_Info_3 = record
|
1838 |
fi3_id: DWord;
|
1839 |
fi3_permissions: DWord;
|
1840 |
fi3_num_locks: DWord;
|
1841 |
fi3_pathname: LPWSTR;
|
1842 |
fi3_username: LPWSTR;
|
1843 |
end;
|
1844 |
|
1845 |
{ Special Values and Constants - File }
|
1846 |
|
1847 |
{ bit values for permissions }
|
1848 |
const
|
1849 |
PERM_FILE_READ = $1; { user has read access }
|
1850 |
PERM_FILE_WRITE = $2; { user has write access }
|
1851 |
PERM_FILE_CREATE = $4; { user has create access }
|
1852 |
|
1853 |
{-------------------- LMMSG.H -----------------------------------------------}
|
1854 |
type
|
1855 |
TNetMessageNameAdd = function(ServerName, MsgName: LPCWSTR): NET_API_STATUS; stdcall;
|
1856 |
TNetMessageNameEnum = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: PDWord): NET_API_STATUS; stdcall;
|
1857 |
TNetMessageNameGetInfo = function(ServerName, MsgName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1858 |
TNetMessageNameDel = function(ServerName, MsgName: LPCWSTR): NET_API_STATUS; stdcall;
|
1859 |
TNetMessageBufferSend = function(ServerName, MsgName, FromName: LPCWSTR; Buffer: Pointer; BufferLen: DWord): NET_API_STATUS; stdcall;
|
1860 |
|
1861 |
type
|
1862 |
PMSG_INFO_0 = ^TMSG_INFO_0;
|
1863 |
TMSG_INFO_0 = record
|
1864 |
msgi0_name : LPWSTR;
|
1865 |
end;
|
1866 |
|
1867 |
PMSG_INFO_1 = ^TMSG_INFO_1;
|
1868 |
TMSG_INFO_1 = record
|
1869 |
msgi1_name : LPWSTR;
|
1870 |
msgi1_forward_flag : DWord;
|
1871 |
msgi1_forward : LPWSTR;
|
1872 |
end;
|
1873 |
|
1874 |
{ Special Values and Constants }
|
1875 |
|
1876 |
{ Values for msgi1_forward_flag. }
|
1877 |
const
|
1878 |
MSGNAME_NOT_FORWARDED = 0; { Name not forwarded }
|
1879 |
MSGNAME_FORWARDED_TO = $04; { Name forward to remote station }
|
1880 |
MSGNAME_FORWARDED_FROM = $10; { Name forwarded from remote station }
|
1881 |
|
1882 |
{-------------------- LMREMUTL.H --------------------------------------------}
|
1883 |
type
|
1884 |
TNetRemoteTOD = function(UncServerName: LPCWSTR; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1885 |
TNetRemoteComputerSupports = function(UncServerName: LPCWSTR; OptionsWanted: DWord; var OptionsSupported: DWord): NET_API_STATUS; stdcall;
|
1886 |
|
1887 |
T_TIME_OF_DAY_INFO = record
|
1888 |
tod_elapsedt : DWord;
|
1889 |
tod_msecs : DWord;
|
1890 |
tod_hours : DWord;
|
1891 |
tod_mins : DWord;
|
1892 |
tod_secs : DWord;
|
1893 |
tod_hunds : DWord;
|
1894 |
tod_timezone : LongInt;
|
1895 |
tod_tinterval : DWord;
|
1896 |
tod_day : DWord;
|
1897 |
tod_month : DWord;
|
1898 |
tod_year : DWord;
|
1899 |
tod_weekday : DWord;
|
1900 |
end;
|
1901 |
|
1902 |
{ Special Values and Constants }
|
1903 |
|
1904 |
const
|
1905 |
{ Mask bits for use with NetRemoteComputerSupports: }
|
1906 |
SUPPORTS_REMOTE_ADMIN_PROTOCOL = $00000002;
|
1907 |
SUPPORTS_RPC = $00000004;
|
1908 |
SUPPORTS_SAM_PROTOCOL = $00000008;
|
1909 |
SUPPORTS_UNICODE = $00000010;
|
1910 |
SUPPORTS_LOCAL = $00000020;
|
1911 |
SUPPORTS_ANY = $FFFFFFFF;
|
1912 |
|
1913 |
|
1914 |
{-------------------- LMSERVER.H --------------------------------------------}
|
1915 |
type
|
1916 |
TNetServerEnum = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ServerType: DWord; Domain: LPCWSTR; var ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1917 |
TNetServerEnumEx = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ServerType: DWord; Domain, FirstNameToReturn : LPWSTR): NET_API_STATUS; stdcall;
|
1918 |
TNetServerGetInfo = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
1919 |
TNetServerSetInfo = function(ServerName: LPCWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
1920 |
TNetServerDiskEnum = function(ServerName: LPCWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1921 |
TNetServerComputerNameAdd = function(ServerName, EmulatedDomainName, EmulatedServerName: LPWSTR): NET_API_STATUS; stdcall;
|
1922 |
TNetServerComputerNameDel = function(ServerName, EmulatedServerName: LPWSTR): NET_API_STATUS; stdcall;
|
1923 |
TNetServerTransportAdd = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer): NET_API_STATUS; stdcall;
|
1924 |
TNetServerTransportAddEx = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer): NET_API_STATUS; stdcall;
|
1925 |
TNetServerTransportDel = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer): NET_API_STATUS; stdcall;
|
1926 |
TNetServerTransportEnum = function(ServerName: LPWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
1927 |
|
1928 |
type
|
1929 |
TSERVER_INFO_100 = record
|
1930 |
sv100_platform_id : DWord;
|
1931 |
sv100_name : LPWSTR;
|
1932 |
end;
|
1933 |
|
1934 |
TSERVER_INFO_101 = record
|
1935 |
sv101_platform_id : DWord;
|
1936 |
sv101_name : LPWSTR;
|
1937 |
sv101_version_major : DWord;
|
1938 |
sv101_version_minor : DWord;
|
1939 |
sv101_type : DWord;
|
1940 |
sv101_comment : LPWSTR;
|
1941 |
end;
|
1942 |
|
1943 |
TSERVER_INFO_102 = record
|
1944 |
sv102_platform_id : DWord;
|
1945 |
sv102_name : LPWSTR;
|
1946 |
sv102_version_major : DWord;
|
1947 |
sv102_version_minor : DWord;
|
1948 |
sv102_type : DWord;
|
1949 |
sv102_comment : LPWSTR;
|
1950 |
sv102_users : DWord;
|
1951 |
sv102_disc : LongInt;
|
1952 |
sv102_hidden : Bool;
|
1953 |
sv102_announce : DWord;
|
1954 |
sv102_anndelta : DWord;
|
1955 |
sv102_licenses : DWord;
|
1956 |
sv102_userpath : LPWSTR;
|
1957 |
end;
|
1958 |
|
1959 |
TSERVER_INFO_402 = record
|
1960 |
sv402_ulist_mtime : DWord;
|
1961 |
sv402_glist_mtime : DWord;
|
1962 |
sv402_alist_mtime : DWord;
|
1963 |
sv402_alerts : LPWSTR;
|
1964 |
sv402_security : DWord;
|
1965 |
sv402_numadmin : DWord;
|
1966 |
sv402_lanmask : DWord;
|
1967 |
sv402_guestacct : LPWSTR;
|
1968 |
sv402_chdevs : DWord;
|
1969 |
sv402_chdevq : DWord;
|
1970 |
sv402_chdevjobs : DWord;
|
1971 |
sv402_connections : DWord;
|
1972 |
sv402_shares : DWord;
|
1973 |
sv402_openfiles : DWord;
|
1974 |
sv402_sessopens : DWord;
|
1975 |
sv402_sessvcs : DWord;
|
1976 |
sv402_sessreqs : DWord;
|
1977 |
sv402_opensearch : DWord;
|
1978 |
sv402_activelocks : DWord;
|
1979 |
sv402_numreqbuf : DWord;
|
1980 |
sv402_sizreqbuf : DWord;
|
1981 |
sv402_numbigbuf : DWord;
|
1982 |
sv402_numfiletasks : DWord;
|
1983 |
sv402_alertsched : DWord;
|
1984 |
sv402_erroralert : DWord;
|
1985 |
sv402_logonalert : DWord;
|
1986 |
sv402_accessalert : DWord;
|
1987 |
sv402_diskalert : DWord;
|
1988 |
sv402_netioalert : DWord;
|
1989 |
sv402_maxauditsz : DWord;
|
1990 |
sv402_srvheuristics : LPWSTR;
|
1991 |
end;
|
1992 |
|
1993 |
TSERVER_INFO_403 = record
|
1994 |
sv403_ulist_mtime : DWord;
|
1995 |
sv403_glist_mtime : DWord;
|
1996 |
sv403_alist_mtime : DWord;
|
1997 |
sv403_alerts : LPWSTR;
|
1998 |
sv403_security : DWord;
|
1999 |
sv403_numadmin : DWord;
|
2000 |
sv403_lanmask : DWord;
|
2001 |
sv403_guestacct : LPWSTR;
|
2002 |
sv403_chdevs : DWord;
|
2003 |
sv403_chdevq : DWord;
|
2004 |
sv403_chdevjobs : DWord;
|
2005 |
sv403_connections : DWord;
|
2006 |
sv403_shares : DWord;
|
2007 |
sv403_openfiles : DWord;
|
2008 |
sv403_sessopens : DWord;
|
2009 |
sv403_sessvcs : DWord;
|
2010 |
sv403_sessreqs : DWord;
|
2011 |
sv403_opensearch : DWord;
|
2012 |
sv403_activelocks : DWord;
|
2013 |
sv403_numreqbuf : DWord;
|
2014 |
sv403_sizreqbuf : DWord;
|
2015 |
sv403_numbigbuf : DWord;
|
2016 |
sv403_numfiletasks : DWord;
|
2017 |
sv403_alertsched : DWord;
|
2018 |
sv403_erroralert : DWord;
|
2019 |
sv403_logonalert : DWord;
|
2020 |
sv403_accessalert : DWord;
|
2021 |
sv403_diskalert : DWord;
|
2022 |
sv403_netioalert : DWord;
|
2023 |
sv403_maxauditsz : DWord;
|
2024 |
sv403_srvheuristics : LPWSTR;
|
2025 |
sv403_auditedevents : DWord;
|
2026 |
sv403_autoprofile : DWord;
|
2027 |
sv403_autopath : LPWSTR;
|
2028 |
end;
|
2029 |
|
2030 |
TSERVER_INFO_502 = record
|
2031 |
sv502_sessopens : DWord;
|
2032 |
sv502_sessvcs : DWord;
|
2033 |
sv502_opensearch : DWord;
|
2034 |
sv502_sizreqbuf : DWord;
|
2035 |
sv502_initworkitems : DWord;
|
2036 |
sv502_maxworkitems : DWord;
|
2037 |
sv502_rawworkitems : DWord;
|
2038 |
sv502_irpstacksize : DWord;
|
2039 |
sv502_maxrawbuflen : DWord;
|
2040 |
sv502_sessusers : DWord;
|
2041 |
sv502_sessconns : DWord;
|
2042 |
sv502_maxpagedmemoryusage : DWord;
|
2043 |
sv502_maxnonpagedmemoryusage : DWord;
|
2044 |
sv502_enablesoftcompat : Bool;
|
2045 |
sv502_enableforcedlogoff : Bool;
|
2046 |
sv502_timesource : Bool;
|
2047 |
sv502_acceptdownlevelapis : Bool;
|
2048 |
sv502_lmannounce : Bool;
|
2049 |
end;
|
2050 |
|
2051 |
TSERVER_INFO_503 = record
|
2052 |
sv503_sessopens : DWord;
|
2053 |
sv503_sessvcs : DWord;
|
2054 |
sv503_opensearch : DWord;
|
2055 |
sv503_sizreqbuf : DWord;
|
2056 |
sv503_initworkitems : DWord;
|
2057 |
sv503_maxworkitems : DWord;
|
2058 |
sv503_rawworkitems : DWord;
|
2059 |
sv503_irpstacksize : DWord;
|
2060 |
sv503_maxrawbuflen : DWord;
|
2061 |
sv503_sessusers : DWord;
|
2062 |
sv503_sessconns : DWord;
|
2063 |
sv503_maxpagedmemoryusage : DWord;
|
2064 |
sv503_maxnonpagedmemoryusage : DWord;
|
2065 |
sv503_enablesoftcompat : Bool;
|
2066 |
sv503_enableforcedlogoff : Bool;
|
2067 |
sv503_timesource : Bool;
|
2068 |
sv503_acceptdownlevelapis : Bool;
|
2069 |
sv503_lmannounce : Bool;
|
2070 |
sv503_domain : LPWSTR;
|
2071 |
sv503_maxcopyreadlen : DWord;
|
2072 |
sv503_maxcopywritelen : DWord;
|
2073 |
sv503_minkeepsearch : DWord;
|
2074 |
sv503_maxkeepsearch : DWord;
|
2075 |
sv503_minkeepcomplsearch : DWord;
|
2076 |
sv503_maxkeepcomplsearch : DWord;
|
2077 |
sv503_threadcountadd : DWord;
|
2078 |
sv503_numblockthreads : DWord;
|
2079 |
sv503_scavtimeout : DWord;
|
2080 |
sv503_minrcvqueue : DWord;
|
2081 |
sv503_minfreeworkitems : DWord;
|
2082 |
sv503_xactmemsize : DWord;
|
2083 |
sv503_threadpriority : DWord;
|
2084 |
sv503_maxmpxct : DWord;
|
2085 |
sv503_oplockbreakwait : DWord;
|
2086 |
sv503_oplockbreakresponsewait : DWord;
|
2087 |
sv503_enableoplocks : Bool;
|
2088 |
sv503_enableoplockforceclose : Bool;
|
2089 |
sv503_enablefcbopens : Bool;
|
2090 |
sv503_enableraw : Bool;
|
2091 |
sv503_enablesharednetdrives : Bool;
|
2092 |
sv503_minfreeconnections : DWord;
|
2093 |
sv503_maxfreeconnections : DWord;
|
2094 |
end;
|
2095 |
|
2096 |
TSERVER_INFO_599 = record
|
2097 |
sv599_sessopens : DWord;
|
2098 |
sv599_sessvcs : DWord;
|
2099 |
sv599_opensearch : DWord;
|
2100 |
sv599_sizreqbuf : DWord;
|
2101 |
sv599_initworkitems : DWord;
|
2102 |
sv599_maxworkitems : DWord;
|
2103 |
sv599_rawworkitems : DWord;
|
2104 |
sv599_irpstacksize : DWord;
|
2105 |
sv599_maxrawbuflen : DWord;
|
2106 |
sv599_sessusers : DWord;
|
2107 |
sv599_sessconns : DWord;
|
2108 |
sv599_maxpagedmemoryusage : DWord;
|
2109 |
sv599_maxnonpagedmemoryusage : DWord;
|
2110 |
sv599_enablesoftcompat : Bool;
|
2111 |
sv599_enableforcedlogoff : Bool;
|
2112 |
sv599_timesource : Bool;
|
2113 |
sv599_acceptdownlevelapis : Bool;
|
2114 |
sv599_lmannounce : Bool;
|
2115 |
sv599_domain : LPWSTR;
|
2116 |
sv599_maxcopyreadlen : DWord;
|
2117 |
sv599_maxcopywritelen : DWord;
|
2118 |
sv599_minkeepsearch : DWord;
|
2119 |
sv599_maxkeepsearch : DWord;
|
2120 |
sv599_minkeepcomplsearch : DWord;
|
2121 |
sv599_maxkeepcomplsearch : DWord;
|
2122 |
sv599_threadcountadd : DWord;
|
2123 |
sv599_numblockthreads : DWord;
|
2124 |
sv599_scavtimeout : DWord;
|
2125 |
sv599_minrcvqueue : DWord;
|
2126 |
sv599_minfreeworkitems : DWord;
|
2127 |
sv599_xactmemsize : DWord;
|
2128 |
sv599_threadpriority : DWord;
|
2129 |
sv599_maxmpxct : DWord;
|
2130 |
sv599_oplockbreakwait : DWord;
|
2131 |
sv599_oplockbreakresponsewait : DWord;
|
2132 |
sv599_enableoplocks : Bool;
|
2133 |
sv599_enableoplockforceclose : Bool;
|
2134 |
sv599_enablefcbopens : Bool;
|
2135 |
sv599_enableraw : Bool;
|
2136 |
sv599_enablesharednetdrives : Bool;
|
2137 |
sv599_minfreeconnections : DWord;
|
2138 |
sv599_maxfreeconnections : DWord;
|
2139 |
sv599_initsesstable : DWord;
|
2140 |
sv599_initconntable : DWord;
|
2141 |
sv599_initfiletable : DWord;
|
2142 |
sv599_initsearchtable : DWord;
|
2143 |
sv599_alertschedule : DWord;
|
2144 |
sv599_errorthreshold : DWord;
|
2145 |
sv599_networkerrorthreshold : DWord;
|
2146 |
sv599_diskspacethreshold : DWord;
|
2147 |
sv599_reserved : DWord;
|
2148 |
sv599_maxlinkdelay : DWord;
|
2149 |
sv599_minlinkthroughput : DWord;
|
2150 |
sv599_linkinfovalidtime : DWord;
|
2151 |
sv599_scavqosinfoupdatetime : DWord;
|
2152 |
sv599_maxworkitemidletime : DWord;
|
2153 |
end;
|
2154 |
|
2155 |
TSERVER_INFO_598 = record
|
2156 |
sv598_maxrawworkitems : DWord;
|
2157 |
sv598_maxthreadsperqueue : DWord;
|
2158 |
sv598_producttype : DWord;
|
2159 |
sv598_serversize : DWord;
|
2160 |
sv598_connectionlessautodisc : DWord;
|
2161 |
sv598_sharingviolationretries : DWord;
|
2162 |
sv598_sharingviolationdelay : DWord;
|
2163 |
sv598_maxglobalopensearch : DWord;
|
2164 |
sv598_removeduplicatesearches : DWord;
|
2165 |
sv598_lockviolationoffset : DWord;
|
2166 |
sv598_lockviolationdelay : DWord;
|
2167 |
sv598_mdlreadswitchover : DWord;
|
2168 |
sv598_cachedopenlimit : DWord;
|
2169 |
sv598_otherqueueaffinity : DWord;
|
2170 |
sv598_restrictnullsessaccess : Bool;
|
2171 |
sv598_enablewfw311directipx : Bool;
|
2172 |
sv598_queuesamplesecs : DWord;
|
2173 |
sv598_balancecount : DWord;
|
2174 |
sv598_preferredaffinity : DWord;
|
2175 |
sv598_maxfreerfcbs : DWord;
|
2176 |
sv598_maxfreemfcbs : DWord;
|
2177 |
sv598_maxfreelfcbs : DWord;
|
2178 |
sv598_maxfreepagedpoolchunks : DWord;
|
2179 |
sv598_minpagedpoolchunksize : DWord;
|
2180 |
sv598_maxpagedpoolchunksize : DWord;
|
2181 |
sv598_sendsfrompreferredprocesso : Bool;
|
2182 |
sv598_cacheddirectorylimit : DWord;
|
2183 |
sv598_maxcopylength : DWord;
|
2184 |
sv598_enablebulktransfer : Bool;
|
2185 |
sv598_enablecompression : Bool;
|
2186 |
sv598_autosharewks : Bool;
|
2187 |
sv598_autoshareserver : Bool;
|
2188 |
end;
|
2189 |
|
2190 |
TSERVER_INFO_1005 = record
|
2191 |
sv1005_comment : LPWSTR;
|
2192 |
end;
|
2193 |
|
2194 |
TSERVER_INFO_1107 = record
|
2195 |
sv1107_users : DWord;
|
2196 |
end;
|
2197 |
|
2198 |
TSERVER_INFO_1010 = record
|
2199 |
sv1010_disc : LongInt;
|
2200 |
end;
|
2201 |
|
2202 |
TSERVER_INFO_1016 = record
|
2203 |
sv1016_hidden : Bool;
|
2204 |
end;
|
2205 |
|
2206 |
TSERVER_INFO_1017 = record
|
2207 |
sv1017_announce : DWord;
|
2208 |
end;
|
2209 |
|
2210 |
TSERVER_INFO_1018 = record
|
2211 |
sv1018_anndelta : DWord;
|
2212 |
end;
|
2213 |
|
2214 |
TSERVER_INFO_1501 = record
|
2215 |
sv1501_sessopens : DWord;
|
2216 |
end;
|
2217 |
|
2218 |
TSERVER_INFO_1502 = record
|
2219 |
sv1502_sessvcs : DWord;
|
2220 |
end;
|
2221 |
|
2222 |
TSERVER_INFO_1503 = record
|
2223 |
sv1503_opensearch : DWord;
|
2224 |
end;
|
2225 |
|
2226 |
TSERVER_INFO_1506 = record
|
2227 |
sv1506_maxworkitems : DWord;
|
2228 |
end;
|
2229 |
|
2230 |
TSERVER_INFO_1509 = record
|
2231 |
sv1509_maxrawbuflen : DWord;
|
2232 |
end;
|
2233 |
|
2234 |
TSERVER_INFO_1510 = record
|
2235 |
sv1510_sessusers : DWord;
|
2236 |
end;
|
2237 |
|
2238 |
TSERVER_INFO_1511 = record
|
2239 |
sv1511_sessconns : DWord;
|
2240 |
end;
|
2241 |
|
2242 |
TSERVER_INFO_1512 = record
|
2243 |
sv1512_maxnonpagedmemoryusage : DWord;
|
2244 |
end;
|
2245 |
|
2246 |
TSERVER_INFO_1513 = record
|
2247 |
sv1513_maxpagedmemoryusage : DWord;
|
2248 |
end;
|
2249 |
|
2250 |
TSERVER_INFO_1514 = record
|
2251 |
sv1514_enablesoftcompat : Bool;
|
2252 |
end;
|
2253 |
|
2254 |
TSERVER_INFO_1515 = record
|
2255 |
sv1515_enableforcedlogoff : Bool;
|
2256 |
end;
|
2257 |
|
2258 |
TSERVER_INFO_1516 = record
|
2259 |
sv1516_timesource : Bool;
|
2260 |
end;
|
2261 |
|
2262 |
TSERVER_INFO_1518 = record
|
2263 |
sv1518_lmannounce : Bool;
|
2264 |
end;
|
2265 |
|
2266 |
TSERVER_INFO_1520 = record
|
2267 |
sv1520_maxcopyreadlen : DWord;
|
2268 |
end;
|
2269 |
|
2270 |
TSERVER_INFO_1521 = record
|
2271 |
sv1521_maxcopywritelen : DWord;
|
2272 |
end;
|
2273 |
|
2274 |
TSERVER_INFO_1522 = record
|
2275 |
sv1522_minkeepsearch : DWord;
|
2276 |
end;
|
2277 |
|
2278 |
TSERVER_INFO_1523 = record
|
2279 |
sv1523_maxkeepsearch : DWord;
|
2280 |
end;
|
2281 |
|
2282 |
TSERVER_INFO_1524 = record
|
2283 |
sv1524_minkeepcomplsearch : DWord;
|
2284 |
end;
|
2285 |
|
2286 |
TSERVER_INFO_1525 = record
|
2287 |
sv1525_maxkeepcomplsearch : DWord;
|
2288 |
end;
|
2289 |
|
2290 |
TSERVER_INFO_1528 = record
|
2291 |
sv1528_scavtimeout : DWord;
|
2292 |
end;
|
2293 |
|
2294 |
TSERVER_INFO_1529 = record
|
2295 |
sv1529_minrcvqueue : DWord;
|
2296 |
end;
|
2297 |
|
2298 |
TSERVER_INFO_1530 = record
|
2299 |
sv1530_minfreeworkitems : DWord;
|
2300 |
end;
|
2301 |
|
2302 |
TSERVER_INFO_1533 = record
|
2303 |
sv1533_maxmpxct : DWord;
|
2304 |
end;
|
2305 |
|
2306 |
TSERVER_INFO_1534 = record
|
2307 |
sv1534_oplockbreakwait : DWord;
|
2308 |
end;
|
2309 |
|
2310 |
TSERVER_INFO_1535 = record
|
2311 |
sv1535_oplockbreakresponsewait : DWord;
|
2312 |
end;
|
2313 |
|
2314 |
TSERVER_INFO_1536 = record
|
2315 |
sv1536_enableoplocks : Bool;
|
2316 |
end;
|
2317 |
|
2318 |
TSERVER_INFO_1537 = record
|
2319 |
sv1537_enableoplockforceclose : Bool;
|
2320 |
end;
|
2321 |
|
2322 |
TSERVER_INFO_1538 = record
|
2323 |
sv1538_enablefcbopens : Bool;
|
2324 |
end;
|
2325 |
|
2326 |
TSERVER_INFO_1539 = record
|
2327 |
sv1539_enableraw : Bool;
|
2328 |
end;
|
2329 |
|
2330 |
TSERVER_INFO_1540 = record
|
2331 |
sv1540_enablesharednetdrives : Bool;
|
2332 |
end;
|
2333 |
|
2334 |
TSERVER_INFO_1541 = record
|
2335 |
sv1541_minfreeconnections : Bool;
|
2336 |
end;
|
2337 |
|
2338 |
TSERVER_INFO_1542 = record
|
2339 |
sv1542_maxfreeconnections : Bool;
|
2340 |
end;
|
2341 |
|
2342 |
TSERVER_INFO_1543 = record
|
2343 |
sv1543_initsesstable : DWord;
|
2344 |
end;
|
2345 |
|
2346 |
TSERVER_INFO_1544 = record
|
2347 |
sv1544_initconntable : DWord;
|
2348 |
end;
|
2349 |
|
2350 |
TSERVER_INFO_1545 = record
|
2351 |
sv1545_initfiletable : DWord;
|
2352 |
end;
|
2353 |
|
2354 |
TSERVER_INFO_1546 = record
|
2355 |
sv1546_initsearchtable : DWord;
|
2356 |
end;
|
2357 |
|
2358 |
TSERVER_INFO_1547 = record
|
2359 |
sv1547_alertschedule : DWord;
|
2360 |
end;
|
2361 |
|
2362 |
TSERVER_INFO_1548 = record
|
2363 |
sv1548_errorthreshold : DWord;
|
2364 |
end;
|
2365 |
|
2366 |
TSERVER_INFO_1549 = record
|
2367 |
sv1549_networkerrorthreshold : DWord;
|
2368 |
end;
|
2369 |
|
2370 |
TSERVER_INFO_1550 = record
|
2371 |
sv1550_diskspacethreshold : DWord;
|
2372 |
end;
|
2373 |
|
2374 |
TSERVER_INFO_1552 = record
|
2375 |
sv1552_maxlinkdelay : DWord;
|
2376 |
end;
|
2377 |
|
2378 |
TSERVER_INFO_1553 = record
|
2379 |
sv1553_minlinkthroughput : DWord;
|
2380 |
end;
|
2381 |
|
2382 |
TSERVER_INFO_1554 = record
|
2383 |
sv1554_linkinfovalidtime : DWord;
|
2384 |
end;
|
2385 |
|
2386 |
TSERVER_INFO_1555 = record
|
2387 |
sv1555_scavqosinfoupdatetime : DWord;
|
2388 |
end;
|
2389 |
|
2390 |
TSERVER_INFO_1556 = record
|
2391 |
sv1556_maxworkitemidletime : DWord;
|
2392 |
end;
|
2393 |
|
2394 |
TSERVER_INFO_1557 = record
|
2395 |
sv1557_maxrawworkitems : DWord;
|
2396 |
end;
|
2397 |
|
2398 |
TSERVER_INFO_1560 = record
|
2399 |
sv1560_producttype : DWord;
|
2400 |
end;
|
2401 |
|
2402 |
TSERVER_INFO_1561 = record
|
2403 |
sv1561_serversize : DWord;
|
2404 |
end;
|
2405 |
|
2406 |
TSERVER_INFO_1562 = record
|
2407 |
sv1562_connectionlessautodisc : DWord;
|
2408 |
end;
|
2409 |
|
2410 |
TSERVER_INFO_1563 = record
|
2411 |
sv1563_sharingviolationretries : DWord;
|
2412 |
end;
|
2413 |
|
2414 |
TSERVER_INFO_1564 = record
|
2415 |
sv1564_sharingviolationdelay : DWord;
|
2416 |
end;
|
2417 |
|
2418 |
TSERVER_INFO_1565 = record
|
2419 |
sv1565_maxglobalopensearch : DWord;
|
2420 |
end;
|
2421 |
|
2422 |
TSERVER_INFO_1566 = record
|
2423 |
sv1566_removeduplicatesearches : Bool;
|
2424 |
end;
|
2425 |
|
2426 |
TSERVER_INFO_1567 = record
|
2427 |
sv1567_lockviolationretries : DWord;
|
2428 |
end;
|
2429 |
|
2430 |
TSERVER_INFO_1568 = record
|
2431 |
sv1568_lockviolationoffset : DWord;
|
2432 |
end;
|
2433 |
|
2434 |
TSERVER_INFO_1569 = record
|
2435 |
sv1569_lockviolationdelay : DWord;
|
2436 |
end;
|
2437 |
|
2438 |
TSERVER_INFO_1570 = record
|
2439 |
sv1570_mdlreadswitchover : DWord;
|
2440 |
end;
|
2441 |
|
2442 |
TSERVER_INFO_1571 = record
|
2443 |
sv1571_cachedopenlimit : DWord;
|
2444 |
end;
|
2445 |
|
2446 |
TSERVER_INFO_1572 = record
|
2447 |
sv1572_criticalthreads : DWord;
|
2448 |
end;
|
2449 |
|
2450 |
TSERVER_INFO_1573 = record
|
2451 |
sv1573_restrictnullsessaccess : DWord;
|
2452 |
end;
|
2453 |
|
2454 |
TSERVER_INFO_1574 = record
|
2455 |
sv1574_enablewfw311directipx : DWord;
|
2456 |
end;
|
2457 |
|
2458 |
TSERVER_INFO_1575 = record
|
2459 |
sv1575_otherqueueaffinity : DWord;
|
2460 |
end;
|
2461 |
|
2462 |
TSERVER_INFO_1576 = record
|
2463 |
sv1576_queuesamplesecs : DWord;
|
2464 |
end;
|
2465 |
|
2466 |
TSERVER_INFO_1577 = record
|
2467 |
sv1577_balancecount : DWord;
|
2468 |
end;
|
2469 |
|
2470 |
TSERVER_INFO_1578 = record
|
2471 |
sv1578_preferredaffinity : DWord;
|
2472 |
end;
|
2473 |
|
2474 |
TSERVER_INFO_1579 = record
|
2475 |
sv1579_maxfreerfcbs : DWord;
|
2476 |
end;
|
2477 |
|
2478 |
TSERVER_INFO_1580 = record
|
2479 |
sv1580_maxfreemfcbs : DWord;
|
2480 |
end;
|
2481 |
|
2482 |
TSERVER_INFO_1581 = record
|
2483 |
sv1581_maxfreemlcbs : DWord;
|
2484 |
end;
|
2485 |
|
2486 |
TSERVER_INFO_1582 = record
|
2487 |
sv1582_maxfreepagedpoolchunks : DWord;
|
2488 |
end;
|
2489 |
|
2490 |
TSERVER_INFO_1583 = record
|
2491 |
sv1583_minpagedpoolchunksize : DWord;
|
2492 |
end;
|
2493 |
|
2494 |
TSERVER_INFO_1584 = record
|
2495 |
sv1584_maxpagedpoolchunksize : DWord;
|
2496 |
end;
|
2497 |
|
2498 |
TSERVER_INFO_1585 = record
|
2499 |
sv1585_sendsfrompreferredprocessor: Bool;
|
2500 |
end;
|
2501 |
|
2502 |
TSERVER_INFO_1586 = record
|
2503 |
sv1586_maxthreadsperqueue : DWord;
|
2504 |
end;
|
2505 |
|
2506 |
TSERVER_INFO_1587 = record
|
2507 |
sv1587_cacheddirectorylimit : DWord;
|
2508 |
end;
|
2509 |
|
2510 |
TSERVER_INFO_1588 = record
|
2511 |
sv1588_maxcopylength : DWord;
|
2512 |
end;
|
2513 |
|
2514 |
TSERVER_INFO_1589 = record
|
2515 |
sv1589_enablebulktransfer : DWord;
|
2516 |
end;
|
2517 |
|
2518 |
TSERVER_INFO_1590 = record
|
2519 |
sv1590_enablecompression : DWord;
|
2520 |
end;
|
2521 |
|
2522 |
TSERVER_INFO_1591 = record
|
2523 |
sv1591_autosharewks : DWord;
|
2524 |
end;
|
2525 |
|
2526 |
TSERVER_INFO_1592 = record
|
2527 |
sv1592_autoshareserver : DWord;
|
2528 |
end;
|
2529 |
|
2530 |
(*
|
2531 |
A special structure definition is required in order for this
|
2532 |
structure to work with RPC. The problem is that having addresslength
|
2533 |
indicate the number of bytes in address means that RPC must know the
|
2534 |
link between the two.
|
2535 |
*)
|
2536 |
TSERVER_TRANSPORT_INFO_0 = record
|
2537 |
svti0_numberofvcs : DWord;
|
2538 |
svti0_transportname : LPSTR;
|
2539 |
svti0_transportaddress : Pointer;
|
2540 |
svti0_transportaddresslength : DWord;
|
2541 |
svti0_networkaddress : LPWSTR;
|
2542 |
end;
|
2543 |
|
2544 |
TSERVER_TRANSPORT_INFO_1 = record
|
2545 |
svti1_numberofvcs : DWord;
|
2546 |
svti1_transportname : LPWSTR;
|
2547 |
svti1_transportaddress : Pointer;
|
2548 |
svti1_transportaddresslength : DWord;
|
2549 |
svti1_networkaddress : LPWSTR;
|
2550 |
svti1_domain : LPWSTR;
|
2551 |
end;
|
2552 |
|
2553 |
const
|
2554 |
{ The platform ID indicates the levels to use for platform-specific information. }
|
2555 |
SV_PLATFORM_ID_OS2 = 400;
|
2556 |
SV_PLATFORM_ID_NT = 500;
|
2557 |
|
2558 |
{ Mask to be applied to svX_version_major in order to obtain the major version number. }
|
2559 |
MAJOR_VERSION_MASK = $0F;
|
2560 |
|
2561 |
{ Bit-mapped values for svX_type fields. X = 1, 2 or 3. }
|
2562 |
SV_TYPE_WORKSTATION = $00000001;
|
2563 |
SV_TYPE_SERVER = $00000002;
|
2564 |
SV_TYPE_SQLSERVER = $00000004;
|
2565 |
SV_TYPE_DOMAIN_CTRL = $00000008;
|
2566 |
SV_TYPE_DOMAIN_BAKCTRL = $00000010;
|
2567 |
SV_TYPE_TIME_SOURCE = $00000020;
|
2568 |
SV_TYPE_AFP = $00000040;
|
2569 |
SV_TYPE_NOVELL = $00000080;
|
2570 |
SV_TYPE_DOMAIN_MEMBER = $00000100;
|
2571 |
SV_TYPE_PRINTQ_SERVER = $00000200;
|
2572 |
SV_TYPE_DIALIN_SERVER = $00000400;
|
2573 |
SV_TYPE_XENIX_SERVER = $00000800;
|
2574 |
SV_TYPE_SERVER_UNIX = SV_TYPE_XENIX_SERVER;
|
2575 |
SV_TYPE_NT = $00001000;
|
2576 |
SV_TYPE_WFW = $00002000;
|
2577 |
SV_TYPE_SERVER_MFPN = $00004000;
|
2578 |
SV_TYPE_SERVER_NT = $00008000;
|
2579 |
SV_TYPE_POTENTIAL_BROWSER = $00010000;
|
2580 |
SV_TYPE_BACKUP_BROWSER = $00020000;
|
2581 |
SV_TYPE_MASTER_BROWSER = $00040000;
|
2582 |
SV_TYPE_DOMAIN_MASTER = $00080000;
|
2583 |
SV_TYPE_SERVER_OSF = $00100000;
|
2584 |
SV_TYPE_SERVER_VMS = $00200000;
|
2585 |
SV_TYPE_WINDOWS = $00400000;
|
2586 |
SV_TYPE_DFS = $00800000;
|
2587 |
SV_TYPE_CLUSTER_NT = $01000000;
|
2588 |
SV_TYPE_TERMINALSERVER = $02000000;
|
2589 |
SV_TYPE_DCE = $10000000;
|
2590 |
SV_TYPE_ALTERNATE_XPORT = $20000000;
|
2591 |
SV_TYPE_LOCAL_LIST_ONLY = $40000000;
|
2592 |
SV_TYPE_DOMAIN_ENUM = $80000000;
|
2593 |
SV_TYPE_ALL = $FFFFFFFF;
|
2594 |
|
2595 |
{ Special value for sv102_disc that specifies infinite disconnect time. }
|
2596 |
SV_NODISC = (-1); { No autodisconnect timeout enforced }
|
2597 |
|
2598 |
{ Values of svX_security field. X = 2 or 3. }
|
2599 |
SV_USERSECURITY = 1;
|
2600 |
SV_SHARESECURITY = 0;
|
2601 |
|
2602 |
{ Values of svX_hidden field. X = 2 or 3. }
|
2603 |
SV_HIDDEN = 1;
|
2604 |
SV_VISIBLE = 0;
|
2605 |
|
2606 |
{ Values for ParmError parameter to NetServerSetInfo. }
|
2607 |
SV_PLATFORM_ID_PARMNUM = 101;
|
2608 |
SV_NAME_PARMNUM = 102;
|
2609 |
SV_VERSION_MAJOR_PARMNUM = 103;
|
2610 |
SV_VERSION_MINOR_PARMNUM = 104;
|
2611 |
SV_TYPE_PARMNUM = 105;
|
2612 |
SV_COMMENT_PARMNUM = 5;
|
2613 |
SV_USERS_PARMNUM = 107;
|
2614 |
SV_DISC_PARMNUM = 10;
|
2615 |
SV_HIDDEN_PARMNUM = 16;
|
2616 |
SV_ANNOUNCE_PARMNUM = 17;
|
2617 |
SV_ANNDELTA_PARMNUM = 18;
|
2618 |
SV_USERPATH_PARMNUM = 112;
|
2619 |
|
2620 |
SV_ULIST_MTIME_PARMNUM = 401;
|
2621 |
SV_GLIST_MTIME_PARMNUM = 402;
|
2622 |
SV_ALIST_MTIME_PARMNUM = 403;
|
2623 |
SV_ALERTS_PARMNUM = 11;
|
2624 |
SV_SECURITY_PARMNUM = 405;
|
2625 |
SV_NUMADMIN_PARMNUM = 406;
|
2626 |
SV_LANMASK_PARMNUM = 407;
|
2627 |
SV_GUESTACC_PARMNUM = 408;
|
2628 |
SV_CHDEVQ_PARMNUM = 410;
|
2629 |
SV_CHDEVJOBS_PARMNUM = 411;
|
2630 |
SV_CONNECTIONS_PARMNUM = 412;
|
2631 |
SV_SHARES_PARMNUM = 413;
|
2632 |
SV_OPENFILES_PARMNUM = 414;
|
2633 |
SV_SESSREQS_PARMNUM = 417;
|
2634 |
SV_ACTIVELOCKS_PARMNUM = 419;
|
2635 |
SV_NUMREQBUF_PARMNUM = 420;
|
2636 |
SV_NUMBIGBUF_PARMNUM = 422;
|
2637 |
SV_NUMFILETASKS_PARMNUM = 423;
|
2638 |
SV_ALERTSCHED_PARMNUM = 37;
|
2639 |
SV_ERRORALERT_PARMNUM = 38;
|
2640 |
SV_LOGONALERT_PARMNUM = 39;
|
2641 |
SV_ACCESSALERT_PARMNUM = 40;
|
2642 |
SV_DISKALERT_PARMNUM = 41;
|
2643 |
SV_NETIOALERT_PARMNUM = 42;
|
2644 |
SV_MAXAUDITSZ_PARMNUM = 43;
|
2645 |
SV_SRVHEURISTICS_PARMNUM = 431;
|
2646 |
|
2647 |
SV_SESSOPENS_PARMNUM = 501;
|
2648 |
SV_SESSVCS_PARMNUM = 502;
|
2649 |
SV_OPENSEARCH_PARMNUM = 503;
|
2650 |
SV_SIZREQBUF_PARMNUM = 504;
|
2651 |
SV_INITWORKITEMS_PARMNUM = 505;
|
2652 |
SV_MAXWORKITEMS_PARMNUM = 506;
|
2653 |
SV_RAWWORKITEMS_PARMNUM = 507;
|
2654 |
SV_IRPSTACKSIZE_PARMNUM = 508;
|
2655 |
SV_MAXRAWBUFLEN_PARMNUM = 509;
|
2656 |
SV_SESSUSERS_PARMNUM = 510;
|
2657 |
SV_SESSCONNS_PARMNUM = 511;
|
2658 |
SV_MAXNONPAGEDMEMORYUSAGE_PARMNUM = 512;
|
2659 |
SV_MAXPAGEDMEMORYUSAGE_PARMNUM = 513;
|
2660 |
SV_ENABLESOFTCOMPAT_PARMNUM = 514;
|
2661 |
SV_ENABLEFORCEDLOGOFF_PARMNUM = 515;
|
2662 |
SV_TIMESOURCE_PARMNUM = 516;
|
2663 |
SV_ACCEPTDOWNLEVELAPIS_PARMNUM = 517;
|
2664 |
SV_LMANNOUNCE_PARMNUM = 518;
|
2665 |
SV_DOMAIN_PARMNUM = 519;
|
2666 |
SV_MAXCOPYREADLEN_PARMNUM = 520;
|
2667 |
SV_MAXCOPYWRITELEN_PARMNUM = 521;
|
2668 |
SV_MINKEEPSEARCH_PARMNUM = 522;
|
2669 |
SV_MAXKEEPSEARCH_PARMNUM = 523;
|
2670 |
SV_MINKEEPCOMPLSEARCH_PARMNUM = 524;
|
2671 |
SV_MAXKEEPCOMPLSEARCH_PARMNUM = 525;
|
2672 |
SV_THREADCOUNTADD_PARMNUM = 526;
|
2673 |
SV_NUMBLOCKTHREADS_PARMNUM = 527;
|
2674 |
SV_SCAVTIMEOUT_PARMNUM = 528;
|
2675 |
SV_MINRCVQUEUE_PARMNUM = 529;
|
2676 |
SV_MINFREEWORKITEMS_PARMNUM = 530;
|
2677 |
SV_XACTMEMSIZE_PARMNUM = 531;
|
2678 |
SV_THREADPRIORITY_PARMNUM = 532;
|
2679 |
SV_MAXMPXCT_PARMNUM = 533;
|
2680 |
SV_OPLOCKBREAKWAIT_PARMNUM = 534;
|
2681 |
SV_OPLOCKBREAKRESPONSEWAIT_PARMNUM = 535;
|
2682 |
SV_ENABLEOPLOCKS_PARMNUM = 536;
|
2683 |
SV_ENABLEOPLOCKFORCECLOSE_PARMNUM = 537;
|
2684 |
SV_ENABLEFCBOPENS_PARMNUM = 538;
|
2685 |
SV_ENABLERAW_PARMNUM = 539;
|
2686 |
SV_ENABLESHAREDNETDRIVES_PARMNUM = 540;
|
2687 |
SV_MINFREECONNECTIONS_PARMNUM = 541;
|
2688 |
SV_MAXFREECONNECTIONS_PARMNUM = 542;
|
2689 |
SV_INITSESSTABLE_PARMNUM = 543;
|
2690 |
SV_INITCONNTABLE_PARMNUM = 544;
|
2691 |
SV_INITFILETABLE_PARMNUM = 545;
|
2692 |
SV_INITSEARCHTABLE_PARMNUM = 546;
|
2693 |
SV_ALERTSCHEDULE_PARMNUM = 547;
|
2694 |
SV_ERRORTHRESHOLD_PARMNUM = 548;
|
2695 |
SV_NETWORKERRORTHRESHOLD_PARMNUM = 549;
|
2696 |
SV_DISKSPACETHRESHOLD_PARMNUM = 550;
|
2697 |
SV_MAXLINKDELAY_PARMNUM = 552;
|
2698 |
SV_MINLINKTHROUGHPUT_PARMNUM = 553;
|
2699 |
SV_LINKINFOVALIDTIME_PARMNUM = 554;
|
2700 |
SV_SCAVQOSINFOUPDATETIME_PARMNUM = 555;
|
2701 |
SV_MAXWORKITEMIDLETIME_PARMNUM = 556;
|
2702 |
SV_MAXRAWWORKITEMS_PARMNUM = 557;
|
2703 |
SV_PRODUCTTYPE_PARMNUM = 560;
|
2704 |
SV_SERVERSIZE_PARMNUM = 561;
|
2705 |
SV_CONNECTIONLESSAUTODISC_PARMNUM = 562;
|
2706 |
SV_SHARINGVIOLATIONRETRIES_PARMNUM = 563;
|
2707 |
SV_SHARINGVIOLATIONDELAY_PARMNUM = 564;
|
2708 |
SV_MAXGLOBALOPENSEARCH_PARMNUM = 565;
|
2709 |
SV_REMOVEDUPLICATESEARCHES_PARMNUM = 566;
|
2710 |
SV_LOCKVIOLATIONRETRIES_PARMNUM = 567;
|
2711 |
SV_LOCKVIOLATIONOFFSET_PARMNUM = 568;
|
2712 |
SV_LOCKVIOLATIONDELAY_PARMNUM = 569;
|
2713 |
SV_MDLREADSWITCHOVER_PARMNUM = 570;
|
2714 |
SV_CACHEDOPENLIMIT_PARMNUM = 571;
|
2715 |
SV_CRITICALTHREADS_PARMNUM = 572;
|
2716 |
SV_RESTRICTNULLSESSACCESS_PARMNUM = 573;
|
2717 |
SV_ENABLEWFW311DIRECTIPX_PARMNUM = 574;
|
2718 |
SV_OTHERQUEUEAFFINITY_PARMNUM = 575;
|
2719 |
SV_QUEUESAMPLESECS_PARMNUM = 576;
|
2720 |
SV_BALANCECOUNT_PARMNUM = 577;
|
2721 |
SV_PREFERREDAFFINITY_PARMNUM = 578;
|
2722 |
SV_MAXFREERFCBS_PARMNUM = 579;
|
2723 |
SV_MAXFREEMFCBS_PARMNUM = 580;
|
2724 |
SV_MAXFREELFCBS_PARMNUM = 581;
|
2725 |
SV_MAXFREEPAGEDPOOLCHUNKS_PARMNUM = 582;
|
2726 |
SV_MINPAGEDPOOLCHUNKSIZE_PARMNUM = 583;
|
2727 |
SV_MAXPAGEDPOOLCHUNKSIZE_PARMNUM = 584;
|
2728 |
SV_SENDSFROMPREFERREDPROCESSOR_PARMNUM = 585;
|
2729 |
SV_MAXTHREADSPERQUEUE_PARMNUM = 586;
|
2730 |
SV_CACHEDDIRECTORYLIMIT_PARMNUM = 587;
|
2731 |
SV_MAXCOPYLENGTH_PARMNUM = 588;
|
2732 |
SV_ENABLEBULKTRANSFER_PARMNUM = 589;
|
2733 |
SV_ENABLECOMPRESSION_PARMNUM = 590;
|
2734 |
SV_AUTOSHAREWKS_PARMNUM = 591;
|
2735 |
SV_AUTOSHARESERVER_PARMNUM = 592;
|
2736 |
|
2737 |
{ Single-field infolevels for NetServerSetInfo. }
|
2738 |
SV_COMMENT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_COMMENT_PARMNUM);
|
2739 |
SV_USERS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_USERS_PARMNUM);
|
2740 |
SV_DISC_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_DISC_PARMNUM);
|
2741 |
SV_HIDDEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_HIDDEN_PARMNUM);
|
2742 |
SV_ANNOUNCE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ANNOUNCE_PARMNUM);
|
2743 |
SV_ANNDELTA_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ANNDELTA_PARMNUM);
|
2744 |
SV_SESSOPENS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SESSOPENS_PARMNUM);
|
2745 |
SV_SESSVCS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SESSVCS_PARMNUM);
|
2746 |
SV_OPENSEARCH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_OPENSEARCH_PARMNUM);
|
2747 |
SV_MAXWORKITEMS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXWORKITEMS_PARMNUM);
|
2748 |
SV_MAXRAWBUFLEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXRAWBUFLEN_PARMNUM);
|
2749 |
SV_SESSUSERS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SESSUSERS_PARMNUM);
|
2750 |
SV_SESSCONNS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SESSCONNS_PARMNUM);
|
2751 |
SV_MAXNONPAGEDMEMORYUSAGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXNONPAGEDMEMORYUSAGE_PARMNUM);
|
2752 |
SV_MAXPAGEDMEMORYUSAGE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXPAGEDMEMORYUSAGE_PARMNUM);
|
2753 |
SV_ENABLESOFTCOMPAT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLESOFTCOMPAT_PARMNUM);
|
2754 |
SV_ENABLEFORCEDLOGOFF_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEFORCEDLOGOFF_PARMNUM);
|
2755 |
SV_TIMESOURCE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_TIMESOURCE_PARMNUM);
|
2756 |
SV_LMANNOUNCE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_LMANNOUNCE_PARMNUM);
|
2757 |
SV_MAXCOPYREADLEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXCOPYREADLEN_PARMNUM);
|
2758 |
SV_MAXCOPYWRITELEN_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXCOPYWRITELEN_PARMNUM);
|
2759 |
SV_MINKEEPSEARCH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINKEEPSEARCH_PARMNUM);
|
2760 |
SV_MAXKEEPSEARCH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXKEEPSEARCH_PARMNUM);
|
2761 |
SV_MINKEEPCOMPLSEARCH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINKEEPCOMPLSEARCH_PARMNUM);
|
2762 |
SV_MAXKEEPCOMPLSEARCH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXKEEPCOMPLSEARCH_PARMNUM);
|
2763 |
SV_SCAVTIMEOUT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SCAVTIMEOUT_PARMNUM);
|
2764 |
SV_MINRCVQUEUE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINRCVQUEUE_PARMNUM);
|
2765 |
SV_MINFREEWORKITEMS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINFREEWORKITEMS_PARMNUM);
|
2766 |
SV_MAXMPXCT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXMPXCT_PARMNUM);
|
2767 |
SV_OPLOCKBREAKWAIT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_OPLOCKBREAKWAIT_PARMNUM);
|
2768 |
SV_OPLOCKBREAKRESPONSEWAIT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_OPLOCKBREAKRESPONSEWAIT_PARMNUM);
|
2769 |
SV_ENABLEOPLOCKS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEOPLOCKS_PARMNUM);
|
2770 |
SV_ENABLEOPLOCKFORCECLOSE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEOPLOCKFORCECLOSE_PARMNUM);
|
2771 |
SV_ENABLEFCBOPENS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEFCBOPENS_PARMNUM);
|
2772 |
SV_ENABLERAW_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLERAW_PARMNUM);
|
2773 |
SV_ENABLESHAREDNETDRIVES_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLESHAREDNETDRIVES_PARMNUM);
|
2774 |
SV_MINFREECONNECTIONS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINFREECONNECTIONS_PARMNUM);
|
2775 |
SV_MAXFREECONNECTIONS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXFREECONNECTIONS_PARMNUM);
|
2776 |
SV_INITSESSTABLE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_INITSESSTABLE_PARMNUM);
|
2777 |
SV_INITCONNTABLE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_INITCONNTABLE_PARMNUM);
|
2778 |
SV_INITFILETABLE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_INITFILETABLE_PARMNUM);
|
2779 |
SV_INITSEARCHTABLE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_INITSEARCHTABLE_PARMNUM);
|
2780 |
SV_ALERTSCHEDULE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ALERTSCHEDULE_PARMNUM);
|
2781 |
SV_ERRORTHRESHOLD_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ERRORTHRESHOLD_PARMNUM);
|
2782 |
SV_NETWORKERRORTHRESHOLD_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_NETWORKERRORTHRESHOLD_PARMNUM);
|
2783 |
SV_DISKSPACETHRESHOLD_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_DISKSPACETHRESHOLD_PARMNUM);
|
2784 |
SV_MAXLINKDELAY_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXLINKDELAY_PARMNUM);
|
2785 |
SV_MINLINKTHROUGHPUT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINLINKTHROUGHPUT_PARMNUM);
|
2786 |
SV_LINKINFOVALIDTIME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_LINKINFOVALIDTIME_PARMNUM);
|
2787 |
SV_SCAVQOSINFOUPDATETIME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SCAVQOSINFOUPDATETIME_PARMNUM);
|
2788 |
SV_MAXWORKITEMIDLETIME_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXWORKITEMIDLETIME_PARMNUM);
|
2789 |
SV_MAXRAWWORKITEMS_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXRAWWORKITEMS_PARMNUM);
|
2790 |
SV_PRODUCTTYPE_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_PRODUCTTYPE_PARMNUM);
|
2791 |
SV_SERVERSIZE_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SERVERSIZE_PARMNUM);
|
2792 |
SV_CONNECTIONLESSAUTODISC_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_CONNECTIONLESSAUTODISC_PARMNUM);
|
2793 |
SV_SHARINGVIOLATIONRETRIES_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SHARINGVIOLATIONRETRIES_PARMNUM);
|
2794 |
SV_SHARINGVIOLATIONDELAY_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SHARINGVIOLATIONDELAY_PARMNUM);
|
2795 |
SV_MAXGLOBALOPENSEARCH_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXGLOBALOPENSEARCH_PARMNUM);
|
2796 |
SV_REMOVEDUPLICATESEARCHES_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_REMOVEDUPLICATESEARCHES_PARMNUM);
|
2797 |
SV_LOCKVIOLATIONRETRIES_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_LOCKVIOLATIONRETRIES_PARMNUM);
|
2798 |
SV_LOCKVIOLATIONOFFSET_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_LOCKVIOLATIONOFFSET_PARMNUM);
|
2799 |
SV_LOCKVIOLATIONDELAY_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_LOCKVIOLATIONDELAY_PARMNUM);
|
2800 |
SV_MDLREADSWITCHOVER_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MDLREADSWITCHOVER_PARMNUM);
|
2801 |
SV_CACHEDOPENLIMIT_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_CACHEDOPENLIMIT_PARMNUM);
|
2802 |
SV_CRITICALTHREADS_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_CRITICALTHREADS_PARMNUM);
|
2803 |
SV_RESTRICTNULLSESSACCESS_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_RESTRICTNULLSESSACCESS_PARMNUM);
|
2804 |
SV_ENABLEWFW311DIRECTIPX_INFOLOEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEWFW311DIRECTIPX_PARMNUM);
|
2805 |
SV_OTHERQUEUEAFFINITY_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_OTHERQUEUEAFFINITY_PARMNUM);
|
2806 |
SV_QUEUESAMPLESECS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_QUEUESAMPLESECS_PARMNUM);
|
2807 |
SV_BALANCECOUNT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_BALANCECOUNT_PARMNUM);
|
2808 |
SV_PREFERREDAFFINITY_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_PREFERREDAFFINITY_PARMNUM);
|
2809 |
SV_MAXFREERFCBS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXFREERFCBS_PARMNUM);
|
2810 |
SV_MAXFREEMFCBS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXFREEMFCBS_PARMNUM);
|
2811 |
SV_MAXFREELFCBS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXFREELFCBS_PARMNUM);
|
2812 |
SV_MAXFREEPAGEDPOOLCHUNKS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXFREEPAGEDPOOLCHUNKS_PARMNUM);
|
2813 |
SV_MINPAGEDPOOLCHUNKSIZE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MINPAGEDPOOLCHUNKSIZE_PARMNUM);
|
2814 |
SV_MAXPAGEDPOOLCHUNKSIZE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXPAGEDPOOLCHUNKSIZE_PARMNUM);
|
2815 |
SV_SENDSFROMPREFERREDPROCESSOR_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_SENDSFROMPREFERREDPROCESSOR_PARMNUM);
|
2816 |
SV_MAXTHREADSPERQUEUE_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXTHREADSPERQUEUE_PARMNUM);
|
2817 |
SV_CACHEDDIRECTORYLIMIT_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_CACHEDDIRECTORYLIMIT_PARMNUM);
|
2818 |
SV_MAXCOPYLENGTH_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_MAXCOPYLENGTH_PARMNUM);
|
2819 |
SV_ENABLEBULKTRANSFER_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLEBULKTRANSFER_PARMNUM);
|
2820 |
SV_ENABLECOMPRESSION_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_ENABLECOMPRESSION_PARMNUM);
|
2821 |
SV_AUTOSHAREWKS_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_AUTOSHAREWKS_PARMNUM);
|
2822 |
SV_AUTOSHARESERVER_INFOLEVEL = (PARMNUM_BASE_INFOLEVEL + SV_AUTOSHARESERVER_PARMNUM);
|
2823 |
|
2824 |
SVI1_NUM_ELEMENTS = 5;
|
2825 |
SVI2_NUM_ELEMENTS = 40;
|
2826 |
SVI3_NUM_ELEMENTS = 44;
|
2827 |
|
2828 |
{ Maxmimum length for command string to NetServerAdminCommand. }
|
2829 |
SV_MAX_CMD_LEN = PATHLEN;
|
2830 |
|
2831 |
{ Masks describing AUTOPROFILE parameters }
|
2832 |
SW_AUTOPROF_LOAD_MASK = $1;
|
2833 |
SW_AUTOPROF_SAVE_MASK = $2;
|
2834 |
|
2835 |
{ Max size of svX_srvheuristics. }
|
2836 |
SV_MAX_SRV_HEUR_LEN = 32; { Max heuristics info string length. }
|
2837 |
|
2838 |
{ Equate for use with sv102_licenses. }
|
2839 |
SV_USERS_PER_LICENSE = 5;
|
2840 |
|
2841 |
{-------------------- LMUSE.H -----------------------------------------------}
|
2842 |
type
|
2843 |
TNetUseAdd = function(UncServerName: LPWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
2844 |
TNetUseDel = function(UncServerName, UseName: LPWSTR; ForceCond: DWord): NET_API_STATUS; stdcall;
|
2845 |
TNetUseEnum = function(UncServerName: LPWSTR; Level : DWord; var Buffer: Pointer; PrefMaxSize : DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
2846 |
TNetUseGetInfo = function(UncServerName, UseName: LPWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
2847 |
|
2848 |
{-------------------- LMWKSTA.H ---------------------------------------------}
|
2849 |
type
|
2850 |
TNetWkstaGetInfo = function(ServerName: LPWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
2851 |
TNetWkstaSetInfo = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
2852 |
TNetWkstaUserGetInfo = function(Reserved: LPWSTR; Level: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
2853 |
TNetWkstaUserSetInfo = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
2854 |
TNetWkstaUserEnum = function(ServerName: LPWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
2855 |
TNetWkstaTransportAdd = function(ServerName: LPWSTR; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS; stdcall;
|
2856 |
TNetWkstaTransportDel = function(ServerName, TransportName: LPWSTR; Ucond: DWord): NET_API_STATUS; stdcall;
|
2857 |
TNetWkstaTransportEnum = function(ServerName: LPWSTR; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS; stdcall;
|
2858 |
|
2859 |
{-------------------- LMAPIBUF.H --------------------------------------------}
|
2860 |
type
|
2861 |
TNetApiBufferAllocate = function(ByteCount: Cardinal; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
2862 |
TNetApiBufferFree = function(Buffer: Pointer): NET_API_STATUS; stdcall;
|
2863 |
TNetApiBufferReallocate = function(OldBuffer: Pointer; NewByteCount : Cardinal; var NewBuffer: Pointer): NET_API_STATUS; stdcall;
|
2864 |
TNetApiBufferSize = function(Buffer: Pointer; var ByteCount: DWord): NET_API_STATUS; stdcall;
|
2865 |
|
2866 |
{-------------------- LMSTATS.H ---------------------------------------------}
|
2867 |
type
|
2868 |
TNetStatisticsGet = function(Server, Service: LPWSTR; Level, Options: DWord; var Buffer: Pointer): NET_API_STATUS; stdcall;
|
2869 |
|
2870 |
{-------------------- WINBASE.H ---------------------------------------------}
|
2871 |
type
|
2872 |
TGetSidIdentifierAuthority = function(SID: PSID): PSIDIdentifierAuthority; stdcall;
|
2873 |
TGetSidSubAuthority = function(SID: PSID; nSubAuthority: DWord): PDWord; stdcall;
|
2874 |
TGetSidSubAuthorityCount = function(SID: PSID): PByte; stdcall;
|
2875 |
TLookupAccountName = function(SystemName, AccountName: PChar; Sid: Pointer; var cbSid: DWord; DomainName: PChar; var cbDomainName: DWord; var peUse: DWord): Boolean; stdcall;
|
2876 |
TLookupAccountSid = function(SystemName: PChar; Sid: PSID; AccountName: PChar; var AccountLen: DWord; DomainName: PChar; var DomainLen; var peUse: DWord): Boolean; stdcall;
|
2877 |
|
2878 |
{ ============================================================================}
|
2879 |
{LMACCESS}
|
2880 |
function StNetUserAdd(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2881 |
function StNetUserEnum(ServerName: string; Level, Filter: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2882 |
function StNetUserGetInfo(ServerName, UserName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2883 |
function StNetUserSetInfo(ServerName, UserName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2884 |
function StNetUserDel(ServerName, UserName: string): NET_API_STATUS;
|
2885 |
function StNetUserGetGroups(ServerName, UserName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord): NET_API_STATUS;
|
2886 |
function StNetUserSetGroups(ServerName, UserName: string; Level: DWord; Buffer: Pointer; NumEntries: DWord): NET_API_STATUS;
|
2887 |
function StNetUserGetLocalGroups(ServerName, UserName: string; Level: DWord; Flags: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries : DWord): NET_API_STATUS;
|
2888 |
function StNetUserModalsGet(ServerName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2889 |
function StNetUserModalsSet(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2890 |
function StNetUserChangePassword(DomainName, UserName, OldPassword, NewPassword: string): NET_API_STATUS;
|
2891 |
|
2892 |
function StNetGroupAdd(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2893 |
function StNetGroupAddUser(ServerName, GroupName, UserName: string): NET_API_STATUS;
|
2894 |
function StNetGroupEnum(ServerName: string; Level: DWord; Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2895 |
function StNetGroupGetInfo(ServerName, GroupName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2896 |
function StNetGroupSetInfo(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2897 |
function StNetGroupDel(ServerName, GroupName: string): NET_API_STATUS;
|
2898 |
function StNetGroupDelUser(ServerName, GroupName, UserName: string): NET_API_STATUS;
|
2899 |
function StNetGroupGetUsers(ServerName, GroupName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: Pointer): NET_API_STATUS;
|
2900 |
function StNetGroupSetUsers(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; var TotalEntries : DWord): NET_API_STATUS;
|
2901 |
|
2902 |
function StNetLocalGroupAdd(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2903 |
function StNetLocalGroupAddMember(ServerName, GroupName: string; MembersID: PSID): NET_API_STATUS;
|
2904 |
function StNetLocalGroupEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; var ResumeHandle: DWord): NET_API_STATUS;
|
2905 |
function StNetLocalGroupGetInfo(ServerName, GroupName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2906 |
function StNetLocalGroupSetInfo(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2907 |
function StNetLocalGroupDel(ServerName, GroupName: string): NET_API_STATUS;
|
2908 |
function StNetLocalGroupDelMember(ServerName, GroupName: string; MembersID: PSID): NET_API_STATUS;
|
2909 |
function StNetLocalGroupGetMembers(ServerName, GroupName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: Pointer): NET_API_STATUS;
|
2910 |
function StNetLocalGroupSetMembers(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; var TotalEntries: DWord): NET_API_STATUS;
|
2911 |
function StNetLocalGroupAddMembers(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; TotalEntries: DWord): NET_API_STATUS;
|
2912 |
function StNetLocalGroupDelMembers(ServerName, GroupName: string; Level: DWord; Buffer: Pointer; TotalEntries: DWord): NET_API_STATUS;
|
2913 |
|
2914 |
function StNetQueryDisplayInformation(ServerName: string; Level, Index, EntriesRequested, PrefMaxLen: DWord; var ReturnedCount: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2915 |
function StNetGetDisplayInformationIndex(ServerName: string; Level: DWord; Prefix: string; var Index: DWord): NET_API_STATUS;
|
2916 |
|
2917 |
function StNetAccessAdd(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2918 |
function StNetAccessEnum(ServerName, BasePath: string; Recursive, Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2919 |
function StNetAccessGetInfo(ServerName, Resource: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2920 |
function StNetAccessSetInfo(ServerName, Resource: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2921 |
function StNetAccessDel(ServerName, Resource: string): NET_API_STATUS;
|
2922 |
function StNetAccessGetUserPerms(ServerName, UGname, Resource: string; var Perms: DWord): NET_API_STATUS;
|
2923 |
|
2924 |
function StNetGetDCName(ServerName, DomainName: string; var Buffer: string): NET_API_STATUS;
|
2925 |
function StNetGetAnyDCName(ServerName, DomainName: string; var Buffer: string): NET_API_STATUS;
|
2926 |
function StI_NetLogonControl(ServerName: string; FunctionCode, QueryLevel: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2927 |
function StI_NetLogonControl2(ServerName: string; FunctionCode, QueryLevel: DWord; Data: Pointer; var Buffer: Pointer): NET_API_STATUS;
|
2928 |
function StNetEnumerateTrustedDomains(ServerName: string; var Buffer: Pointer): NET_API_STATUS;
|
2929 |
|
2930 |
{LMALERT}
|
2931 |
function StNetAlertRaise(AlertEventName: string; Buffer: Pointer; BufferSize: DWord): NET_API_STATUS;
|
2932 |
function StNetAlertRaiseEx(AlertEventName: string; VariableInfo: Pointer; VariableInfoSize: DWord; ServiceName: string): NET_API_STATUS;
|
2933 |
|
2934 |
function StNetShareAdd(ServerName: string; Level: DWORD; Buffer: Pointer; var ParmErr: DWORD): NET_API_STATUS;
|
2935 |
function StNetShareEnum(ServerName: string; Level: DWORD; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; var ResumeHandle: DWord): NET_API_STATUS;
|
2936 |
function StNetShareEnumSticky(ServerName: string; Level: DWORD; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2937 |
function StNetShareGetInfo(ServerName, NetName: string; Level: DWORD; var Buffer: Pointer): NET_API_STATUS;
|
2938 |
function StNetShareSetInfo(ServerName, NetName: string; Level: DWORD; var Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2939 |
function StNetShareDel(ServerName, NetName: string; Reserved: DWord): NET_API_STATUS;
|
2940 |
function StNetShareDelSticky(ServerName, NetName: string; Reserved: DWord): NET_API_STATUS;
|
2941 |
function StNetShareCheck(ServerName, Device: string; var ShareType: DWord): NET_API_STATUS;
|
2942 |
|
2943 |
function StNetSessionEnum(ServerName, UncClientName, UserName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2944 |
function StNetSessionDel(ServerName, UncClientName, UserName: string): NET_API_STATUS;
|
2945 |
function StNetSessionGetInfo(ServerName, UncClientName, UserName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2946 |
|
2947 |
function StNetConnectionEnum(ServerName, Qualifier: string; Level: DWord; var Buffer : Pointer; PrefMaxLen : DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2948 |
|
2949 |
function StNetFileClose(ServerName: string; FileID: DWord): NET_API_STATUS;
|
2950 |
function StNetFileEnum(ServerName, BasePath, UserName: string; Level: DWord; var Buffer: Pointer; PrefMexLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2951 |
function StNetFileGetInfo(ServerName: string; FileID, Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2952 |
|
2953 |
{LMMSG}
|
2954 |
function StNetMessageNameAdd(ServerName, MsgName: string): NET_API_STATUS;
|
2955 |
function StNetMessageNameEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ResumeHandle: PDWord): NET_API_STATUS;
|
2956 |
function StNetMessageNameGetInfo(ServerName, MsgName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2957 |
function StNetMessageNameDel(ServerName, MsgName: string): NET_API_STATUS;
|
2958 |
function StNetMessageBufferSend(ServerName, MsgName, FromName: string; Buffer: Pointer; BufferLen: DWord): NET_API_STATUS;
|
2959 |
|
2960 |
{LMREMUTL}
|
2961 |
function StNetRemoteTOD(UncServerName: string; var Buffer: Pointer): NET_API_STATUS;
|
2962 |
function StNetRemoteComputerSupports(UncServerName: string; OptionsWanted: DWord; var OptionsSupported: DWord): NET_API_STATUS;
|
2963 |
|
2964 |
{LMSERVER}
|
2965 |
function StNetServerEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ServerType: DWord; Domain: string; var ResumeHandle: DWord): NET_API_STATUS;
|
2966 |
function StNetServerEnumEx(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord; ServerType: DWord; Domain, FirstNameToReturn : string): NET_API_STATUS;
|
2967 |
function StNetServerGetInfo(ServerName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2968 |
function StNetServerSetInfo(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2969 |
function StNetServerDiskEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2970 |
function StNetServerComputerNameAdd(ServerName, EmulatedDomainName, EmulatedServerName: string): NET_API_STATUS;
|
2971 |
function StNetServerComputerNameDel(ServerName, EmulatedServerName: string): NET_API_STATUS;
|
2972 |
function StNetServerTransportAdd(ServerName: string; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
2973 |
function StNetServerTransportAddEx(ServerName: WideString; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
2974 |
function StNetServerTransportDel(ServerName: string; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
2975 |
function StNetServerTransportEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2976 |
|
2977 |
{LMUSE}
|
2978 |
function StNetUseAdd(UncServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2979 |
function StNetUseDel(UncServerName, UseName: string; ForceCond: DWord): NET_API_STATUS;
|
2980 |
function StNetUseEnum(UncServerName: string; Level : DWord; var Buffer: Pointer; PrefMaxSize : DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2981 |
function StNetUseGetInfo(UncServerName, UseName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2982 |
|
2983 |
{LMWKSTA}
|
2984 |
function StNetWkstaGetInfo(ServerName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2985 |
function StNetWkstaSetInfo(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2986 |
function StNetWkstaUserGetInfo(Reserved: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
2987 |
function StNetWkstaUserSetInfo(Reserved: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2988 |
function StNetWkstaUserEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2989 |
function StNetWkstaTransportAdd(ServerName: string; Level: DWord; Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
2990 |
function StNetWkstaTransportDel(ServerName, TransportName: string; Ucond: DWord): NET_API_STATUS;
|
2991 |
function StNetWkstaTransportEnum(ServerName: string; Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead, TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
2992 |
|
2993 |
{LMAPIBUF}
|
2994 |
function StNetApiBufferAllocate(ByteCount: Cardinal; var Buffer: Pointer): NET_API_STATUS;
|
2995 |
function StNetApiBufferFree(Buffer: Pointer): NET_API_STATUS;
|
2996 |
function StNetApiBufferReallocate(OldBuffer: Pointer; NewByteCount : Cardinal; var NewBuffer: Pointer): NET_API_STATUS;
|
2997 |
function StNetApiBufferSize(Buffer: Pointer; var ByteCount: DWord): NET_API_STATUS;
|
2998 |
|
2999 |
{LMSTATS}
|
3000 |
function StNetStatisticsGet(ServerName, ServiceName: string; Level, Options: DWord; var Buffer: Pointer): NET_API_STATUS;
|
3001 |
|
3002 |
{WINBASE}
|
3003 |
function StGetSidIdentifierAuthority(Sid: PSID): PSIDIdentifierAuthority;
|
3004 |
function StGetSidSubAuthority(Sid: PSID; SubAuthority: DWord): DWord;
|
3005 |
function StGetSidSubAuthorityCount(SID: PSID): Byte;
|
3006 |
function StLookupAccountName(SystemName, AccountName: string; var Sid: Pointer; var SidLength: DWord; var DomainName: string; var peUse: DWord): Boolean;
|
3007 |
function StLookupAccountSid(SystemName: string; Sid: PSid; var AccountName, DomainName: string; var peUse: DWord): Boolean;
|
3008 |
|
3009 |
|
3010 |
type
|
3011 |
TLMWideChar = record
|
3012 |
Value : PWideChar;
|
3013 |
Length: DWord;
|
3014 |
end;
|
3015 |
|
3016 |
TNetDisplayUserArray = array[0..(MaxInt div SizeOf(TNET_DISPLAY_USER))-1] of TNET_DISPLAY_USER;
|
3017 |
TNetDisplayGroupArray = array[0..(MaxInt div SizeOf(TNET_DISPLAY_GROUP))-1] of TNET_DISPLAY_GROUP;
|
3018 |
|
3019 |
TUserInfo3Array = array[0..(MaxInt div SizeOf(TUSER_INFO_3))-1] of TUSER_INFO_3;
|
3020 |
|
3021 |
TLocalGroupInfo1Array = array[0..(MaxInt div SizeOf(TLOCALGROUP_INFO_1))-1] of TLOCALGROUP_INFO_1;
|
3022 |
TLocalGroupUsersInfo0Array = array[0..(MaxInt div SizeOf(TLOCALGROUP_USERS_INFO_0))-1] of TLOCALGROUP_USERS_INFO_0;
|
3023 |
TLocalGroupMembersInfo1Array = array[0..(MaxInt div SizeOf(TLOCALGROUP_MEMBERS_INFO_1))-1] of TLOCALGROUP_MEMBERS_INFO_1;
|
3024 |
TLocalGroupMembersInfo2Array = array[0..(MaxInt div SizeOf(TLOCALGROUP_MEMBERS_INFO_2))-1] of TLOCALGROUP_MEMBERS_INFO_2;
|
3025 |
|
3026 |
TGroupInfo1Array = array[0..(MaxInt div SizeOf(TGROUP_INFO_1))-1] of TGROUP_INFO_1;
|
3027 |
TGroupUsersInfo0Array = array[0..(MaxInt div SizeOf(TGROUP_USERS_INFO_0))-1] of TGROUP_USERS_INFO_0;
|
3028 |
|
3029 |
TShareInfo1Array = array[0..(MaxInt div SizeOf(TSHARE_INFO_1))-1] of TSHARE_INFO_1;
|
3030 |
|
3031 |
TMsgInfo0Array = array[0..(MaxInt div SizeOf(TMSG_INFO_0))-1] of TMSG_INFO_0;
|
3032 |
|
3033 |
procedure CvtToWideChar(const S: string; var WS: TLMWideChar);
|
3034 |
procedure CvtToWideCharLM(const S: string; var WS: TLMWideChar);
|
3035 |
|
3036 |
implementation
|
3037 |
|
3038 |
uses SysUtils, StUtils;
|
3039 |
|
3040 |
var
|
3041 |
{LMACCESS}
|
3042 |
_NetUserAdd : TNetUserAdd = nil;
|
3043 |
_NetUserEnum : TNetUserEnum = nil;
|
3044 |
_NetUserGetInfo : TNetUserGetInfo = nil;
|
3045 |
_NetUserSetInfo : TNetUserSetInfo = nil;
|
3046 |
_NetUserDel : TNetUserDel = nil;
|
3047 |
_NetUserGetGroups : TNetUserGetGroups = nil;
|
3048 |
_NetUserSetGroups : TNetUserSetGroups = nil;
|
3049 |
_NetUserGetLocalGroups : TNetUserGetLocalGroups = nil;
|
3050 |
_NetUserModalsGet : TNetUserModalsGet = nil;
|
3051 |
_NetUserModalsSet : TNetUserModalsSet = nil;
|
3052 |
_NetUserChangePassword : TNetUserChangePassword = nil;
|
3053 |
|
3054 |
_NetGroupAdd : TNetGroupAdd = nil;
|
3055 |
_NetGroupAddUser : TNetGroupAddUser = nil;
|
3056 |
_NetGroupEnum : TNetGroupEnum = nil;
|
3057 |
_NetGroupGetInfo : TNetGroupGetInfo = nil;
|
3058 |
_NetGroupSetInfo : TNetGroupSetInfo = nil;
|
3059 |
_NetGroupDel : TNetGroupDel = nil;
|
3060 |
_NetGroupDelUser : TNetGroupDelUser = nil;
|
3061 |
_NetGroupGetUsers : TNetGroupGetUsers = nil;
|
3062 |
_NetGroupSetUsers : TNetGroupSetUsers = nil;
|
3063 |
|
3064 |
_NetLocalGroupAdd : TNetLocalGroupAdd = nil;
|
3065 |
_NetLocalGroupAddMember : TNetLocalGroupAddMember = nil;
|
3066 |
_NetLocalGroupEnum : TNetLocalGroupEnum = nil;
|
3067 |
_NetLocalGroupGetInfo : TNetLocalGroupGetInfo = nil;
|
3068 |
_NetLocalGroupSetInfo : TNetLocalGroupSetInfo = nil;
|
3069 |
_NetLocalGroupDel : TNetLocalGroupDel = nil;
|
3070 |
_NetLocalGroupDelMember : TNetLocalGroupDelMember = nil;
|
3071 |
_NetLocalGroupGetMembers : TNetLocalGroupGetMembers = nil;
|
3072 |
_NetLocalGroupSetMembers : TNetLocalGroupSetMembers = nil;
|
3073 |
_NetLocalGroupAddMembers : TNetLocalGroupAddMembers = nil;
|
3074 |
_NetLocalGroupDelMembers : TNetLocalGroupDelMembers = nil;
|
3075 |
|
3076 |
_NetQueryDisplayInformation : TNetQueryDisplayInformation = nil;
|
3077 |
_NetGetDisplayInformationIndex : TNetGetDisplayInformationIndex = nil;
|
3078 |
|
3079 |
_NetAccessAdd : TNetAccessAdd = nil;
|
3080 |
_NetAccessEnum : TNetAccessEnum = nil;
|
3081 |
_NetAccessGetInfo : TNetAccessGetInfo = nil;
|
3082 |
_NetAccessSetInfo : TNetAccessSetInfo = nil;
|
3083 |
_NetAccessDel : TNetAccessDel = nil;
|
3084 |
_NetAccessGetUserPerms : TNetAccessGetUserPerms = nil;
|
3085 |
|
3086 |
_NetGetDCName : TNetGetDCName = nil;
|
3087 |
_NetGetAnyDCName : TNetGetAnyDCName = nil;
|
3088 |
_I_NetLogonControl : TI_NetLogonControl = nil;
|
3089 |
_I_NetLogonControl2 : TI_NetLogonControl2 = nil;
|
3090 |
_NetEnumerateTrustedDomains : TNetEnumerateTrustedDomains = nil;
|
3091 |
|
3092 |
{LMALERT}
|
3093 |
_NetAlertRaise : TNetAlertRaise = nil;
|
3094 |
_NetAlertRaiseEx : TNetAlertRaiseEx = nil;
|
3095 |
|
3096 |
{LMSHARE}
|
3097 |
_NetShareAdd : TNetShareAdd = nil;
|
3098 |
_NetShareEnum : TNetShareEnum = nil;
|
3099 |
_NetShareEnumSticky : TNetShareEnumSticky = nil;
|
3100 |
_NetShareGetInfo : TNetShareGetInfo = nil;
|
3101 |
_NetShareSetInfo : TNetShareSetInfo = nil;
|
3102 |
_NetShareDel : TNetShareDel = nil;
|
3103 |
_NetShareDelSticky : TNetShareDelSticky = nil;
|
3104 |
_NetShareCheck : TNetShareCheck = nil;
|
3105 |
|
3106 |
_NetSessionEnum : TNetSessionEnum = nil;
|
3107 |
_NetSessionDel : TNetSessionDel = nil;
|
3108 |
_NetSessionGetInfo : TNetSessionGetInfo = nil;
|
3109 |
|
3110 |
_NetConnectionEnum : TNetConnectionEnum = nil;
|
3111 |
|
3112 |
_NetFileClose : TNetFileClose = nil;
|
3113 |
_NetFileEnum : TNetFileEnum = nil;
|
3114 |
_NetFileGetInfo : TNetFileGetInfo = nil;
|
3115 |
|
3116 |
{LMMSG}
|
3117 |
_NetMessageNameAdd : TNetMessageNameAdd = nil;
|
3118 |
_NetMessageNameEnum : TNetMessageNameEnum = nil;
|
3119 |
_NetMessageNameGetInfo : TNetMessageNameGetInfo = nil;
|
3120 |
_NetMessageNameDel : TNetMessageNameDel = nil;
|
3121 |
_NetMessageBufferSend : TNetMessageBufferSend = nil;
|
3122 |
|
3123 |
{LMREMUTL}
|
3124 |
_NetRemoteTOD : TNetRemoteTOD = nil;
|
3125 |
_NetRemoteComputerSupports : TNetRemoteComputerSupports = nil;
|
3126 |
|
3127 |
{LMSERVER}
|
3128 |
_NetServerEnum : TNetServerEnum = nil;
|
3129 |
_NetServerEnumEx : TNetServerEnumEx = nil;
|
3130 |
_NetServerGetInfo : TNetServerGetInfo = nil;
|
3131 |
_NetServerSetInfo : TNetServerSetInfo = nil;
|
3132 |
_NetServerDiskEnum : TNetServerDiskEnum = nil;
|
3133 |
_NetServerComputerNameAdd : TNetServerComputerNameAdd = nil;
|
3134 |
_NetServerComputerNameDel : TNetServerComputerNameDel = nil;
|
3135 |
_NetServerTransportAdd : TNetServerTransportAdd = nil;
|
3136 |
_NetServerTransportAddEx : TNetServerTransportAddEx = nil;
|
3137 |
_NetServerTransportDel : TNetServerTransportDel = nil;
|
3138 |
_NetServerTransportEnum : TNetServerTransportEnum = nil;
|
3139 |
|
3140 |
{LMUSE}
|
3141 |
_NetUseAdd : TNetUseAdd = nil;
|
3142 |
_NetUseDel : TNetUseDel = nil;
|
3143 |
_NetUseEnum : TNetUseEnum = nil;
|
3144 |
_NetUseGetInfo : TNetUseGetInfo = nil;
|
3145 |
|
3146 |
{LMWKSTA}
|
3147 |
_NetWkstaGetInfo : TNetWkstaGetInfo = nil;
|
3148 |
_NetWkstaSetInfo : TNetWkstaSetInfo = nil;
|
3149 |
_NetWkstaUserGetInfo : TNetWkstaUserGetInfo = nil;
|
3150 |
_NetWkstaUserSetInfo : TNetWkstaUserSetInfo = nil;
|
3151 |
_NetWkstaUserEnum : TNetWkstaUserEnum = nil;
|
3152 |
_NetWkstaTransportAdd : TNetWkstaTransportAdd = nil;
|
3153 |
_NetWkstaTransportDel : TNetWkstaTransportDel = nil;
|
3154 |
_NetWkstaTransportEnum : TNetWkstaTransportEnum = nil;
|
3155 |
|
3156 |
{LMAPIBUF}
|
3157 |
_NetApiBufferAllocate : TNetApiBufferAllocate = nil;
|
3158 |
_NetApiBufferFree : TNetApiBufferFree = nil;
|
3159 |
_NetApiBufferReallocate : TNetApiBufferReallocate = nil;
|
3160 |
_NetApiBufferSize : TNetApiBufferSize = nil;
|
3161 |
|
3162 |
{LMSTATS}
|
3163 |
_NetStatisticsGet : TNetStatisticsGet = nil;
|
3164 |
|
3165 |
{WINBASE}
|
3166 |
_GetSidIdentifierAuthority : TGetSidIdentifierAuthority = nil;
|
3167 |
_GetSidSubAuthority : TGetSidSubAuthority = nil;
|
3168 |
_GetSidSubAuthorityCount : TGetSidSubAuthorityCount = nil;
|
3169 |
_LookupAccountName : TLookupAccountName = nil;
|
3170 |
_LookupAccountSid : TLookupAccountSid = nil;
|
3171 |
|
3172 |
var
|
3173 |
NETAPI32 : THandle = 0;
|
3174 |
ADVAPI32 : THandle = 0;
|
3175 |
|
3176 |
NETAPI32DLL : PChar = 'netapi32.dll';
|
3177 |
ADVAPI32DLL : PChar = 'advapi32.dll';
|
3178 |
|
3179 |
function IsNetApi32: Boolean;
|
3180 |
begin
|
3181 |
if NETAPI32 = 0 then
|
3182 |
NETAPI32 := LoadLibrary(NETAPI32DLL);
|
3183 |
|
3184 |
Result := (NETAPI32 <> 0);
|
3185 |
end;
|
3186 |
|
3187 |
function IsAdvApi32: Boolean;
|
3188 |
begin
|
3189 |
if ADVAPI32 = 0 then
|
3190 |
ADVAPI32 := LoadLibrary(ADVAPI32DLL);
|
3191 |
|
3192 |
Result := (ADVAPI32 <> 0);
|
3193 |
end;
|
3194 |
|
3195 |
function ServerUncName(Name: string): string;
|
3196 |
begin
|
3197 |
{ NT 4 and 9x need it in a UNC form, but Windows 2000 does not (it can have dns names) }
|
3198 |
if (Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion < 5) then
|
3199 |
Result := '\\' + Name
|
3200 |
else
|
3201 |
Result := Name;
|
3202 |
end;
|
3203 |
|
3204 |
procedure CvtToWideChar(const S: string; var WS: TLMWideChar);
|
3205 |
var
|
3206 |
S1 : string;
|
3207 |
begin
|
3208 |
{ Quick check to make sure that WS is not alreay allocated }
|
3209 |
if WS.Value <> nil then
|
3210 |
FreeMem(WS.Value, WS.Length);
|
3211 |
|
3212 |
S1 := Trim(S);
|
3213 |
|
3214 |
{ Now get the new pointer and size }
|
3215 |
if Length(S1) > 0 then begin
|
3216 |
WS.Length := (Length(S1) + 1) * 2;
|
3217 |
GetMem(WS.Value, WS.Length);
|
3218 |
StringToWideChar(S1, WS.Value, WS.Length);
|
3219 |
end else begin
|
3220 |
WS.Length := 0;
|
3221 |
WS.Value := nil;
|
3222 |
end;
|
3223 |
end;
|
3224 |
|
3225 |
procedure CvtToWideCharLM(const S: string; var WS: TLMWideChar);
|
3226 |
var
|
3227 |
S1 : string;
|
3228 |
begin
|
3229 |
{ Quick check to make sure that WS is not alreay allocated }
|
3230 |
if WS.Value <> nil then
|
3231 |
StNetApiBufferFree(WS.Value);
|
3232 |
|
3233 |
S1 := Trim(S);
|
3234 |
|
3235 |
{ Now get the new pointer and size }
|
3236 |
WS.Length := (Length(S1) + 1) * 2;
|
3237 |
StNetApiBufferAllocate(WS.Length, Pointer(WS.Value));
|
3238 |
StringToWideChar(S1, WS.Value, WS.Length);
|
3239 |
end;
|
3240 |
|
3241 |
|
3242 |
{LMACCESS}
|
3243 |
function StNetUserAdd(ServerName: string; Level: DWord; Buffer: Pointer;
|
3244 |
var ParmErr: DWord): NET_API_STATUS;
|
3245 |
var
|
3246 |
S : TLMWideChar;
|
3247 |
begin
|
3248 |
Result := 0;
|
3249 |
if IsNetApi32 then begin
|
3250 |
if (@_NetUserAdd = nil) then
|
3251 |
@_NetUserAdd := GetProcAddress(NETAPI32, 'NetUserAdd');
|
3252 |
|
3253 |
if (@_NetUserAdd <> nil) then begin
|
3254 |
{ determine if UNC identifiers needed }
|
3255 |
ServerName := ServerUncName(ServerName);
|
3256 |
|
3257 |
S.Value := nil;
|
3258 |
try
|
3259 |
{ allocate the unicode server name }
|
3260 |
CvtToWideChar(ServerName, S);
|
3261 |
|
3262 |
{ call the API }
|
3263 |
Result := _NetUserAdd(S.Value, Level, Buffer, ParmErr);
|
3264 |
finally
|
3265 |
FreeMem(S.Value, S.Length);
|
3266 |
end;
|
3267 |
end else
|
3268 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3269 |
end else begin
|
3270 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3271 |
end;
|
3272 |
end;
|
3273 |
|
3274 |
function StNetUserEnum(ServerName: string; Level, Filter: DWord;
|
3275 |
var Buffer: Pointer; PrefMaxLen: DWord; var EntriesRead,
|
3276 |
TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
3277 |
var
|
3278 |
S : TLMWideChar;
|
3279 |
begin
|
3280 |
Result := 0;
|
3281 |
if IsNetApi32 then begin
|
3282 |
if (@_NetUserEnum = nil) then
|
3283 |
@_NetUserEnum := GetProcAddress(NETAPI32, 'NetUserEnum');
|
3284 |
|
3285 |
if (@_NetUserEnum <> nil) then begin
|
3286 |
{ determine if UNC identifiers needed }
|
3287 |
ServerName := ServerUncName(ServerName);
|
3288 |
|
3289 |
S.Value := nil;
|
3290 |
try
|
3291 |
{ allocate the unicode server name }
|
3292 |
CvtToWideChar(ServerName, S);
|
3293 |
|
3294 |
{ call the API }
|
3295 |
Result := _NetUserEnum(S.Value, Level, Filter, Buffer, PrefMaxLen,
|
3296 |
EntriesRead, TotalEntries, ResumeHandle);
|
3297 |
finally
|
3298 |
FreeMem(S.Value, S.Length);
|
3299 |
end;
|
3300 |
end else
|
3301 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3302 |
end else begin
|
3303 |
{ EStNetException }
|
3304 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3305 |
end;
|
3306 |
end;
|
3307 |
|
3308 |
function StNetUserGetInfo(ServerName, UserName: string; Level: DWord;
|
3309 |
var Buffer: Pointer): NET_API_STATUS;
|
3310 |
var
|
3311 |
S, U : TLMWideChar;
|
3312 |
begin
|
3313 |
Result := 0;
|
3314 |
if IsNetApi32 then begin
|
3315 |
if (@_NetUserGetInfo = nil) then
|
3316 |
@_NetUserGetInfo := GetProcAddress(NETAPI32, 'NetUserGetInfo');
|
3317 |
|
3318 |
if (@_NetUserGetInfo <> nil) then begin
|
3319 |
{ determine if UNC identifiers needed }
|
3320 |
ServerName := ServerUncName(ServerName);
|
3321 |
|
3322 |
S.Value := nil;
|
3323 |
U.Value := nil;
|
3324 |
try
|
3325 |
{ allocate the unicode server name }
|
3326 |
CvtToWideChar(ServerName, S);
|
3327 |
|
3328 |
{ allocate the unicode user name }
|
3329 |
CvtToWideChar(UserName, U);
|
3330 |
|
3331 |
{ call the API }
|
3332 |
Result := _NetUserGetInfo(S.Value, U.Value, Level, Buffer);
|
3333 |
finally
|
3334 |
FreeMem(U.Value, U.Length);
|
3335 |
FreeMem(S.Value, S.Length);
|
3336 |
end;
|
3337 |
end else
|
3338 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3339 |
end else begin
|
3340 |
{ EStNetException }
|
3341 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3342 |
end;
|
3343 |
end;
|
3344 |
|
3345 |
function StNetUserSetInfo(ServerName, UserName: string; Level: DWord;
|
3346 |
Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
3347 |
var
|
3348 |
S, U : TLMWideChar;
|
3349 |
begin
|
3350 |
Result := 0;
|
3351 |
if IsNetApi32 then begin
|
3352 |
if (@_NetUserSetInfo = nil) then
|
3353 |
@_NetUserSetInfo := GetProcAddress(NETAPI32, 'NetUserSetInfo');
|
3354 |
|
3355 |
if (@_NetUserSetInfo <> nil) then begin
|
3356 |
{ determine if UNC identifiers needed }
|
3357 |
ServerName := ServerUncName(ServerName);
|
3358 |
|
3359 |
S.Value := nil;
|
3360 |
U.Value := nil;
|
3361 |
try
|
3362 |
{ allocate the unicode server name }
|
3363 |
CvtToWideChar(ServerName, S);
|
3364 |
|
3365 |
{ allocate the unicode user name }
|
3366 |
CvtToWideChar(UserName, U);
|
3367 |
|
3368 |
{ call the API }
|
3369 |
Result := _NetUserSetInfo(S.Value, U.Value, Level, Buffer, ParmErr);
|
3370 |
finally
|
3371 |
FreeMem(S.Value, S.Length);
|
3372 |
FreeMem(U.Value, U.Length);
|
3373 |
end;
|
3374 |
end else
|
3375 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3376 |
end else begin
|
3377 |
{ EStNetException }
|
3378 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3379 |
end;
|
3380 |
end;
|
3381 |
|
3382 |
function StNetUserDel(ServerName, UserName: string): NET_API_STATUS;
|
3383 |
var
|
3384 |
S, U : TLMWideChar;
|
3385 |
begin
|
3386 |
Result := 0;
|
3387 |
if IsNetApi32 then begin
|
3388 |
if (@_NetUserDel = nil) then
|
3389 |
@_NetUserDel := GetProcAddress(NETAPI32, 'NetUserDel');
|
3390 |
|
3391 |
if (@_NetUserDel <> nil) then begin
|
3392 |
{ determine if UNC identifiers needed }
|
3393 |
ServerName := ServerUncName(ServerName);
|
3394 |
|
3395 |
S.Value := nil;
|
3396 |
U.Value := nil;
|
3397 |
try
|
3398 |
{ allocate the unicode server name }
|
3399 |
CvtToWideChar(ServerName, S);
|
3400 |
|
3401 |
{ allocate the unicode user name }
|
3402 |
CvtToWideChar(UserName, U);
|
3403 |
|
3404 |
{ call the API }
|
3405 |
Result := _NetUserDel(S.Value, U.Value);
|
3406 |
finally
|
3407 |
FreeMem(S.Value, S.Length);
|
3408 |
FreeMem(U.Value, U.Length);
|
3409 |
end;
|
3410 |
end else
|
3411 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3412 |
end else begin
|
3413 |
{ EStNetException }
|
3414 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3415 |
end;
|
3416 |
end;
|
3417 |
|
3418 |
function StNetUserGetGroups(ServerName, UserName: string; Level: DWord;
|
3419 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
3420 |
var EntriesRead, TotalEntries: DWord): NET_API_STATUS;
|
3421 |
var
|
3422 |
S, U : TLMWideChar;
|
3423 |
begin
|
3424 |
Result := 0;
|
3425 |
if IsNetApi32 then begin
|
3426 |
if (@_NetUserGetGroups = nil) then
|
3427 |
@_NetUserGetGroups := GetProcAddress(NETAPI32, 'NetUserGetGroups');
|
3428 |
|
3429 |
if (@_NetUserGetGroups <> nil) then begin
|
3430 |
{ determine if UNC identifiers needed }
|
3431 |
ServerName := ServerUncName(ServerName);
|
3432 |
|
3433 |
S.Value := nil;
|
3434 |
U.Value := nil;
|
3435 |
try
|
3436 |
{ allocate the unicode server name }
|
3437 |
CvtToWideChar(ServerName, S);
|
3438 |
|
3439 |
{ allocate the unicode user name }
|
3440 |
CvtToWideChar(UserName, U);
|
3441 |
|
3442 |
{ call the API }
|
3443 |
Result := _NetUserGetGroups(S.Value, U.Value, Level, Buffer,
|
3444 |
PrefMaxLen, EntriesRead, TotalEntries);
|
3445 |
finally
|
3446 |
FreeMem(S.Value, S.Length);
|
3447 |
FreeMem(U.value, U.Length);
|
3448 |
end;
|
3449 |
end else
|
3450 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3451 |
end else begin
|
3452 |
{ EStNetException }
|
3453 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3454 |
end;
|
3455 |
end;
|
3456 |
|
3457 |
function StNetUserSetGroups(ServerName, UserName: string; Level: DWord;
|
3458 |
Buffer: Pointer; NumEntries: DWord): NET_API_STATUS;
|
3459 |
var
|
3460 |
S, U : TLMWideChar;
|
3461 |
begin
|
3462 |
Result := 0;
|
3463 |
if IsNetApi32 then begin
|
3464 |
if (@_NetUserSetGroups = nil) then
|
3465 |
@_NetUserSetGroups := GetProcAddress(NETAPI32, 'NetUserSetGroups');
|
3466 |
|
3467 |
if (@_NetUserSetGroups <> nil) then begin
|
3468 |
{ determine if UNC identifiers needed }
|
3469 |
ServerName := ServerUncName(ServerName);
|
3470 |
|
3471 |
S.Value := nil;
|
3472 |
U.Value := nil;
|
3473 |
try
|
3474 |
{ allocate the unicode server name }
|
3475 |
CvtToWideChar(ServerName, S);
|
3476 |
|
3477 |
{ allocate the unicode user name }
|
3478 |
CvtToWideChar(UserName, U);
|
3479 |
|
3480 |
{ call the API }
|
3481 |
Result := _NetUserSetGroups(S.Value, U.Value, Level, Buffer, NumEntries);
|
3482 |
finally
|
3483 |
FreeMem(S.Value, S.Length);
|
3484 |
FreeMem(U.value, U.Length);
|
3485 |
end;
|
3486 |
end else
|
3487 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3488 |
end else begin
|
3489 |
{ EStNetException }
|
3490 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3491 |
end;
|
3492 |
end;
|
3493 |
|
3494 |
function StNetUserGetLocalGroups(ServerName, UserName: string; Level: DWord;
|
3495 |
Flags: DWord; var Buffer: Pointer;
|
3496 |
PrefMaxLen: DWord; var EntriesRead,
|
3497 |
TotalEntries : DWord): NET_API_STATUS;
|
3498 |
var
|
3499 |
S, U : TLMWideChar;
|
3500 |
begin
|
3501 |
Result := 0;
|
3502 |
if IsNetApi32 then begin
|
3503 |
if (@_NetUserGetLocalGroups = nil) then
|
3504 |
@_NetUserGetLocalGroups := GetProcAddress(NETAPI32, 'NetUserGetLocalGroups');
|
3505 |
|
3506 |
if (@_NetUserGetLocalGroups <> nil) then begin
|
3507 |
{ determine if UNC identifiers needed }
|
3508 |
ServerName := ServerUncName(ServerName);
|
3509 |
|
3510 |
S.Value := nil;
|
3511 |
U.Value := nil;
|
3512 |
try
|
3513 |
{ allocate the unicode server name }
|
3514 |
CvtToWideChar(ServerName, S);
|
3515 |
|
3516 |
{ allocate the unicode user name }
|
3517 |
CvtToWideChar(UserName, U);
|
3518 |
|
3519 |
{ call the API }
|
3520 |
Result := _NetUserGetLocalGroups(S.Value, U.Value, Level, Flags,
|
3521 |
Buffer, PrefMaxLen, EntriesRead,
|
3522 |
TotalEntries);
|
3523 |
finally
|
3524 |
FreeMem(S.Value, S.Length);
|
3525 |
FreeMem(U.value, U.Length);
|
3526 |
end;
|
3527 |
end else
|
3528 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3529 |
end else begin
|
3530 |
{ EStNetException }
|
3531 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3532 |
end;
|
3533 |
end;
|
3534 |
|
3535 |
function StNetUserModalsGet(ServerName: string; Level: DWord;
|
3536 |
var Buffer: Pointer): NET_API_STATUS;
|
3537 |
var
|
3538 |
S : TLMWideChar;
|
3539 |
begin
|
3540 |
Result := 0;
|
3541 |
if IsNetApi32 then begin
|
3542 |
if (@_NetUserModalsGet = nil) then
|
3543 |
@_NetUserModalsGet := GetProcAddress(NETAPI32, 'NetUserModalsGet');
|
3544 |
|
3545 |
if (@_NetUserModalsGet <> nil) then begin
|
3546 |
{ determine if UNC identifiers needed }
|
3547 |
ServerName := ServerUncName(ServerName);
|
3548 |
|
3549 |
S.Value := nil;
|
3550 |
try
|
3551 |
{ allocate the unicode server name }
|
3552 |
CvtToWideChar(ServerName, S);
|
3553 |
|
3554 |
{ call the API }
|
3555 |
Result := _NetUserModalsGet(S.Value, Level, Buffer);
|
3556 |
finally
|
3557 |
FreeMem(S.Value, S.Length);
|
3558 |
end;
|
3559 |
end else
|
3560 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3561 |
end else begin
|
3562 |
{ EStNetException }
|
3563 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3564 |
end;
|
3565 |
end;
|
3566 |
|
3567 |
function StNetUserModalsSet(ServerName: string; Level: DWord;
|
3568 |
Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
3569 |
var
|
3570 |
S : TLMWideChar;
|
3571 |
begin
|
3572 |
Result := 0;
|
3573 |
if IsNetApi32 then begin
|
3574 |
if (@_NetUserModalsSet = nil) then
|
3575 |
@_NetUserModalsSet := GetProcAddress(NETAPI32, 'NetUserModalsSet');
|
3576 |
|
3577 |
if (@_NetUserModalsSet <> nil) then begin
|
3578 |
{ determine if UNC identifiers needed }
|
3579 |
ServerName := ServerUncName(ServerName);
|
3580 |
|
3581 |
S.Value := nil;
|
3582 |
try
|
3583 |
{ allocate the unicode server name }
|
3584 |
CvtToWideChar(ServerName, S);
|
3585 |
|
3586 |
{ call the API }
|
3587 |
Result := _NetUserModalsSet(S.Value, Level, Buffer, ParmErr);
|
3588 |
finally
|
3589 |
FreeMem(S.Value, S.Length);
|
3590 |
end;
|
3591 |
end else
|
3592 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3593 |
end else begin
|
3594 |
{ EStNetException }
|
3595 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3596 |
end;
|
3597 |
end;
|
3598 |
|
3599 |
function StNetUserChangePassword(DomainName, UserName, OldPassword,
|
3600 |
NewPassword: string): NET_API_STATUS;
|
3601 |
var
|
3602 |
D, U, O, N : TLMWideChar;
|
3603 |
begin
|
3604 |
Result := 0;
|
3605 |
if IsNetApi32 then begin
|
3606 |
if (@_NetUserChangePassword = nil) then
|
3607 |
@_NetUserChangePassword := GetProcAddress(NETAPI32, 'NetUserChangePassword');
|
3608 |
|
3609 |
if (@_NetUserChangePassword <> nil) then begin
|
3610 |
{ determine if UNC identifiers needed }
|
3611 |
DomainName := ServerUncName(DomainName);
|
3612 |
|
3613 |
D.Value := nil;
|
3614 |
U.Value := nil;
|
3615 |
O.Value := nil;
|
3616 |
N.Value := nil;
|
3617 |
try
|
3618 |
{ allocate the unicode domain name }
|
3619 |
CvtToWideChar(DomainName, D);
|
3620 |
|
3621 |
{ allocate the unicode user name }
|
3622 |
CvtToWideChar(UserName, U);
|
3623 |
|
3624 |
{ allocate the unicode old password }
|
3625 |
CvtToWideChar(OldPassword, O);
|
3626 |
|
3627 |
{ allocate the unicode new password }
|
3628 |
CvtToWideChar(NewPassword, N);
|
3629 |
|
3630 |
{ call the API }
|
3631 |
Result := _NetUserChangePassword(D.Value, U.Value, O.Value, N.Value);
|
3632 |
finally
|
3633 |
FreeMem(D.Value, D.Length);
|
3634 |
FreeMem(U.Value, U.Length);
|
3635 |
FreeMem(O.Value, O.Length);
|
3636 |
FreeMem(N.Value, N.Length);
|
3637 |
end;
|
3638 |
end else
|
3639 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3640 |
end else begin
|
3641 |
{ EStNetException }
|
3642 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3643 |
end;
|
3644 |
end;
|
3645 |
|
3646 |
|
3647 |
function StNetGroupAdd(ServerName: string; Level: DWord; Buffer: Pointer;
|
3648 |
var ParmErr: DWord): NET_API_STATUS;
|
3649 |
var
|
3650 |
S : TLMWideChar;
|
3651 |
begin
|
3652 |
Result := 0;
|
3653 |
if IsNetApi32 then begin
|
3654 |
if (@_NetGroupAdd = nil) then
|
3655 |
@_NetGroupAdd := GetProcAddress(NETAPI32, 'NetGroupAdd');
|
3656 |
|
3657 |
if (@_NetGroupAdd <> nil) then begin
|
3658 |
{ determine if UNC identifiers needed }
|
3659 |
ServerName := ServerUncName(ServerName);
|
3660 |
|
3661 |
S.Value := nil;
|
3662 |
try
|
3663 |
{ allocate the unicode server name }
|
3664 |
CvtToWideChar(ServerName, S);
|
3665 |
|
3666 |
{ call the API }
|
3667 |
Result := _NetGroupAdd(S.Value, Level, Buffer, ParmErr);
|
3668 |
finally
|
3669 |
FreeMem(S.Value, S.Length);
|
3670 |
end;
|
3671 |
end else
|
3672 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3673 |
end else begin
|
3674 |
{ EStNetException }
|
3675 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3676 |
end;
|
3677 |
end;
|
3678 |
|
3679 |
function StNetGroupAddUser(ServerName, GroupName, UserName: string): NET_API_STATUS;
|
3680 |
var
|
3681 |
S, G, U : TLMWideChar;
|
3682 |
begin
|
3683 |
Result := 0;
|
3684 |
if IsNetApi32 then begin
|
3685 |
if (@_NetGroupAddUser = nil) then
|
3686 |
@_NetGroupAddUser := GetProcAddress(NETAPI32, 'NetGroupAddUser');
|
3687 |
|
3688 |
if (@_NetGroupAddUser <> nil) then begin
|
3689 |
{ determine if UNC identifiers needed }
|
3690 |
ServerName := ServerUncName(ServerName);
|
3691 |
|
3692 |
S.Value := nil;
|
3693 |
G.Value := nil;
|
3694 |
U.Value := nil;
|
3695 |
try
|
3696 |
{ allocate the unicode server name }
|
3697 |
CvtToWideChar(ServerName, S);
|
3698 |
|
3699 |
{ allocate the unicode group name }
|
3700 |
CvtToWideChar(GroupName, G);
|
3701 |
|
3702 |
{ allocate the unicode user name }
|
3703 |
CvtToWideChar(UserName, U);
|
3704 |
|
3705 |
{ call the API }
|
3706 |
Result := _NetGroupAddUser(S.Value, G.Value, U.Value);
|
3707 |
finally
|
3708 |
FreeMem(S.Value, S.Length);
|
3709 |
FreeMem(G.Value, G.Length);
|
3710 |
FreeMem(U.Value, U.Length);
|
3711 |
end;
|
3712 |
end else
|
3713 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3714 |
end else begin
|
3715 |
{ EStNetException }
|
3716 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3717 |
end;
|
3718 |
end;
|
3719 |
|
3720 |
function StNetGroupEnum(ServerName: string; Level: DWord; Buffer: Pointer;
|
3721 |
PrefMaxLen: DWord; var EntriesRead, TotalEntries,
|
3722 |
ResumeHandle: DWord): NET_API_STATUS;
|
3723 |
var
|
3724 |
S : TLMWideChar;
|
3725 |
begin
|
3726 |
Result := 0;
|
3727 |
if IsNetApi32 then begin
|
3728 |
if (@_NetGroupEnum = nil) then
|
3729 |
@_NetGroupEnum := GetProcAddress(NETAPI32, 'NetGroupEnum');
|
3730 |
|
3731 |
if (@_NetGroupEnum <> nil) then begin
|
3732 |
{ determine if UNC identifiers needed }
|
3733 |
ServerName := ServerUncName(ServerName);
|
3734 |
|
3735 |
S.Value := nil;
|
3736 |
try
|
3737 |
{ allocate the unicode server name }
|
3738 |
CvtToWideChar(ServerName, S);
|
3739 |
|
3740 |
{ call the API }
|
3741 |
Result := _NetGroupEnum(S.Value, Level, Buffer, PrefMaxLen,
|
3742 |
EntriesRead, TotalEntries, ResumeHandle);
|
3743 |
finally
|
3744 |
FreeMem(S.Value, S.Length);
|
3745 |
end;
|
3746 |
end else
|
3747 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3748 |
end else begin
|
3749 |
{ EStNetException }
|
3750 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3751 |
end;
|
3752 |
end;
|
3753 |
|
3754 |
function StNetGroupGetInfo(ServerName, GroupName: string; Level: DWord;
|
3755 |
var Buffer: Pointer): NET_API_STATUS;
|
3756 |
var
|
3757 |
S, G : TLMWideChar;
|
3758 |
begin
|
3759 |
Result := 0;
|
3760 |
if IsNetApi32 then begin
|
3761 |
if (@_NetGroupGetInfo = nil) then
|
3762 |
@_NetGroupGetInfo := GetProcAddress(NETAPI32, 'NetGroupGetInfo');
|
3763 |
|
3764 |
if (@_NetGroupGetInfo <> nil) then begin
|
3765 |
{ determine if UNC identifiers needed }
|
3766 |
ServerName := ServerUncName(ServerName);
|
3767 |
|
3768 |
S.Value := nil;
|
3769 |
G.Value := nil;
|
3770 |
try
|
3771 |
{ allocate the unicode server name }
|
3772 |
CvtToWideChar(ServerName, S);
|
3773 |
|
3774 |
{ allocate the unicode group name }
|
3775 |
CvtToWideChar(GroupName, G);
|
3776 |
|
3777 |
{ call the API }
|
3778 |
Result := _NetGroupGetInfo(S.Value, G.Value, Level, Buffer);
|
3779 |
finally
|
3780 |
FreeMem(S.Value, S.Length);
|
3781 |
FreeMem(G.Value, G.Length);
|
3782 |
end;
|
3783 |
end else
|
3784 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3785 |
end else begin
|
3786 |
{ EStNetException }
|
3787 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3788 |
end;
|
3789 |
end;
|
3790 |
|
3791 |
function StNetGroupSetInfo(ServerName, GroupName: string; Level: DWord;
|
3792 |
Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
3793 |
var
|
3794 |
S, G : TLMWideChar;
|
3795 |
begin
|
3796 |
Result := 0;
|
3797 |
if IsNetApi32 then begin
|
3798 |
if (@_NetGroupSetInfo = nil) then
|
3799 |
@_NetGroupSetInfo := GetProcAddress(NETAPI32, 'NetGroupSetInfo');
|
3800 |
|
3801 |
if (@_NetGroupSetInfo <> nil) then begin
|
3802 |
{ determine if UNC identifiers needed }
|
3803 |
ServerName := ServerUncName(ServerName);
|
3804 |
|
3805 |
S.Value := nil;
|
3806 |
G.Value := nil;
|
3807 |
try
|
3808 |
{ allocate the unicode server name }
|
3809 |
CvtToWideChar(ServerName, S);
|
3810 |
|
3811 |
{ allocate the unicode group name }
|
3812 |
CvtToWideChar(GroupName, G);
|
3813 |
|
3814 |
{ call the API }
|
3815 |
Result := _NetGroupSetInfo(S.Value, G.Value, Level, Buffer, ParmErr);
|
3816 |
finally
|
3817 |
FreeMem(S.Value, S.Length);
|
3818 |
FreeMem(G.Value, G.Length);
|
3819 |
end;
|
3820 |
end else
|
3821 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3822 |
end else begin
|
3823 |
{ EStNetException }
|
3824 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3825 |
end;
|
3826 |
end;
|
3827 |
|
3828 |
function StNetGroupDel(ServerName, GroupName: string): NET_API_STATUS;
|
3829 |
var
|
3830 |
S, G : TLMWideChar;
|
3831 |
begin
|
3832 |
Result := 0;
|
3833 |
if IsNetApi32 then begin
|
3834 |
if (@_NetGroupDel = nil) then
|
3835 |
@_NetGroupDel := GetProcAddress(NETAPI32, 'NetGroupDel');
|
3836 |
|
3837 |
if (@_NetGroupDel <> nil) then begin
|
3838 |
{ determine if UNC identifiers needed }
|
3839 |
ServerName := ServerUncName(ServerName);
|
3840 |
|
3841 |
S.Value := nil;
|
3842 |
G.Value := nil;
|
3843 |
try
|
3844 |
{ allocate the unicode server name }
|
3845 |
CvtToWideChar(ServerName, S);
|
3846 |
|
3847 |
{ allocate the unicode group name }
|
3848 |
CvtToWideChar(GroupName, G);
|
3849 |
|
3850 |
{ call the API }
|
3851 |
Result := _NetGroupDel(S.Value, G.Value);
|
3852 |
finally
|
3853 |
FreeMem(S.Value, S.Length);
|
3854 |
FreeMem(G.Value, G.Length);
|
3855 |
end;
|
3856 |
end else
|
3857 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3858 |
end else begin
|
3859 |
{ EStNetException }
|
3860 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3861 |
end;
|
3862 |
end;
|
3863 |
|
3864 |
function StNetGroupDelUser(ServerName, GroupName, UserName: string): NET_API_STATUS;
|
3865 |
var
|
3866 |
S, G, U : TLMWideChar;
|
3867 |
begin
|
3868 |
Result := 0;
|
3869 |
if IsNetApi32 then begin
|
3870 |
if (@_NetGroupDelUser = nil) then
|
3871 |
@_NetGroupDelUser := GetProcAddress(NETAPI32, 'NetGroupDelUser');
|
3872 |
|
3873 |
if (@_NetGroupDelUser <> nil) then begin
|
3874 |
{ determine if UNC identifiers needed }
|
3875 |
ServerName := ServerUncName(ServerName);
|
3876 |
|
3877 |
S.Value := nil;
|
3878 |
G.Value := nil;
|
3879 |
U.Value := nil;
|
3880 |
try
|
3881 |
{ allocate the unicode server name }
|
3882 |
CvtToWideChar(ServerName, S);
|
3883 |
|
3884 |
{ allocate the unicode group name }
|
3885 |
CvtToWideChar(GroupName, G);
|
3886 |
|
3887 |
{ allocate the unicode user name }
|
3888 |
CvtToWideChar(UserName, U);
|
3889 |
|
3890 |
{ call the API }
|
3891 |
Result := _NetGroupDelUser(S.Value, G.Value, U.Value);
|
3892 |
finally
|
3893 |
FreeMem(S.Value, S.Length);
|
3894 |
FreeMem(G.Value, G.Length);
|
3895 |
FreeMem(U.Value, U.Length);
|
3896 |
end;
|
3897 |
end else
|
3898 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3899 |
end else begin
|
3900 |
{ EStNetException }
|
3901 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3902 |
end;
|
3903 |
end;
|
3904 |
|
3905 |
function StNetGroupGetUsers(ServerName, GroupName: string; Level: DWord;
|
3906 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
3907 |
var EntriesRead, TotalEntries: DWord;
|
3908 |
ResumeHandle: Pointer): NET_API_STATUS;
|
3909 |
var
|
3910 |
S, G : TLMWideChar;
|
3911 |
begin
|
3912 |
Result := 0;
|
3913 |
if IsNetApi32 then begin
|
3914 |
if (@_NetGroupGetUsers = nil) then
|
3915 |
@_NetGroupGetUsers := GetProcAddress(NETAPI32, 'NetGroupGetUsers');
|
3916 |
|
3917 |
if (@_NetGroupGetUsers <> nil) then begin
|
3918 |
{ determine if UNC identifiers needed }
|
3919 |
ServerName := ServerUncName(ServerName);
|
3920 |
|
3921 |
S.Value := nil;
|
3922 |
G.Value := nil;
|
3923 |
try
|
3924 |
{ allocate the unicode server name }
|
3925 |
CvtToWideChar(ServerName, S);
|
3926 |
|
3927 |
{ allocate the unicode group name }
|
3928 |
CvtToWideChar(GroupName, G);
|
3929 |
|
3930 |
{ call the API }
|
3931 |
Result := _NetGroupGetUsers(S.Value, G.Value, Level, Buffer,
|
3932 |
PrefMaxLen, EntriesRead, TotalEntries,
|
3933 |
ResumeHandle);
|
3934 |
finally
|
3935 |
FreeMem(S.Value, S.Length);
|
3936 |
FreeMem(G.Value, G.Length);
|
3937 |
end;
|
3938 |
end else
|
3939 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3940 |
end else begin
|
3941 |
{ EStNetException }
|
3942 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3943 |
end;
|
3944 |
end;
|
3945 |
|
3946 |
function StNetGroupSetUsers(ServerName, GroupName: string; Level: DWord;
|
3947 |
Buffer: Pointer; var TotalEntries : DWord): NET_API_STATUS;
|
3948 |
var
|
3949 |
S, G : TLMWideChar;
|
3950 |
begin
|
3951 |
Result := 0;
|
3952 |
if IsNetApi32 then begin
|
3953 |
if (@_NetGroupSetUsers = nil) then
|
3954 |
@_NetGroupSetUsers := GetProcAddress(NETAPI32, 'NetGroupSetUsers');
|
3955 |
|
3956 |
if (@_NetGroupSetUsers <> nil) then begin
|
3957 |
{ determine if UNC identifiers needed }
|
3958 |
ServerName := ServerUncName(ServerName);
|
3959 |
|
3960 |
S.Value := nil;
|
3961 |
G.Value := nil;
|
3962 |
try
|
3963 |
{ allocate the unicode server name }
|
3964 |
CvtToWideChar(ServerName, S);
|
3965 |
|
3966 |
{ allocate the unicode group name }
|
3967 |
CvtToWideChar(GroupName, G);
|
3968 |
|
3969 |
{ call the API }
|
3970 |
Result := _NetGroupSetUsers(S.Value, G.Value, Level, Buffer, TotalEntries);
|
3971 |
finally
|
3972 |
FreeMem(S.Value, S.Length);
|
3973 |
FreeMem(G.Value, G.Length);
|
3974 |
end;
|
3975 |
end else
|
3976 |
RaiseStWin32Error(EStNetException, GetLastError);
|
3977 |
end else begin
|
3978 |
{ EStNetException }
|
3979 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
3980 |
end;
|
3981 |
end;
|
3982 |
|
3983 |
|
3984 |
function StNetLocalGroupAdd(ServerName: string; Level: DWord; Buffer: Pointer;
|
3985 |
var ParmErr: DWord): NET_API_STATUS;
|
3986 |
var
|
3987 |
S : TLMWideChar;
|
3988 |
begin
|
3989 |
Result := 0;
|
3990 |
if IsNetApi32 then begin
|
3991 |
if (@_NetLocalGroupAdd = nil) then
|
3992 |
@_NetLocalGroupAdd := GetProcAddress(NETAPI32, 'NetLocalGroupAdd');
|
3993 |
|
3994 |
if (@_NetLocalGroupAdd <> nil) then begin
|
3995 |
{ determine if UNC identifiers needed }
|
3996 |
ServerName := ServerUncName(ServerName);
|
3997 |
|
3998 |
S.Value := nil;
|
3999 |
try
|
4000 |
{ allocate the unicode server name }
|
4001 |
CvtToWideChar(ServerName, S);
|
4002 |
|
4003 |
{ call the API }
|
4004 |
Result := _NetLocalGroupAdd(S.Value, Level, Buffer, ParmErr);
|
4005 |
finally
|
4006 |
FreeMem(S.Value, S.Length);
|
4007 |
end;
|
4008 |
end else
|
4009 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4010 |
end else begin
|
4011 |
{ EStNetException }
|
4012 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4013 |
end;
|
4014 |
end;
|
4015 |
|
4016 |
function StNetLocalGroupAddMember(ServerName, GroupName: string;
|
4017 |
MemberSID: PSID): NET_API_STATUS;
|
4018 |
var
|
4019 |
S, G : TLMWideChar;
|
4020 |
begin
|
4021 |
Result := 0;
|
4022 |
if IsNetApi32 then begin
|
4023 |
if (@_NetLocalGroupAddMember = nil) then
|
4024 |
@_NetLocalGroupAddMember := GetProcAddress(NETAPI32, 'NetLocalGroupAddMember');
|
4025 |
|
4026 |
if (@_NetLocalGroupAddMember <> nil) then begin
|
4027 |
{ determine if UNC identifiers needed }
|
4028 |
ServerName := ServerUncName(ServerName);
|
4029 |
|
4030 |
S.Value := nil;
|
4031 |
G.Value := nil;
|
4032 |
try
|
4033 |
{ allocate the unicode server name }
|
4034 |
CvtToWideChar(ServerName, S);
|
4035 |
|
4036 |
{ allocate the unicode group name }
|
4037 |
CvtToWideChar(GroupName, G);
|
4038 |
|
4039 |
{ call the API }
|
4040 |
Result := _NetLocalGroupAddMember(S.Value, G.Value, MemberSID)
|
4041 |
finally
|
4042 |
FreeMem(S.Value, S.Length);
|
4043 |
FreeMem(G.Value, G.Length);
|
4044 |
end;
|
4045 |
end else
|
4046 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4047 |
end else begin
|
4048 |
{ EStNetException }
|
4049 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4050 |
end;
|
4051 |
end;
|
4052 |
|
4053 |
function StNetLocalGroupEnum(ServerName: string; Level: DWord;
|
4054 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
4055 |
var EntriesRead, TotalEntries: DWord;
|
4056 |
var ResumeHandle: DWord): NET_API_STATUS;
|
4057 |
var
|
4058 |
S : TLMWideChar;
|
4059 |
begin
|
4060 |
Result := 0;
|
4061 |
if IsNetApi32 then begin
|
4062 |
if (@_NetLocalGroupEnum = nil) then
|
4063 |
@_NetLocalGroupEnum := GetProcAddress(NETAPI32, 'NetLocalGroupEnum');
|
4064 |
|
4065 |
if (@_NetLocalGroupEnum <> nil) then begin
|
4066 |
{ determine if UNC identifiers needed }
|
4067 |
ServerName := ServerUncName(ServerName);
|
4068 |
|
4069 |
S.Value := nil;
|
4070 |
try
|
4071 |
{ allocate the unicode server name }
|
4072 |
CvtToWideChar(ServerName, S);
|
4073 |
|
4074 |
{ call the API }
|
4075 |
Result := _NetLocalGroupEnum(S.Value, Level, Buffer, PrefMaxLen,
|
4076 |
EntriesRead, TotalEntries, ResumeHandle);
|
4077 |
finally
|
4078 |
FreeMem(S.Value, S.Length);
|
4079 |
end;
|
4080 |
end else
|
4081 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4082 |
end else begin
|
4083 |
{ EStNetException }
|
4084 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4085 |
end;
|
4086 |
end;
|
4087 |
|
4088 |
function StNetLocalGroupGetInfo(ServerName, GroupName: string; Level: DWord;
|
4089 |
var Buffer: Pointer): NET_API_STATUS;
|
4090 |
var
|
4091 |
S, G : TLMWideChar;
|
4092 |
begin
|
4093 |
Result := 0;
|
4094 |
if IsNetApi32 then begin
|
4095 |
if (@_NetLocalGroupGetInfo = nil) then
|
4096 |
@_NetLocalGroupGetInfo := GetProcAddress(NETAPI32, 'NetLocalGroupGetInfo');
|
4097 |
|
4098 |
if (@_NetLocalGroupGetInfo <> nil) then begin
|
4099 |
{ determine if UNC identifiers needed }
|
4100 |
ServerName := ServerUncName(ServerName);
|
4101 |
|
4102 |
S.Value := nil;
|
4103 |
G.Value := nil;
|
4104 |
try
|
4105 |
{ allocate the unicode server name }
|
4106 |
CvtToWideChar(ServerName, S);
|
4107 |
|
4108 |
{ allocate the unicode group name }
|
4109 |
CvtToWideChar(GroupName, G);
|
4110 |
|
4111 |
{ call the API }
|
4112 |
Result := _NetLocalGroupGetInfo(S.Value, G.Value, Level, Buffer);
|
4113 |
finally
|
4114 |
FreeMem(S.Value, S.Length);
|
4115 |
FreeMem(G.Value, G.Length);
|
4116 |
end;
|
4117 |
end else
|
4118 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4119 |
end else begin
|
4120 |
{ EStNetException }
|
4121 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4122 |
end;
|
4123 |
end;
|
4124 |
|
4125 |
function StNetLocalGroupSetInfo(ServerName, GroupName: string; Level: DWord;
|
4126 |
Buffer: Pointer;
|
4127 |
var ParmErr: DWord): NET_API_STATUS;
|
4128 |
var
|
4129 |
S, G : TLMWideChar;
|
4130 |
begin
|
4131 |
Result := 0;
|
4132 |
if IsNetApi32 then begin
|
4133 |
if (@_NetLocalGroupSetInfo = nil) then
|
4134 |
@_NetLocalGroupSetInfo := GetProcAddress(NETAPI32, 'NetLocalGroupSetInfo');
|
4135 |
|
4136 |
if (@_NetLocalGroupSetInfo <> nil) then begin
|
4137 |
{ determine if UNC identifiers needed }
|
4138 |
ServerName := ServerUncName(ServerName);
|
4139 |
|
4140 |
S.Value := nil;
|
4141 |
G.Value := nil;
|
4142 |
try
|
4143 |
{ allocate the unicode server name }
|
4144 |
CvtToWideChar(ServerName, S);
|
4145 |
|
4146 |
{ allocate the unicode group name }
|
4147 |
CvtToWideChar(GroupName, G);
|
4148 |
|
4149 |
{ call the API }
|
4150 |
Result := _NetLocalGroupSetInfo(S.Value, G.Value, Level, Buffer, ParmErr);
|
4151 |
finally
|
4152 |
FreeMem(S.Value, S.Length);
|
4153 |
FreeMem(G.Value, G.Length);
|
4154 |
end;
|
4155 |
end else
|
4156 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4157 |
end else begin
|
4158 |
{ EStNetException }
|
4159 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4160 |
end;
|
4161 |
end;
|
4162 |
|
4163 |
function StNetLocalGroupDel(ServerName, GroupName: string): NET_API_STATUS;
|
4164 |
var
|
4165 |
S, G : TLMWideChar;
|
4166 |
begin
|
4167 |
Result := 0;
|
4168 |
if IsNetApi32 then begin
|
4169 |
if (@_NetLocalGroupDel = nil) then
|
4170 |
@_NetLocalGroupDel := GetProcAddress(NETAPI32, 'NetLocalGroupDel');
|
4171 |
|
4172 |
if (@_NetLocalGroupDel <> nil) then begin
|
4173 |
{ determine if UNC identifiers needed }
|
4174 |
ServerName := ServerUncName(ServerName);
|
4175 |
|
4176 |
S.Value := nil;
|
4177 |
G.Value := nil;
|
4178 |
try
|
4179 |
{ allocate the unicode server name }
|
4180 |
CvtToWideChar(ServerName, S);
|
4181 |
|
4182 |
{ allocate the unicode group name }
|
4183 |
CvtToWideChar(GroupName, G);
|
4184 |
|
4185 |
{ call the API }
|
4186 |
Result := _NetLocalGroupDel(S.Value, G.Value);
|
4187 |
finally
|
4188 |
FreeMem(S.Value, S.Length);
|
4189 |
FreeMem(G.Value, G.Length);
|
4190 |
end;
|
4191 |
end else
|
4192 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4193 |
end else begin
|
4194 |
{ EStNetException }
|
4195 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4196 |
end;
|
4197 |
end;
|
4198 |
|
4199 |
function StNetLocalGroupDelMember(ServerName, GroupName: string;
|
4200 |
MemberSID: PSID): NET_API_STATUS;
|
4201 |
var
|
4202 |
S, G : TLMWideChar;
|
4203 |
begin
|
4204 |
Result := 0;
|
4205 |
if IsNetApi32 then begin
|
4206 |
if (@_NetLocalGroupDelMember = nil) then
|
4207 |
@_NetLocalGroupDelMember := GetProcAddress(NETAPI32, 'NetLocalGroupDelMember');
|
4208 |
|
4209 |
if (@_NetLocalGroupDelMember <> nil) then begin
|
4210 |
{ determine if UNC identifiers needed }
|
4211 |
ServerName := ServerUncName(ServerName);
|
4212 |
|
4213 |
S.Value := nil;
|
4214 |
G.Value := nil;
|
4215 |
try
|
4216 |
{ allocate the unicode server name }
|
4217 |
CvtToWideChar(ServerName, S);
|
4218 |
|
4219 |
{ allocate the unicode group name }
|
4220 |
CvtToWideChar(GroupName, G);
|
4221 |
|
4222 |
{ call the API }
|
4223 |
Result := _NetLocalGroupDelMember(S.Value, G.Value, MemberSID)
|
4224 |
finally
|
4225 |
FreeMem(S.Value, S.Length);
|
4226 |
FreeMem(G.Value, G.Length);
|
4227 |
end;
|
4228 |
end else
|
4229 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4230 |
end else begin
|
4231 |
{ EStNetException }
|
4232 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4233 |
end;
|
4234 |
end;
|
4235 |
|
4236 |
function StNetLocalGroupGetMembers(ServerName, GroupName: string; Level: DWord;
|
4237 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
4238 |
var EntriesRead, TotalEntries: DWord;
|
4239 |
ResumeHandle: Pointer): NET_API_STATUS;
|
4240 |
var
|
4241 |
S, G : TLMWideChar;
|
4242 |
begin
|
4243 |
Result := 0;
|
4244 |
if IsNetApi32 then begin
|
4245 |
if (@_NetLocalGroupGetMembers = nil) then
|
4246 |
@_NetLocalGroupGetMembers := GetProcAddress(NETAPI32, 'NetLocalGroupGetMembers');
|
4247 |
|
4248 |
if (@_NetLocalGroupGetMembers <> nil) then begin
|
4249 |
{ determine if UNC identifiers needed }
|
4250 |
ServerName := ServerUncName(ServerName);
|
4251 |
|
4252 |
S.Value := nil;
|
4253 |
G.Value := nil;
|
4254 |
try
|
4255 |
{ allocate the unicode server name }
|
4256 |
CvtToWideChar(ServerName, S);
|
4257 |
|
4258 |
{ allocate the unicode group name }
|
4259 |
CvtToWideChar(GroupName, G);
|
4260 |
|
4261 |
{ call the API }
|
4262 |
Result := _NetLocalGroupGetMembers(S.Value, G.Value, Level, Buffer,
|
4263 |
PrefMaxLen, EntriesRead,
|
4264 |
TotalEntries, ResumeHandle)
|
4265 |
finally
|
4266 |
FreeMem(S.Value, S.Length);
|
4267 |
FreeMem(G.Value, G.Length);
|
4268 |
end;
|
4269 |
end else
|
4270 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4271 |
end else begin
|
4272 |
{ EStNetException }
|
4273 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4274 |
end;
|
4275 |
end;
|
4276 |
|
4277 |
function StNetLocalGroupSetMembers(ServerName, GroupName: string; Level: DWord;
|
4278 |
Buffer: Pointer;
|
4279 |
var TotalEntries: DWord): NET_API_STATUS;
|
4280 |
var
|
4281 |
S, G : TLMWideChar;
|
4282 |
begin
|
4283 |
Result := 0;
|
4284 |
if IsNetApi32 then begin
|
4285 |
if (@_NetLocalGroupSetMembers = nil) then
|
4286 |
@_NetLocalGroupSetMembers := GetProcAddress(NETAPI32, 'NetLocalGroupSetMembers');
|
4287 |
|
4288 |
if (@_NetLocalGroupSetMembers <> nil) then begin
|
4289 |
{ determine if UNC identifiers needed }
|
4290 |
ServerName := ServerUncName(ServerName);
|
4291 |
|
4292 |
S.Value := nil;
|
4293 |
G.Value := nil;
|
4294 |
try
|
4295 |
{ allocate the unicode server name }
|
4296 |
CvtToWideChar(ServerName, S);
|
4297 |
|
4298 |
{ allocate the unicode group name }
|
4299 |
CvtToWideChar(GroupName, G);
|
4300 |
|
4301 |
{ call the API }
|
4302 |
Result := _NetLocalGroupSetMembers(S.Value, G.Value, Level, Buffer,
|
4303 |
TotalEntries);
|
4304 |
finally
|
4305 |
FreeMem(S.Value, S.Length);
|
4306 |
FreeMem(G.Value, G.Length);
|
4307 |
end;
|
4308 |
end else
|
4309 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4310 |
end else begin
|
4311 |
{ EStNetException }
|
4312 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4313 |
end;
|
4314 |
end;
|
4315 |
|
4316 |
function StNetLocalGroupAddMembers(ServerName, GroupName: string; Level: DWord;
|
4317 |
Buffer: Pointer;
|
4318 |
TotalEntries: DWord): NET_API_STATUS;
|
4319 |
var
|
4320 |
S, G : TLMWideChar;
|
4321 |
begin
|
4322 |
Result := 0;
|
4323 |
if IsNetApi32 then begin
|
4324 |
if (@_NetLocalGroupAddMembers = nil) then
|
4325 |
@_NetLocalGroupAddMembers := GetProcAddress(NETAPI32, 'NetLocalGroupAddMembers');
|
4326 |
|
4327 |
if (@_NetLocalGroupAddMembers <> nil) then begin
|
4328 |
{ determine if UNC identifiers needed }
|
4329 |
ServerName := ServerUncName(ServerName);
|
4330 |
|
4331 |
S.Value := nil;
|
4332 |
G.Value := nil;
|
4333 |
try
|
4334 |
{ allocate the unicode server name }
|
4335 |
CvtToWideChar(ServerName, S);
|
4336 |
|
4337 |
{ allocate the unicode group name }
|
4338 |
CvtToWideChar(GroupName, G);
|
4339 |
|
4340 |
{ call the API }
|
4341 |
Result := _NetLocalGroupAddMembers(S.Value, G.Value, Level, Buffer,
|
4342 |
TotalEntries);
|
4343 |
finally
|
4344 |
FreeMem(S.Value, S.Length);
|
4345 |
FreeMem(G.Value, G.Length);
|
4346 |
end;
|
4347 |
end else
|
4348 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4349 |
end else begin
|
4350 |
{ EStNetException }
|
4351 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4352 |
end;
|
4353 |
end;
|
4354 |
|
4355 |
function StNetLocalGroupDelMembers(ServerName, GroupName: string; Level: DWord;
|
4356 |
Buffer: Pointer; TotalEntries: DWord): NET_API_STATUS;
|
4357 |
var
|
4358 |
S, G : TLMWideChar;
|
4359 |
begin
|
4360 |
Result := 0;
|
4361 |
if IsNetApi32 then begin
|
4362 |
if (@_NetLocalGroupDelMembers = nil) then
|
4363 |
@_NetLocalGroupDelMembers := GetProcAddress(NETAPI32, 'NetLocalGroupDelMembers');
|
4364 |
|
4365 |
if (@_NetLocalGroupDelMembers <> nil) then begin
|
4366 |
{ determine if UNC identifiers needed }
|
4367 |
ServerName := ServerUncName(ServerName);
|
4368 |
|
4369 |
S.Value := nil;
|
4370 |
G.Value := nil;
|
4371 |
try
|
4372 |
{ allocate the unicode server name }
|
4373 |
CvtToWideChar(ServerName, S);
|
4374 |
|
4375 |
{ allocate the unicode group name }
|
4376 |
CvtToWideChar(GroupName, G);
|
4377 |
|
4378 |
{ call the API }
|
4379 |
Result := _NetLocalGroupDelMembers(S.Value, G.Value, Level, Buffer,
|
4380 |
TotalEntries);
|
4381 |
finally
|
4382 |
FreeMem(S.Value, S.Length);
|
4383 |
FreeMem(G.Value, G.Length);
|
4384 |
end;
|
4385 |
end else
|
4386 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4387 |
end else begin
|
4388 |
{ EStNetException }
|
4389 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4390 |
end;
|
4391 |
end;
|
4392 |
|
4393 |
|
4394 |
function StNetQueryDisplayInformation(ServerName: string; Level, Index,
|
4395 |
EntriesRequested, PrefMaxLen: DWord;
|
4396 |
var ReturnedCount: DWord;
|
4397 |
var Buffer: Pointer): NET_API_STATUS;
|
4398 |
var
|
4399 |
S : TLMWidechar;
|
4400 |
begin
|
4401 |
Result := 0;
|
4402 |
if IsNetApi32 then begin
|
4403 |
if (@_NetQueryDisplayInformation = nil) then
|
4404 |
@_NetQueryDisplayInformation := GetProcAddress(NETAPI32, 'NetQueryDisplayInformation');
|
4405 |
|
4406 |
if (@_NetQueryDisplayInformation <> nil) then begin
|
4407 |
{ determine if UNC identifiers needed }
|
4408 |
ServerName := ServerUncName(ServerName);
|
4409 |
|
4410 |
S.Value := nil;
|
4411 |
try
|
4412 |
{ allocate the unicode server name }
|
4413 |
CvtToWideChar(ServerName, S);
|
4414 |
|
4415 |
{ call the API }
|
4416 |
Result := _NetQueryDisplayInformation(S.Value, Level, Index,
|
4417 |
EntriesRequested, PrefMaxLen,
|
4418 |
ReturnedCount, Buffer);
|
4419 |
finally
|
4420 |
FreeMem(S.Value, S.Length);
|
4421 |
end;
|
4422 |
end else
|
4423 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4424 |
end else begin
|
4425 |
{ EStNetException }
|
4426 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4427 |
end;
|
4428 |
end;
|
4429 |
|
4430 |
function StNetGetDisplayInformationIndex(ServerName: string; Level: DWord;
|
4431 |
Prefix: string;
|
4432 |
var Index: DWord): NET_API_STATUS;
|
4433 |
var
|
4434 |
S, P : TLMWidechar;
|
4435 |
begin
|
4436 |
Result := 0;
|
4437 |
if IsNetApi32 then begin
|
4438 |
if (@_NetGetDisplayInformationIndex = nil) then
|
4439 |
@_NetGetDisplayInformationIndex := GetProcAddress(NETAPI32, 'NetGetDisplayInformationIndex');
|
4440 |
|
4441 |
if (@_NetGetDisplayInformationIndex <> nil) then begin
|
4442 |
{ determine if UNC identifiers needed }
|
4443 |
ServerName := ServerUncName(ServerName);
|
4444 |
|
4445 |
S.Value := nil;
|
4446 |
P.Value := nil;
|
4447 |
try
|
4448 |
{ allocate the unicode server name }
|
4449 |
CvtToWideChar(ServerName, S);
|
4450 |
|
4451 |
{ allocate the unicode prefix }
|
4452 |
CvtToWideChar(Prefix, P);
|
4453 |
|
4454 |
{ call the API }
|
4455 |
Result := _NetGetDisplayInformationIndex(S.Value, Level, P.Value, Index);
|
4456 |
finally
|
4457 |
FreeMem(S.Value, S.Length);
|
4458 |
FreeMem(P.Value, P.Length);
|
4459 |
end;
|
4460 |
end else
|
4461 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4462 |
end else begin
|
4463 |
{ EStNetException }
|
4464 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4465 |
end;
|
4466 |
end;
|
4467 |
|
4468 |
function StNetAccessAdd(ServerName: string; Level: DWord; Buffer: Pointer;
|
4469 |
var ParmErr: DWord): NET_API_STATUS;
|
4470 |
var
|
4471 |
S : TLMWidechar;
|
4472 |
begin
|
4473 |
Result := 0;
|
4474 |
if IsNetApi32 then begin
|
4475 |
if (@_NetAccessAdd = nil) then
|
4476 |
@_NetAccessAdd := GetProcAddress(NETAPI32, 'NetAccessAdd');
|
4477 |
|
4478 |
if (@_NetAccessAdd <> nil) then begin
|
4479 |
S.Value := nil;
|
4480 |
try
|
4481 |
{ allocate the unicode server name }
|
4482 |
CvtToWideChar(ServerName, S);
|
4483 |
|
4484 |
{ call the API }
|
4485 |
Result := _NetAccessAdd(S.Value, Level, Buffer, ParmErr)
|
4486 |
finally
|
4487 |
FreeMem(S.Value, S.Length);
|
4488 |
end;
|
4489 |
end else
|
4490 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4491 |
end else begin
|
4492 |
{ EStNetException }
|
4493 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4494 |
end;
|
4495 |
end;
|
4496 |
|
4497 |
function StNetAccessEnum(ServerName, BasePath: string; Recursive, Level: DWord;
|
4498 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
4499 |
var EntriesRead, TotalEntries,
|
4500 |
ResumeHandle: DWord): NET_API_STATUS;
|
4501 |
var
|
4502 |
S, B : TLMWideChar;
|
4503 |
begin
|
4504 |
Result := 0;
|
4505 |
if IsNetApi32 then begin
|
4506 |
if (@_NetAccessEnum = nil) then
|
4507 |
@_NetAccessEnum := GetProcAddress(NETAPI32, 'NetAccessEnum');
|
4508 |
|
4509 |
if (@_NetAccessEnum <> nil) then begin
|
4510 |
S.Value := nil;
|
4511 |
B.Value := nil;
|
4512 |
try
|
4513 |
{ allocate the unicode server name }
|
4514 |
CvtToWideChar(ServerName, S);
|
4515 |
|
4516 |
{ allocate the unicode base path }
|
4517 |
CvtToWideChar(BasePath, B);
|
4518 |
|
4519 |
{ call the API }
|
4520 |
Result := _NetAccessEnum(S.Value, B.Value, Recursive, Level, Buffer,
|
4521 |
PrefMaxLen, EntriesRead, TotalEntries,
|
4522 |
ResumeHandle);
|
4523 |
finally
|
4524 |
FreeMem(S.Value, S.Length);
|
4525 |
FreeMem(B.Value, B.Length);
|
4526 |
end;
|
4527 |
end else
|
4528 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4529 |
end else begin
|
4530 |
{ EStNetException }
|
4531 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4532 |
end;
|
4533 |
end;
|
4534 |
|
4535 |
function StNetAccessGetInfo(ServerName, Resource: string; Level: DWord;
|
4536 |
var Buffer: Pointer): NET_API_STATUS;
|
4537 |
var
|
4538 |
S, R : TLMWideChar;
|
4539 |
begin
|
4540 |
Result := 0;
|
4541 |
if IsNetApi32 then begin
|
4542 |
if (@_NetAccessGetInfo = nil) then
|
4543 |
@_NetAccessGetInfo := GetProcAddress(NETAPI32, 'NetAccessGetInfo');
|
4544 |
|
4545 |
if (@_NetAccessGetInfo <> nil) then begin
|
4546 |
S.Value := nil;
|
4547 |
R.Value := nil;
|
4548 |
try
|
4549 |
{ allocate the unicode server name }
|
4550 |
CvtToWideChar(ServerName, S);
|
4551 |
|
4552 |
{ allocate the unicode resource }
|
4553 |
CvtToWideChar(Resource, R);
|
4554 |
|
4555 |
{ call the API }
|
4556 |
Result := _NetAccessGetInfo(S.Value, R.Value, Level, Buffer);
|
4557 |
finally
|
4558 |
FreeMem(S.Value, S.Length);
|
4559 |
FreeMem(R.Value, R.Length);
|
4560 |
end;
|
4561 |
end else
|
4562 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4563 |
end else begin
|
4564 |
{ EStNetException }
|
4565 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4566 |
end;
|
4567 |
end;
|
4568 |
|
4569 |
function StNetAccessSetInfo(ServerName, Resource: string; Level: DWord;
|
4570 |
Buffer: Pointer; var ParmErr: DWord): NET_API_STATUS;
|
4571 |
var
|
4572 |
S, R : TLMWideChar;
|
4573 |
begin
|
4574 |
Result := 0;
|
4575 |
if IsNetApi32 then begin
|
4576 |
if (@_NetAccessSetInfo = nil) then
|
4577 |
@_NetAccessSetInfo := GetProcAddress(NETAPI32, 'NetAccessSetInfo');
|
4578 |
|
4579 |
if (@_NetAccessSetInfo <> nil) then begin
|
4580 |
S.Value := nil;
|
4581 |
R.Value := nil;
|
4582 |
try
|
4583 |
{ allocate the unicode server name }
|
4584 |
CvtToWideChar(ServerName, S);
|
4585 |
|
4586 |
{ allocate the unicode resource }
|
4587 |
CvtToWideChar(Resource, R);
|
4588 |
|
4589 |
{ call the API }
|
4590 |
Result := _NetAccessSetInfo(S.Value, R.Value, Level, Buffer, ParmErr);
|
4591 |
finally
|
4592 |
FreeMem(S.Value, S.Length);
|
4593 |
FreeMem(R.Value, R.Length);
|
4594 |
end;
|
4595 |
end else
|
4596 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4597 |
end else begin
|
4598 |
{ EStNetException }
|
4599 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4600 |
end;
|
4601 |
end;
|
4602 |
|
4603 |
function StNetAccessDel(ServerName, Resource: string): NET_API_STATUS;
|
4604 |
var
|
4605 |
S, R : TLMWideChar;
|
4606 |
begin
|
4607 |
Result := 0;
|
4608 |
if IsNetApi32 then begin
|
4609 |
if (@_NetAccessDel = nil) then
|
4610 |
@_NetAccessDel := GetProcAddress(NETAPI32, 'NetAccessDel');
|
4611 |
|
4612 |
if (@_NetAccessDel <> nil) then begin
|
4613 |
S.Value := nil;
|
4614 |
R.Value := nil;
|
4615 |
try
|
4616 |
{ allocate the unicode server name }
|
4617 |
CvtToWideChar(ServerName, S);
|
4618 |
|
4619 |
{ allocate the unicode resource }
|
4620 |
CvtToWideChar(Resource, R);
|
4621 |
|
4622 |
{ call the API }
|
4623 |
Result := _NetAccessDel(S.Value, R.Value);
|
4624 |
finally
|
4625 |
FreeMem(S.Value, S.Length);
|
4626 |
FreeMem(R.Value, R.Length);
|
4627 |
end;
|
4628 |
end else
|
4629 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4630 |
end else begin
|
4631 |
{ EStNetException }
|
4632 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4633 |
end;
|
4634 |
end;
|
4635 |
|
4636 |
function StNetAccessGetUserPerms(ServerName, UGname, Resource: string;
|
4637 |
var Perms: DWord): NET_API_STATUS;
|
4638 |
var
|
4639 |
S, U, R : TLMWideChar;
|
4640 |
begin
|
4641 |
Result := 0;
|
4642 |
if IsNetApi32 then begin
|
4643 |
if (@_NetAccessGetUserPerms = nil) then
|
4644 |
@_NetAccessGetUserPerms := GetProcAddress(NETAPI32, 'NetAccessGetUserPerms');
|
4645 |
|
4646 |
if (@_NetAccessGetUserPerms <> nil) then begin
|
4647 |
S.Value := nil;
|
4648 |
U.Value := nil;
|
4649 |
R.Value := nil;
|
4650 |
try
|
4651 |
{ allocate the unicode server name }
|
4652 |
CvtToWideChar(ServerName, S);
|
4653 |
|
4654 |
{ allocate the unicode user/group name }
|
4655 |
CvtToWideChar(UGname, U);
|
4656 |
|
4657 |
{ allocate the unicode resource }
|
4658 |
CvtToWideChar(Resource, R);
|
4659 |
|
4660 |
{ call the API }
|
4661 |
Result := _NetAccessGetUserPerms(S.Value, U.Value, R.Value, Perms);
|
4662 |
finally
|
4663 |
FreeMem(S.Value, S.Length);
|
4664 |
FreeMem(U.Value, U.Length);
|
4665 |
FreeMem(R.Value, R.Length);
|
4666 |
end;
|
4667 |
end else
|
4668 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4669 |
end else begin
|
4670 |
{ EStNetException }
|
4671 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4672 |
end;
|
4673 |
end;
|
4674 |
|
4675 |
|
4676 |
function StNetGetDCName(ServerName, DomainName: string;
|
4677 |
var Buffer: string): NET_API_STATUS;
|
4678 |
var
|
4679 |
S, D: TLMWideChar;
|
4680 |
DB : Pointer;
|
4681 |
begin
|
4682 |
Result := 0;
|
4683 |
if IsNetApi32 then begin
|
4684 |
if (@_NetGetDCName = nil) then
|
4685 |
@_NetGetDCName := GetProcAddress(NETAPI32, 'NetGetDCName');
|
4686 |
|
4687 |
if (@_NetGetDCName <> nil) then begin
|
4688 |
S.Value := nil;
|
4689 |
D.Value := nil;
|
4690 |
try
|
4691 |
{ allocate the unicode server name }
|
4692 |
CvtToWideChar(ServerName, S);
|
4693 |
|
4694 |
{ allocate the unicode domain name }
|
4695 |
CvtToWideChar(DomainName, D);
|
4696 |
|
4697 |
{ call the API }
|
4698 |
Result := _NetGetDCName(S.Value, D.Value, DB);
|
4699 |
if Result = NERR_SUCCESS then begin
|
4700 |
Buffer := WideCharToString(DB);
|
4701 |
StNetApiBufferFree(DB);
|
4702 |
end;
|
4703 |
finally
|
4704 |
FreeMem(S.Value, S.Length);
|
4705 |
FreeMem(D.Value, D.Length);
|
4706 |
end;
|
4707 |
end else
|
4708 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4709 |
end else begin
|
4710 |
{ EStNetException }
|
4711 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4712 |
end;
|
4713 |
end;
|
4714 |
|
4715 |
function StNetGetAnyDCName(ServerName, DomainName: string;
|
4716 |
var Buffer: string): NET_API_STATUS;
|
4717 |
var
|
4718 |
S, D : TLMWideChar;
|
4719 |
B : PByte;
|
4720 |
begin
|
4721 |
Result := 0;
|
4722 |
if IsNetApi32 then begin
|
4723 |
if (@_NetGetAnyDCName = nil) then
|
4724 |
@_NetGetAnyDCName := GetProcAddress(NETAPI32, 'NetGetAnyDCName');
|
4725 |
|
4726 |
if (@_NetGetAnyDCName <> nil) then begin
|
4727 |
S.Value := nil;
|
4728 |
D.Value := nil;
|
4729 |
try
|
4730 |
{ allocate the unicode server name }
|
4731 |
CvtToWideChar(ServerName, S);
|
4732 |
|
4733 |
{ allocate the unicode domain name }
|
4734 |
CvtToWideChar(DomainName, D);
|
4735 |
|
4736 |
{ call the API }
|
4737 |
Result := _NetGetAnyDCName(S.Value, D.Value, B);
|
4738 |
if Result = NERR_SUCCESS then begin
|
4739 |
Buffer := StrPas(PAnsiChar(B));
|
4740 |
StNetApiBufferFree(B);
|
4741 |
end;
|
4742 |
finally
|
4743 |
FreeMem(S.Value, S.Length);
|
4744 |
FreeMem(D.Value, D.Length);
|
4745 |
end;
|
4746 |
end else
|
4747 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4748 |
end else begin
|
4749 |
{ EStNetException }
|
4750 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4751 |
end;
|
4752 |
end;
|
4753 |
|
4754 |
function StI_NetLogonControl(ServerName: string; FunctionCode, QueryLevel: DWord;
|
4755 |
var Buffer: Pointer): NET_API_STATUS;
|
4756 |
var
|
4757 |
S : TLMWideChar;
|
4758 |
begin
|
4759 |
Result := 0;
|
4760 |
if IsNetApi32 then begin
|
4761 |
if (@_I_NetLogonControl = nil) then
|
4762 |
@_I_NetLogonControl := GetProcAddress(NETAPI32, 'I_NetLogonControl');
|
4763 |
|
4764 |
if (@_I_NetLogonControl <> nil) then begin
|
4765 |
S.Value := nil;
|
4766 |
try
|
4767 |
{ allocate the unicode server name }
|
4768 |
CvtToWideChar(ServerName, S);
|
4769 |
|
4770 |
{ call the API }
|
4771 |
Result := _I_NetLogonControl(S.Value, FunctionCode, QueryLevel, Buffer)
|
4772 |
finally
|
4773 |
FreeMem(S.Value, S.Length);
|
4774 |
end;
|
4775 |
end else
|
4776 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4777 |
end else begin
|
4778 |
{ EStNetException }
|
4779 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4780 |
end;
|
4781 |
end;
|
4782 |
|
4783 |
function StI_NetLogonControl2(ServerName: string; FunctionCode,
|
4784 |
QueryLevel: DWord; Data: Pointer;
|
4785 |
var Buffer: Pointer): NET_API_STATUS;
|
4786 |
var
|
4787 |
S : TLMWideChar;
|
4788 |
begin
|
4789 |
Result := 0;
|
4790 |
if IsNetApi32 then begin
|
4791 |
if (@_I_NetLogonControl2 = nil) then
|
4792 |
@_I_NetLogonControl2 := GetProcAddress(NETAPI32, 'I_NetLogonControl2');
|
4793 |
|
4794 |
if (@_I_NetLogonControl2 <> nil) then begin
|
4795 |
S.Value := nil;
|
4796 |
try
|
4797 |
{ allocate the unicode server name }
|
4798 |
CvtToWideChar(ServerName, S);
|
4799 |
|
4800 |
{ call the API }
|
4801 |
Result := _I_NetLogonControl2(S.Value, FunctionCode, QueryLevel, Data, Buffer);
|
4802 |
finally
|
4803 |
FreeMem(S.Value, S.Length);
|
4804 |
end;
|
4805 |
end else
|
4806 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4807 |
end else begin
|
4808 |
{ EStNetException }
|
4809 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4810 |
end;
|
4811 |
end;
|
4812 |
|
4813 |
function StNetEnumerateTrustedDomains(ServerName: string;
|
4814 |
var Buffer: Pointer): NET_API_STATUS;
|
4815 |
var
|
4816 |
S : TLMWideChar;
|
4817 |
begin
|
4818 |
Result := 0;
|
4819 |
if IsNetApi32 then begin
|
4820 |
if (@_NetEnumerateTrustedDomains = nil) then
|
4821 |
@_NetEnumerateTrustedDomains := GetProcAddress(NETAPI32, 'NetEnumerateTrustedDomains');
|
4822 |
|
4823 |
if (@_NetEnumerateTrustedDomains <> nil) then begin
|
4824 |
S.Value := nil;
|
4825 |
try
|
4826 |
{ allocate the unicode server name }
|
4827 |
CvtToWideChar(ServerName, S);
|
4828 |
|
4829 |
{ call the API }
|
4830 |
Result := _NetEnumerateTrustedDomains(S.Value, Buffer)
|
4831 |
finally
|
4832 |
FreeMem(S.Value, S.Length);
|
4833 |
end;
|
4834 |
end else
|
4835 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4836 |
end else begin
|
4837 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4838 |
end;
|
4839 |
end;
|
4840 |
|
4841 |
|
4842 |
{LMALERT}
|
4843 |
function StNetAlertRaise(AlertEventName: string; Buffer: Pointer;
|
4844 |
BufferSize: DWord): NET_API_STATUS;
|
4845 |
var
|
4846 |
A : TLMWideChar;
|
4847 |
begin
|
4848 |
Result := 0;
|
4849 |
if IsNetApi32 then begin
|
4850 |
if (@_NetAlertRaise = nil) then
|
4851 |
@_NetAlertRaise := GetProcAddress(NETAPI32, 'NetAlertRaise');
|
4852 |
|
4853 |
if (@_NetAlertRaise <> nil) then begin
|
4854 |
A.Value := nil;
|
4855 |
try
|
4856 |
{ allocate the unicode alert event name }
|
4857 |
CvtToWideChar(AlertEventName, A);
|
4858 |
|
4859 |
{ call the API }
|
4860 |
Result := _NetAlertRaise(A.Value, Buffer, BufferSize);
|
4861 |
finally
|
4862 |
FreeMem(A.Value, A.Length);
|
4863 |
end;
|
4864 |
end else
|
4865 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4866 |
end else begin
|
4867 |
{ EStNetException }
|
4868 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4869 |
end;
|
4870 |
end;
|
4871 |
|
4872 |
function StNetAlertRaiseEx(AlertEventName: string; VariableInfo:
|
4873 |
Pointer; VariableInfoSize: DWord;
|
4874 |
ServiceName: string): NET_API_STATUS;
|
4875 |
var
|
4876 |
A, S : TLMWideChar;
|
4877 |
begin
|
4878 |
Result := 0;
|
4879 |
if IsNetApi32 then begin
|
4880 |
if (@_NetAlertRaiseEx = nil) then
|
4881 |
@_NetAlertRaiseEx := GetProcAddress(NETAPI32, 'NetAlertRaiseEx');
|
4882 |
|
4883 |
if (@_NetAlertRaiseEx <> nil) then begin
|
4884 |
A.Value := nil;
|
4885 |
S.Value := nil;
|
4886 |
try
|
4887 |
{ allocate the unicode alert event name }
|
4888 |
CvtToWideChar(AlertEventName, A);
|
4889 |
|
4890 |
{ allocate the unicode service name }
|
4891 |
CvtToWideChar(ServiceName, S);
|
4892 |
|
4893 |
{ call the API }
|
4894 |
Result := _NetAlertRaiseEx(A.Value, VariableInfo, VariableInfoSize, S.Value);
|
4895 |
finally
|
4896 |
FreeMem(A.Value, A.Length);
|
4897 |
FreeMem(S.Value, S.Length);
|
4898 |
end;
|
4899 |
end else
|
4900 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4901 |
end else begin
|
4902 |
{ EStNetException }
|
4903 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4904 |
end;
|
4905 |
end;
|
4906 |
|
4907 |
|
4908 |
function StNetShareAdd(ServerName: string; Level: DWORD; Buffer: Pointer;
|
4909 |
var ParmErr: DWORD): NET_API_STATUS;
|
4910 |
var
|
4911 |
S : TLMWideChar;
|
4912 |
begin
|
4913 |
Result := 0;
|
4914 |
if IsNetApi32 then begin
|
4915 |
if (@_NetShareAdd = nil) then
|
4916 |
@_NetShareAdd := GetProcAddress(NETAPI32, 'NetShareAdd');
|
4917 |
|
4918 |
if (@_NetShareAdd <> nil) then begin
|
4919 |
S.Value := nil;
|
4920 |
try
|
4921 |
{ allocate the unicode server name }
|
4922 |
CvtToWideChar(ServerName, S);
|
4923 |
|
4924 |
{ call the API }
|
4925 |
Result := _NetShareAdd(S.Value, Level, Buffer, ParmErr);
|
4926 |
finally
|
4927 |
FreeMem(S.Value, S.Length);
|
4928 |
end;
|
4929 |
end else
|
4930 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4931 |
end else begin
|
4932 |
{ EStNetException }
|
4933 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4934 |
end;
|
4935 |
end;
|
4936 |
|
4937 |
function StNetShareEnum(ServerName: string; Level: DWORD; var Buffer: Pointer;
|
4938 |
PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord;
|
4939 |
var ResumeHandle: DWord): NET_API_STATUS;
|
4940 |
var
|
4941 |
S : TLMWideChar;
|
4942 |
begin
|
4943 |
Result := 0;
|
4944 |
if IsNetApi32 then begin
|
4945 |
if (@_NetShareEnum = nil) then
|
4946 |
@_NetShareEnum := GetProcAddress(NETAPI32, 'NetShareEnum');
|
4947 |
|
4948 |
if (@_NetShareEnum <> nil) then begin
|
4949 |
S.Value := nil;
|
4950 |
try
|
4951 |
{ allocate the unicode server name }
|
4952 |
CvtToWideChar(ServerName, S);
|
4953 |
|
4954 |
{ call the API }
|
4955 |
Result := _NetShareEnum(S.Value, Level, Buffer, PrefMaxLen, EntriesRead,
|
4956 |
TotalEntries, ResumeHandle);
|
4957 |
finally
|
4958 |
FreeMem(S.Value, S.Length);
|
4959 |
end;
|
4960 |
end else
|
4961 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4962 |
end else begin
|
4963 |
{ EStNetException }
|
4964 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4965 |
end;
|
4966 |
end;
|
4967 |
|
4968 |
function StNetShareEnumSticky(ServerName: string; Level: DWORD;
|
4969 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
4970 |
var EntriesRead, TotalEntries,
|
4971 |
ResumeHandle: DWord): NET_API_STATUS;
|
4972 |
var
|
4973 |
S : TLMWideChar;
|
4974 |
begin
|
4975 |
Result := 0;
|
4976 |
if IsNetApi32 then begin
|
4977 |
if (@_NetShareEnumSticky = nil) then
|
4978 |
@_NetShareEnumSticky := GetProcAddress(NETAPI32, 'NetShareEnumSticky');
|
4979 |
|
4980 |
if (@_NetShareEnumSticky <> nil) then begin
|
4981 |
S.Value := nil;
|
4982 |
try
|
4983 |
{ allocate the unicode server name }
|
4984 |
CvtToWideChar(ServerName, S);
|
4985 |
|
4986 |
{ call the API }
|
4987 |
Result := _NetShareEnumSticky(S.Value, Level, Buffer, PrefMaxLen,
|
4988 |
EntriesRead, TotalEntries, ResumeHandle);
|
4989 |
finally
|
4990 |
FreeMem(S.Value, S.Length);
|
4991 |
end;
|
4992 |
end else
|
4993 |
RaiseStWin32Error(EStNetException, GetLastError);
|
4994 |
end else begin
|
4995 |
{ EStNetException }
|
4996 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
4997 |
end;
|
4998 |
end;
|
4999 |
|
5000 |
function StNetShareGetInfo(ServerName, NetName: string; Level: DWORD;
|
5001 |
var Buffer: Pointer): NET_API_STATUS;
|
5002 |
var
|
5003 |
S, N : TLMWideChar;
|
5004 |
begin
|
5005 |
Result := 0;
|
5006 |
if IsNetApi32 then begin
|
5007 |
if (@_NetShareGetInfo = nil) then
|
5008 |
@_NetShareGetInfo := GetProcAddress(NETAPI32, 'NetShareGetInfo');
|
5009 |
|
5010 |
if (@_NetShareGetInfo <> nil) then begin
|
5011 |
S.Value := nil;
|
5012 |
N.Value := nil;
|
5013 |
try
|
5014 |
{ allocate the unicode server name }
|
5015 |
CvtToWideChar(ServerName, S);
|
5016 |
|
5017 |
{ allocate the unicode net name }
|
5018 |
CvtToWideChar(NetName, N);
|
5019 |
|
5020 |
{ call the API }
|
5021 |
Result := _NetShareGetInfo(S.Value, N.Value, Level, Buffer);
|
5022 |
finally
|
5023 |
FreeMem(S.Value, S.Length);
|
5024 |
FreeMem(N.Value, N.Length);
|
5025 |
end;
|
5026 |
end else
|
5027 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5028 |
end else begin
|
5029 |
{ EStNetException }
|
5030 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5031 |
end;
|
5032 |
end;
|
5033 |
|
5034 |
function StNetShareSetInfo(ServerName, NetName: string; Level: DWORD;
|
5035 |
var Buffer: Pointer;
|
5036 |
var ParmErr: DWord): NET_API_STATUS;
|
5037 |
var
|
5038 |
S, N : TLMWideChar;
|
5039 |
begin
|
5040 |
Result := 0;
|
5041 |
if IsNetApi32 then begin
|
5042 |
if (@_NetShareSetInfo = nil) then
|
5043 |
@_NetShareSetInfo := GetProcAddress(NETAPI32, 'NetShareSetInfo');
|
5044 |
|
5045 |
if (@_NetShareSetInfo <> nil) then begin
|
5046 |
S.Value := nil;
|
5047 |
N.Value := nil;
|
5048 |
try
|
5049 |
{ allocate the unicode server name }
|
5050 |
CvtToWideChar(ServerName, S);
|
5051 |
|
5052 |
{ allocate the unicode net name }
|
5053 |
CvtToWideChar(NetName, N);
|
5054 |
|
5055 |
{ call the API }
|
5056 |
Result := _NetShareSetInfo(S.Value, N.Value, Level, Buffer, ParmErr);
|
5057 |
finally
|
5058 |
FreeMem(S.Value, S.Length);
|
5059 |
FreeMem(N.Value, N.Length);
|
5060 |
end;
|
5061 |
end else
|
5062 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5063 |
end else begin
|
5064 |
{ EStNetException }
|
5065 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5066 |
end;
|
5067 |
end;
|
5068 |
|
5069 |
function StNetShareDel(ServerName, NetName: string; Reserved: DWord): NET_API_STATUS;
|
5070 |
var
|
5071 |
S, N : TLMWideChar;
|
5072 |
begin
|
5073 |
Result := 0;
|
5074 |
if IsNetApi32 then begin
|
5075 |
if (@_NetShareDel = nil) then
|
5076 |
@_NetShareDel := GetProcAddress(NETAPI32, 'NetShareDel');
|
5077 |
|
5078 |
if (@_NetShareDel <> nil) then begin
|
5079 |
S.Value := nil;
|
5080 |
N.Value := nil;
|
5081 |
try
|
5082 |
{ allocate the unicode server name }
|
5083 |
CvtToWideChar(ServerName, S);
|
5084 |
|
5085 |
{ allocate the unicode net name }
|
5086 |
CvtToWideChar(NetName, N);
|
5087 |
|
5088 |
{ call the API }
|
5089 |
Result := _NetShareDel(S.Value, N.Value, Reserved)
|
5090 |
finally
|
5091 |
FreeMem(S.Value, S.Length);
|
5092 |
FreeMem(N.Value, N.Length);
|
5093 |
end;
|
5094 |
end else
|
5095 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5096 |
end else begin
|
5097 |
{ EStNetException }
|
5098 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5099 |
end;
|
5100 |
end;
|
5101 |
|
5102 |
function StNetShareDelSticky(ServerName, NetName: string; Reserved: DWord): NET_API_STATUS;
|
5103 |
var
|
5104 |
S, N : TLMWideChar;
|
5105 |
begin
|
5106 |
Result := 0;
|
5107 |
if IsNetApi32 then begin
|
5108 |
if (@_NetShareDelSticky = nil) then
|
5109 |
@_NetShareDelSticky := GetProcAddress(NETAPI32, 'NetShareDelSticky');
|
5110 |
|
5111 |
if (@_NetShareDelSticky <> nil) then begin
|
5112 |
S.Value := nil;
|
5113 |
N.Value := nil;
|
5114 |
try
|
5115 |
{ allocate the unicode server name }
|
5116 |
CvtToWideChar(ServerName, S);
|
5117 |
|
5118 |
{ allocate the unicode net name }
|
5119 |
CvtToWideChar(NetName, N);
|
5120 |
|
5121 |
{ call the API }
|
5122 |
Result := _NetShareDelSticky(S.Value, N.Value, Reserved);
|
5123 |
finally
|
5124 |
FreeMem(S.Value, S.Length);
|
5125 |
FreeMem(N.Value, N.Length);
|
5126 |
end;
|
5127 |
end else
|
5128 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5129 |
end else begin
|
5130 |
{ EStNetException }
|
5131 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5132 |
end;
|
5133 |
end;
|
5134 |
|
5135 |
function StNetShareCheck(ServerName, Device: string; var ShareType: DWord): NET_API_STATUS;
|
5136 |
var
|
5137 |
S, D : TLMWideChar;
|
5138 |
begin
|
5139 |
Result := 0;
|
5140 |
if IsNetApi32 then begin
|
5141 |
if (@_NetShareCheck = nil) then
|
5142 |
@_NetShareCheck := GetProcAddress(NETAPI32, 'NetShareCheck');
|
5143 |
|
5144 |
if (@_NetShareCheck <> nil) then begin
|
5145 |
S.Value := nil;
|
5146 |
D.Value := nil;
|
5147 |
try
|
5148 |
{ allocate the unicode server name }
|
5149 |
CvtToWideChar(ServerName, S);
|
5150 |
|
5151 |
{ allocate the unicode device name }
|
5152 |
CvtToWideChar(Device, D);
|
5153 |
|
5154 |
{ call the API }
|
5155 |
Result := _NetShareCheck(S.Value, D.Value, ShareType);
|
5156 |
finally
|
5157 |
FreeMem(S.Value, S.Length);
|
5158 |
FreeMem(D.Value, D.Length);
|
5159 |
end;
|
5160 |
end else
|
5161 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5162 |
end else begin
|
5163 |
{ EStNetException }
|
5164 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5165 |
end;
|
5166 |
end;
|
5167 |
|
5168 |
|
5169 |
function StNetSessionEnum(ServerName, UncClientName, UserName: string;
|
5170 |
Level: DWord; var Buffer: Pointer; PrefMaxLen: DWord;
|
5171 |
var EntriesRead, TotalEntries,
|
5172 |
ResumeHandle: DWord): NET_API_STATUS;
|
5173 |
var
|
5174 |
S, C, U : TLMWideChar;
|
5175 |
begin
|
5176 |
Result := 0;
|
5177 |
if IsNetApi32 then begin
|
5178 |
if (@_NetSessionEnum = nil) then
|
5179 |
@_NetSessionEnum := GetProcAddress(NETAPI32, 'NetSessionEnum');
|
5180 |
|
5181 |
if (@_NetSessionEnum <> nil) then begin
|
5182 |
S.Value := nil;
|
5183 |
C.Value := nil;
|
5184 |
U.Value := nil;
|
5185 |
try
|
5186 |
{ allocate the unicode server name }
|
5187 |
CvtToWideChar(ServerName, S);
|
5188 |
|
5189 |
{ allocate the unicode UNC client name }
|
5190 |
CvtToWideChar(UncClientName, C);
|
5191 |
|
5192 |
{ allocate the unicode user name }
|
5193 |
CvtToWideChar(UserName, U);
|
5194 |
|
5195 |
{ call the API }
|
5196 |
Result := _NetSessionEnum(S.Value, C.Value, U.Value, Level, Buffer,
|
5197 |
PrefMaxLen, EntriesRead, TotalEntries,
|
5198 |
ResumeHandle);
|
5199 |
finally
|
5200 |
FreeMem(S.Value, S.Length);
|
5201 |
FreeMem(C.Value, C.Length);
|
5202 |
FreeMem(U.Value, U.Length);
|
5203 |
end;
|
5204 |
end else
|
5205 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5206 |
end else begin
|
5207 |
{ EStNetException }
|
5208 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5209 |
end;
|
5210 |
end;
|
5211 |
|
5212 |
function StNetSessionDel(ServerName, UncClientName, UserName: string): NET_API_STATUS;
|
5213 |
var
|
5214 |
S, C, U : TLMWideChar;
|
5215 |
begin
|
5216 |
Result := 0;
|
5217 |
if IsNetApi32 then begin
|
5218 |
if (@_NetSessionDel = nil) then
|
5219 |
@_NetSessionDel := GetProcAddress(NETAPI32, 'NetSessionDel');
|
5220 |
|
5221 |
if (@_NetSessionDel <> nil) then begin
|
5222 |
S.Value := nil;
|
5223 |
C.Value := nil;
|
5224 |
U.Value := nil;
|
5225 |
try
|
5226 |
{ allocate the unicode server name }
|
5227 |
CvtToWideChar(ServerName, S);
|
5228 |
|
5229 |
{ allocate the unicode UNC client name }
|
5230 |
CvtToWideChar(UncClientName, C);
|
5231 |
|
5232 |
{ allocate the unicode user name }
|
5233 |
CvtToWideChar(UserName, U);
|
5234 |
|
5235 |
{ call the API }
|
5236 |
Result := _NetSessionDel(S.Value, C.Value, U.Value);
|
5237 |
finally
|
5238 |
FreeMem(S.Value, S.Length);
|
5239 |
FreeMem(C.Value, C.Length);
|
5240 |
FreeMem(U.Value, U.Length);
|
5241 |
end;
|
5242 |
end else
|
5243 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5244 |
end else begin
|
5245 |
{ EStNetException }
|
5246 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5247 |
end;
|
5248 |
end;
|
5249 |
|
5250 |
function StNetSessionGetInfo(ServerName, UncClientName, UserName: string;
|
5251 |
Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
5252 |
var
|
5253 |
S, C, U : TLMWideChar;
|
5254 |
begin
|
5255 |
Result := 0;
|
5256 |
if IsNetApi32 then begin
|
5257 |
if (@_NetSessionGetInfo = nil) then
|
5258 |
@_NetSessionGetInfo := GetProcAddress(NETAPI32, 'NetSessionGetInfo');
|
5259 |
|
5260 |
if (@_NetSessionGetInfo <> nil) then begin
|
5261 |
S.Value := nil;
|
5262 |
C.Value := nil;
|
5263 |
U.Value := nil;
|
5264 |
try
|
5265 |
{ allocate the unicode server name }
|
5266 |
CvtToWideChar(ServerName, S);
|
5267 |
|
5268 |
{ allocate the unicode UNC client name }
|
5269 |
CvtToWideChar(UncClientName, C);
|
5270 |
|
5271 |
{ allocate the unicode user name }
|
5272 |
CvtToWideChar(UserName, U);
|
5273 |
|
5274 |
{ call the API }
|
5275 |
Result := _NetSessionGetInfo(S.Value, C.Value, U.Value, Level, Buffer);
|
5276 |
finally
|
5277 |
FreeMem(S.Value, S.Length);
|
5278 |
FreeMem(C.Value, C.Length);
|
5279 |
FreeMem(U.Value, U.Length);
|
5280 |
end;
|
5281 |
end else
|
5282 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5283 |
end else begin
|
5284 |
{ EStNetException }
|
5285 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5286 |
end;
|
5287 |
end;
|
5288 |
|
5289 |
|
5290 |
function StNetConnectionEnum(ServerName, Qualifier: string; Level: DWord;
|
5291 |
var Buffer : Pointer; PrefMaxLen : DWord;
|
5292 |
var EntriesRead, TotalEntries,
|
5293 |
ResumeHandle: DWord): NET_API_STATUS;
|
5294 |
var
|
5295 |
S, Q : TLMWideChar;
|
5296 |
begin
|
5297 |
Result := 0;
|
5298 |
if IsNetApi32 then begin
|
5299 |
if (@_NetConnectionEnum = nil) then
|
5300 |
@_NetConnectionEnum := GetProcAddress(NETAPI32, 'NetConnectionEnum');
|
5301 |
|
5302 |
if (@_NetConnectionEnum <> nil) then begin
|
5303 |
S.Value := nil;
|
5304 |
Q.Value := nil;
|
5305 |
try
|
5306 |
{ allocate the unicode server name }
|
5307 |
CvtToWideChar(ServerName, S);
|
5308 |
|
5309 |
{ allocate the unicode qualifier }
|
5310 |
CvtToWideChar(Qualifier, Q);
|
5311 |
|
5312 |
{ call the API }
|
5313 |
Result := _NetConnectionEnum(S.Value, Q.Value, Level, Buffer, PrefMaxLen,
|
5314 |
EntriesRead, TotalEntries, ResumeHandle);
|
5315 |
finally
|
5316 |
FreeMem(S.Value, S.Length);
|
5317 |
FreeMem(Q.Value, Q.Length);
|
5318 |
end;
|
5319 |
end else
|
5320 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5321 |
end else begin
|
5322 |
{ EStNetException }
|
5323 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5324 |
end;
|
5325 |
end;
|
5326 |
|
5327 |
|
5328 |
function StNetFileClose(ServerName: string; FileID: DWord): NET_API_STATUS;
|
5329 |
var
|
5330 |
S : TLMWideChar;
|
5331 |
begin
|
5332 |
Result := 0;
|
5333 |
if IsNetApi32 then begin
|
5334 |
if (@_NetFileClose = nil) then
|
5335 |
@_NetFileClose := GetProcAddress(NETAPI32, 'NetFileClose');
|
5336 |
|
5337 |
if (@_NetFileClose <> nil) then begin
|
5338 |
S.Value := nil;
|
5339 |
try
|
5340 |
{ allocate the unicode server name }
|
5341 |
CvtToWideChar(ServerName, S);
|
5342 |
|
5343 |
{ call the API }
|
5344 |
Result := _NetFileClose(S.Value, FileID);
|
5345 |
finally
|
5346 |
FreeMem(S.Value, S.Length);
|
5347 |
end;
|
5348 |
end else
|
5349 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5350 |
end else begin
|
5351 |
{ EStNetException }
|
5352 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5353 |
end;
|
5354 |
end;
|
5355 |
|
5356 |
function StNetFileEnum(ServerName, BasePath, UserName: string; Level: DWord;
|
5357 |
var Buffer: Pointer; PrefMexLen: DWord; var EntriesRead,
|
5358 |
TotalEntries, ResumeHandle: DWord): NET_API_STATUS;
|
5359 |
var
|
5360 |
S, B, U : TLMWideChar;
|
5361 |
begin
|
5362 |
Result := 0;
|
5363 |
if IsNetApi32 then begin
|
5364 |
if (@_NetFileEnum = nil) then
|
5365 |
@_NetFileEnum := GetProcAddress(NETAPI32, 'NetFileEnum');
|
5366 |
|
5367 |
if (@_NetFileEnum <> nil) then begin
|
5368 |
S.Value := nil;
|
5369 |
B.Value := nil;
|
5370 |
U.Value := nil;
|
5371 |
try
|
5372 |
{ allocate the unicode server name }
|
5373 |
CvtToWideChar(ServerName, S);
|
5374 |
|
5375 |
{ allocate the unicode base path }
|
5376 |
CvtToWideChar(BasePath, B);
|
5377 |
|
5378 |
{ allocate the unicode user name }
|
5379 |
CvtToWideChar(UserName, U);
|
5380 |
|
5381 |
{ call the API }
|
5382 |
Result := _NetFileEnum(S.Value, B.Value, U.Value, Level, Buffer,
|
5383 |
PrefMexLen, EntriesRead, TotalEntries, ResumeHandle);
|
5384 |
finally
|
5385 |
FreeMem(S.Value, S.Length);
|
5386 |
FreeMem(B.Value, B.Length);
|
5387 |
FreeMem(U.Value, U.Length);
|
5388 |
end;
|
5389 |
end else
|
5390 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5391 |
end else begin
|
5392 |
{ EStNetException }
|
5393 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5394 |
end;
|
5395 |
end;
|
5396 |
|
5397 |
function StNetFileGetInfo(ServerName: string; FileID, Level: DWord;
|
5398 |
var Buffer: Pointer): NET_API_STATUS;
|
5399 |
var
|
5400 |
S : TLMWideChar;
|
5401 |
begin
|
5402 |
Result := 0;
|
5403 |
if IsNetApi32 then begin
|
5404 |
if (@_NetFileGetInfo = nil) then
|
5405 |
@_NetFileGetInfo := GetProcAddress(NETAPI32, 'NetFileGetInfo');
|
5406 |
|
5407 |
if (@_NetFileGetInfo <> nil) then begin
|
5408 |
S.Value := nil;
|
5409 |
try
|
5410 |
{ allocate the unicode server name }
|
5411 |
CvtToWideChar(ServerName, S);
|
5412 |
|
5413 |
{ call the API }
|
5414 |
Result := _NetFileGetInfo(S.Value, FileID, Level, Buffer);
|
5415 |
finally
|
5416 |
FreeMem(S.Value, S.Length);
|
5417 |
end;
|
5418 |
end else
|
5419 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5420 |
end else begin
|
5421 |
{ EStNetException }
|
5422 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5423 |
end;
|
5424 |
end;
|
5425 |
|
5426 |
|
5427 |
{LMMSG}
|
5428 |
function StNetMessageNameAdd(ServerName, MsgName: string): NET_API_STATUS;
|
5429 |
var
|
5430 |
S, M : TLMWideChar;
|
5431 |
begin
|
5432 |
Result := 0;
|
5433 |
if IsNetApi32 then begin
|
5434 |
if (@_NetMessageNameAdd = nil) then
|
5435 |
@_NetMessageNameAdd := GetProcAddress(NETAPI32, 'NetMessageNameAdd');
|
5436 |
|
5437 |
if (@_NetMessageNameAdd <> nil) then begin
|
5438 |
S.Value := nil;
|
5439 |
M.Value := nil;
|
5440 |
try
|
5441 |
{ allocate the unicode server name }
|
5442 |
CvtToWideChar(ServerName, S);
|
5443 |
|
5444 |
{ allocate the unicode message name }
|
5445 |
CvtToWideChar(MsgName, M);
|
5446 |
|
5447 |
{ call the API }
|
5448 |
Result := _NetMessageNameAdd(S.Value, M.Value);
|
5449 |
finally
|
5450 |
FreeMem(S.Value, S.Length);
|
5451 |
FreeMem(M.Value, M.Length);
|
5452 |
end;
|
5453 |
end else
|
5454 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5455 |
end else begin
|
5456 |
{ EStNetException }
|
5457 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5458 |
end;
|
5459 |
end;
|
5460 |
|
5461 |
function StNetMessageNameEnum(ServerName: string; Level: DWord; var Buffer:
|
5462 |
Pointer; PrefMaxLen: DWord; var EntriesRead,
|
5463 |
TotalEntries: DWord;
|
5464 |
ResumeHandle: PDWord): NET_API_STATUS;
|
5465 |
var
|
5466 |
S : TLMWideChar;
|
5467 |
begin
|
5468 |
Result := 0;
|
5469 |
if IsNetApi32 then begin
|
5470 |
if (@_NetMessageNameEnum = nil) then
|
5471 |
@_NetMessageNameEnum := GetProcAddress(NETAPI32, 'NetMessageNameEnum');
|
5472 |
|
5473 |
if (@_NetMessageNameEnum <> nil) then begin
|
5474 |
S.Value := nil;
|
5475 |
try
|
5476 |
{ allocate the unicode server name }
|
5477 |
CvtToWideChar(ServerName, S);
|
5478 |
|
5479 |
{ call the API }
|
5480 |
Result := _NetMessageNameEnum(S.Value, Level, Buffer, PrefMaxLen,
|
5481 |
EntriesRead, TotalEntries, ResumeHandle);
|
5482 |
finally
|
5483 |
FreeMem(S.Value, S.Length);
|
5484 |
end;
|
5485 |
end else
|
5486 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5487 |
end else begin
|
5488 |
{ EStNetException }
|
5489 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5490 |
end;
|
5491 |
end;
|
5492 |
|
5493 |
function StNetMessageNameGetInfo(ServerName, MsgName: string; Level: DWord;
|
5494 |
var Buffer: Pointer): NET_API_STATUS;
|
5495 |
var
|
5496 |
S, M : TLMWideChar;
|
5497 |
begin
|
5498 |
Result := 0;
|
5499 |
if IsNetApi32 then begin
|
5500 |
if (@_NetMessageNameGetInfo = nil) then
|
5501 |
@_NetMessageNameGetInfo := GetProcAddress(NETAPI32, 'NetMessageNameGetInfo');
|
5502 |
|
5503 |
if (@_NetMessageNameGetInfo <> nil) then begin
|
5504 |
S.Value := nil;
|
5505 |
M.Value := nil;
|
5506 |
try
|
5507 |
{ allocate the unicode server name }
|
5508 |
CvtToWideChar(ServerName, S);
|
5509 |
|
5510 |
{ allocate the unicode message name }
|
5511 |
CvtToWideChar(MsgName, M);
|
5512 |
|
5513 |
{ call the API }
|
5514 |
Result := _NetMessageNameGetInfo(S.Value, M.Value, Level, Buffer);
|
5515 |
finally
|
5516 |
FreeMem(S.Value, S.Length);
|
5517 |
FreeMem(M.Value, M.Length);
|
5518 |
end;
|
5519 |
end else
|
5520 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5521 |
end else begin
|
5522 |
{ EStNetException }
|
5523 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5524 |
end;
|
5525 |
end;
|
5526 |
|
5527 |
function StNetMessageNameDel(ServerName, MsgName: string): NET_API_STATUS;
|
5528 |
var
|
5529 |
S, M : TLMWideChar;
|
5530 |
begin
|
5531 |
Result := 0;
|
5532 |
if IsNetApi32 then begin
|
5533 |
if (@_NetMessageNameDel = nil) then
|
5534 |
@_NetMessageNameDel := GetProcAddress(NETAPI32, 'NetMessageNameDel');
|
5535 |
|
5536 |
if (@_NetMessageNameDel <> nil) then begin
|
5537 |
S.Value := nil;
|
5538 |
M.Value := nil;
|
5539 |
try
|
5540 |
{ allocate the unicode server name }
|
5541 |
CvtToWideChar(ServerName, S);
|
5542 |
|
5543 |
{ allocate the unicode message name }
|
5544 |
CvtToWideChar(MsgName, M);
|
5545 |
|
5546 |
{ call the API }
|
5547 |
Result := _NetMessageNameDel(S.Value, M.Value);
|
5548 |
finally
|
5549 |
FreeMem(S.Value, S.Length);
|
5550 |
FreeMem(M.Value, M.Length);
|
5551 |
end;
|
5552 |
end else
|
5553 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5554 |
end else begin
|
5555 |
{ EStNetException }
|
5556 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5557 |
end;
|
5558 |
end;
|
5559 |
|
5560 |
function StNetMessageBufferSend(ServerName, MsgName, FromName: string;
|
5561 |
Buffer: Pointer; BufferLen: DWord): NET_API_STATUS;
|
5562 |
var
|
5563 |
S, M, F : TLMWideChar;
|
5564 |
begin
|
5565 |
Result := 0;
|
5566 |
if IsNetApi32 then begin
|
5567 |
if (@_NetMessageBufferSend = nil) then
|
5568 |
@_NetMessageBufferSend := GetProcAddress(NETAPI32, 'NetMessageBufferSend');
|
5569 |
|
5570 |
if (@_NetMessageBufferSend <> nil) then begin
|
5571 |
S.Value := nil;
|
5572 |
M.Value := nil;
|
5573 |
F.Value := nil;
|
5574 |
try
|
5575 |
{ allocate the unicode server name }
|
5576 |
CvtToWideChar(ServerName, S);
|
5577 |
|
5578 |
{ allocate the unicode message name }
|
5579 |
CvtToWideChar(MsgName, M);
|
5580 |
|
5581 |
{ allocate the unicode from name }
|
5582 |
CvtToWideChar(FromName, F);
|
5583 |
|
5584 |
{ call the API }
|
5585 |
Result := _NetMessageBufferSend(S.Value, M.Value, F.Value, Buffer, BufferLen);
|
5586 |
finally
|
5587 |
FreeMem(S.Value, S.Length);
|
5588 |
FreeMem(M.Value, M.Length);
|
5589 |
FreeMem(F.Value, F.Length);
|
5590 |
end;
|
5591 |
end else
|
5592 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5593 |
end else begin
|
5594 |
{ EStNetException }
|
5595 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5596 |
end;
|
5597 |
end;
|
5598 |
|
5599 |
|
5600 |
{LMREMUTL}
|
5601 |
function StNetRemoteTOD(UncServerName: string; var Buffer: Pointer): NET_API_STATUS;
|
5602 |
var
|
5603 |
U : TLMWideChar;
|
5604 |
begin
|
5605 |
Result := 0;
|
5606 |
if IsNetApi32 then begin
|
5607 |
if (@_NetRemoteTOD = nil) then
|
5608 |
@_NetRemoteTOD := GetProcAddress(NETAPI32, 'NetRemoteTOD');
|
5609 |
|
5610 |
if (@_NetRemoteTOD <> nil) then begin
|
5611 |
U.Value := nil;
|
5612 |
try
|
5613 |
{ allocate the unicode server name }
|
5614 |
CvtToWideChar(UncServerName, U);
|
5615 |
|
5616 |
{ call the API }
|
5617 |
Result := _NetRemoteTOD(U.Value, Buffer);
|
5618 |
finally
|
5619 |
FreeMem(U.Value, U.Length);
|
5620 |
end;
|
5621 |
end else
|
5622 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5623 |
end else begin
|
5624 |
{ EStNetException }
|
5625 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5626 |
end;
|
5627 |
end;
|
5628 |
|
5629 |
function StNetRemoteComputerSupports(UncServerName: string; OptionsWanted: DWord;
|
5630 |
var OptionsSupported: DWord): NET_API_STATUS;
|
5631 |
var
|
5632 |
U : TLMWideChar;
|
5633 |
begin
|
5634 |
Result := 0;
|
5635 |
if IsNetApi32 then begin
|
5636 |
if (@_NetRemoteComputerSupports = nil) then
|
5637 |
@_NetRemoteComputerSupports := GetProcAddress(NETAPI32, 'NetRemoteComputerSupports');
|
5638 |
|
5639 |
if (@_NetRemoteComputerSupports <> nil) then begin
|
5640 |
U.Value := nil;
|
5641 |
try
|
5642 |
{ allocate the unicode server name }
|
5643 |
CvtToWideChar(UncServerName, U);
|
5644 |
|
5645 |
{ call the API }
|
5646 |
Result := _NetRemoteComputerSupports(U.Value, OptionsWanted, OptionsSupported);
|
5647 |
finally
|
5648 |
FreeMem(U.Value, U.Length);
|
5649 |
end;
|
5650 |
end else
|
5651 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5652 |
end else begin
|
5653 |
{ EStNetException }
|
5654 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5655 |
end;
|
5656 |
end;
|
5657 |
|
5658 |
|
5659 |
{LMSERVER}
|
5660 |
function StNetServerEnum(ServerName: string; Level: DWord; var Buffer: Pointer;
|
5661 |
PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord;
|
5662 |
ServerType: DWord; Domain: string;
|
5663 |
var ResumeHandle: DWord): NET_API_STATUS;
|
5664 |
var
|
5665 |
S, D : TLMWideChar;
|
5666 |
begin
|
5667 |
Result := 0;
|
5668 |
if IsNetApi32 then begin
|
5669 |
if (@_NetServerEnum = nil) then
|
5670 |
@_NetServerEnum := GetProcAddress(NETAPI32, 'NetServerEnum');
|
5671 |
|
5672 |
if (@_NetServerEnum <> nil) then begin
|
5673 |
S.Value := nil;
|
5674 |
D.Value := nil;
|
5675 |
try
|
5676 |
{ allocate the unicode server name }
|
5677 |
CvtToWideChar(ServerName, S);
|
5678 |
|
5679 |
{ allocate the unicode domain name }
|
5680 |
CvtToWideChar(Domain, D);
|
5681 |
|
5682 |
{ call the API }
|
5683 |
Result := _NetServerEnum(S.Value, Level, Buffer, PrefMaxLen, EntriesRead,
|
5684 |
TotalEntries, ServerType, D.Value, ResumeHandle);
|
5685 |
finally
|
5686 |
FreeMem(S.Value, S.Length);
|
5687 |
FreeMem(D.Value, D.Length);
|
5688 |
end;
|
5689 |
end else
|
5690 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5691 |
end else begin
|
5692 |
{ EStNetException }
|
5693 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5694 |
end;
|
5695 |
end;
|
5696 |
|
5697 |
function StNetServerEnumEx(ServerName: string; Level: DWord; var Buffer: Pointer;
|
5698 |
PrefMaxLen: DWord; var EntriesRead, TotalEntries: DWord;
|
5699 |
ServerType: DWord; Domain,
|
5700 |
FirstNameToReturn : string): NET_API_STATUS;
|
5701 |
var
|
5702 |
S, D, F : TLMWideChar;
|
5703 |
begin
|
5704 |
Result := 0;
|
5705 |
if IsNetApi32 then begin
|
5706 |
if (@_NetServerEnumEx = nil) then
|
5707 |
@_NetServerEnumEx := GetProcAddress(NETAPI32, 'NetServerEnumEx');
|
5708 |
|
5709 |
if (@_NetServerEnumEx <> nil) then begin
|
5710 |
S.Value := nil;
|
5711 |
D.Value := nil;
|
5712 |
F.Value := nil;
|
5713 |
try
|
5714 |
{ allocate the unicode server name }
|
5715 |
CvtToWideChar(ServerName, S);
|
5716 |
|
5717 |
{ allocate the unicode domain name }
|
5718 |
CvtToWideChar(Domain, D);
|
5719 |
|
5720 |
{ allocate the unicode first name to return }
|
5721 |
CvtToWideChar(FirstNameToReturn, F);
|
5722 |
|
5723 |
{ call the API }
|
5724 |
Result := _NetServerEnumEx(S.Value, Level, Buffer, PrefMaxLen,
|
5725 |
EntriesRead, TotalEntries, ServerType,
|
5726 |
D.Value, F.Value);
|
5727 |
finally
|
5728 |
FreeMem(S.Value, S.Length);
|
5729 |
FreeMem(D.Value, D.Length);
|
5730 |
FreeMem(F.Value, F.Length);
|
5731 |
end;
|
5732 |
end else
|
5733 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5734 |
end else begin
|
5735 |
{ EStNetException }
|
5736 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5737 |
end;
|
5738 |
end;
|
5739 |
|
5740 |
function StNetServerGetInfo(ServerName: string; Level: DWord;
|
5741 |
var Buffer: Pointer): NET_API_STATUS;
|
5742 |
var
|
5743 |
S : TLMWideChar;
|
5744 |
begin
|
5745 |
Result := 0;
|
5746 |
if IsNetApi32 then begin
|
5747 |
if (@_NetServerGetInfo = nil) then
|
5748 |
@_NetServerGetInfo := GetProcAddress(NETAPI32, 'NetServerGetInfo');
|
5749 |
|
5750 |
if (@_NetServerGetInfo <> nil) then begin
|
5751 |
S.Value := nil;
|
5752 |
try
|
5753 |
{ allocate the unicode server name }
|
5754 |
CvtToWideChar(ServerName, S);
|
5755 |
|
5756 |
{ call the API }
|
5757 |
Result := _NetServerGetInfo(S.Value, Level, Buffer);
|
5758 |
finally
|
5759 |
FreeMem(S.Value, S.Length);
|
5760 |
end;
|
5761 |
end else
|
5762 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5763 |
end else begin
|
5764 |
{ EStNetException }
|
5765 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5766 |
end;
|
5767 |
end;
|
5768 |
|
5769 |
function StNetServerSetInfo(ServerName: string; Level: DWord; Buffer: Pointer;
|
5770 |
var ParmErr: DWord): NET_API_STATUS;
|
5771 |
var
|
5772 |
S : TLMWideChar;
|
5773 |
begin
|
5774 |
Result := 0;
|
5775 |
if IsNetApi32 then begin
|
5776 |
if (@_NetServerSetInfo = nil) then
|
5777 |
@_NetServerSetInfo := GetProcAddress(NETAPI32, 'NetServerSetInfo');
|
5778 |
|
5779 |
if (@_NetServerSetInfo <> nil) then begin
|
5780 |
S.Value := nil;
|
5781 |
try
|
5782 |
{ allocate the unicode server name }
|
5783 |
CvtToWideChar(ServerName, S);
|
5784 |
|
5785 |
{ call the API }
|
5786 |
Result := _NetServerSetInfo(S.Value, Level, Buffer, ParmErr);
|
5787 |
finally
|
5788 |
FreeMem(S.Value, S.Length);
|
5789 |
end;
|
5790 |
end else
|
5791 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5792 |
end else begin
|
5793 |
{ EStNetException }
|
5794 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5795 |
end;
|
5796 |
end;
|
5797 |
|
5798 |
function StNetServerDiskEnum(ServerName: string; Level: DWord;
|
5799 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
5800 |
var EntriesRead, TotalEntries,
|
5801 |
ResumeHandle: DWord): NET_API_STATUS;
|
5802 |
var
|
5803 |
S : TLMWideChar;
|
5804 |
begin
|
5805 |
Result := 0;
|
5806 |
if IsNetApi32 then begin
|
5807 |
if (@_NetServerDiskEnum = nil) then
|
5808 |
@_NetServerDiskEnum := GetProcAddress(NETAPI32, 'NetServerDiskEnum');
|
5809 |
|
5810 |
if (@_NetServerDiskEnum <> nil) then begin
|
5811 |
S.Value := nil;
|
5812 |
try
|
5813 |
{ allocate the unicode server name }
|
5814 |
CvtToWideChar(ServerName, S);
|
5815 |
|
5816 |
{ call the API }
|
5817 |
Result := _NetServerDiskEnum(S.Value, Level, Buffer, PrefMaxLen,
|
5818 |
EntriesRead, TotalEntries, ResumeHandle);
|
5819 |
finally
|
5820 |
FreeMem(S.Value, S.Length);
|
5821 |
end;
|
5822 |
end else
|
5823 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5824 |
end else begin
|
5825 |
{ EStNetException }
|
5826 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5827 |
end;
|
5828 |
end;
|
5829 |
|
5830 |
function StNetServerComputerNameAdd(ServerName, EmulatedDomainName,
|
5831 |
EmulatedServerName: string): NET_API_STATUS;
|
5832 |
var
|
5833 |
S, D, E : TLMWideChar;
|
5834 |
begin
|
5835 |
Result := 0;
|
5836 |
if IsNetApi32 then begin
|
5837 |
if (@_NetServerComputerNameAdd = nil) then
|
5838 |
@_NetServerComputerNameAdd := GetProcAddress(NETAPI32, 'NetServerComputerNameAdd');
|
5839 |
|
5840 |
if (@_NetServerComputerNameAdd <> nil) then begin
|
5841 |
S.Value := nil;
|
5842 |
D.Value := nil;
|
5843 |
E.Value := nil;
|
5844 |
try
|
5845 |
{ allocate the unicode server name }
|
5846 |
CvtToWideChar(ServerName, S);
|
5847 |
|
5848 |
{ allocate the unicode domain name }
|
5849 |
CvtToWideChar(EmulatedDomainName, D);
|
5850 |
|
5851 |
{ allocate the unicode emulated server name }
|
5852 |
CvtToWideChar(EmulatedServerName, E);
|
5853 |
|
5854 |
{ call the API }
|
5855 |
Result := _NetServerComputerNameAdd(S.Value, D.Value, E.Value);
|
5856 |
finally
|
5857 |
FreeMem(S.Value, S.Length);
|
5858 |
FreeMem(D.Value, D.Length);
|
5859 |
FreeMem(E.Value, E.Length);
|
5860 |
end;
|
5861 |
end else
|
5862 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5863 |
end else begin
|
5864 |
{ EStNetException }
|
5865 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5866 |
end;
|
5867 |
end;
|
5868 |
|
5869 |
function StNetServerComputerNameDel(ServerName, EmulatedServerName: string): NET_API_STATUS;
|
5870 |
var
|
5871 |
S, E : TLMWideChar;
|
5872 |
begin
|
5873 |
Result := 0;
|
5874 |
if IsNetApi32 then begin
|
5875 |
if (@_NetServerComputerNameDel = nil) then
|
5876 |
@_NetServerComputerNameDel := GetProcAddress(NETAPI32, 'NetServerComputerNameDel');
|
5877 |
|
5878 |
if (@_NetServerComputerNameDel <> nil) then begin
|
5879 |
S.Value := nil;
|
5880 |
E.Value := nil;
|
5881 |
try
|
5882 |
{ allocate the unicode server name }
|
5883 |
CvtToWideChar(ServerName, S);
|
5884 |
|
5885 |
{ allocate the unicode emulated server name }
|
5886 |
CvtToWideChar(EmulatedServerName, E);
|
5887 |
|
5888 |
{ call the API }
|
5889 |
Result := _NetServerComputerNameDel(S.Value, E.Value);
|
5890 |
finally
|
5891 |
FreeMem(S.Value, S.Length);
|
5892 |
FreeMem(E.Value, E.Length);
|
5893 |
end;
|
5894 |
end else
|
5895 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5896 |
end else begin
|
5897 |
{ EStNetException }
|
5898 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5899 |
end;
|
5900 |
end;
|
5901 |
|
5902 |
function StNetServerTransportAdd(ServerName: string; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
5903 |
var
|
5904 |
S : TLMWideChar;
|
5905 |
begin
|
5906 |
Result := 0;
|
5907 |
if IsNetApi32 then begin
|
5908 |
if (@_NetServerTransportAdd = nil) then
|
5909 |
@_NetServerTransportAdd := GetProcAddress(NETAPI32, 'NetServerTransportAdd');
|
5910 |
|
5911 |
if (@_NetServerTransportAdd <> nil) then begin
|
5912 |
S.Value := nil;
|
5913 |
try
|
5914 |
{ allocate the unicode server name }
|
5915 |
CvtToWideChar(ServerName, S);
|
5916 |
|
5917 |
{ call the API }
|
5918 |
Result := _NetServerTransportAdd(S.Value, Level, Buffer);
|
5919 |
finally
|
5920 |
FreeMem(S.Value, S.Length);
|
5921 |
end;
|
5922 |
end else
|
5923 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5924 |
end else begin
|
5925 |
{ EStNetException }
|
5926 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5927 |
end;
|
5928 |
end;
|
5929 |
|
5930 |
function StNetServerTransportAddEx(ServerName: WideString; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
5931 |
begin
|
5932 |
Result := 0;
|
5933 |
if IsNetApi32 then begin
|
5934 |
if (@_NetServerTransportAddEx = nil) then
|
5935 |
@_NetServerTransportAddEx := GetProcAddress(NETAPI32, 'NetServerTransportAddEx');
|
5936 |
|
5937 |
if (@_NetServerTransportAddEx <> nil) then begin
|
5938 |
try
|
5939 |
Result := _NetServerTransportAddEx(PWideChar(ServerName), Level, Buffer);
|
5940 |
finally
|
5941 |
end;
|
5942 |
end else
|
5943 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5944 |
end else begin
|
5945 |
{ EStNetException }
|
5946 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5947 |
end;
|
5948 |
end;
|
5949 |
|
5950 |
function StNetServerTransportDel(ServerName: string; Level: DWord; Buffer: Pointer): NET_API_STATUS;
|
5951 |
var
|
5952 |
S : TLMWideChar;
|
5953 |
begin
|
5954 |
Result := 0;
|
5955 |
if IsNetApi32 then begin
|
5956 |
if (@_NetServerTransportDel = nil) then
|
5957 |
@_NetServerTransportDel := GetProcAddress(NETAPI32, 'NetServerTransportDel');
|
5958 |
|
5959 |
if (@_NetServerTransportDel <> nil) then begin
|
5960 |
S.Value := nil;
|
5961 |
try
|
5962 |
{ allocate the unicode server name }
|
5963 |
CvtToWideChar(ServerName, S);
|
5964 |
|
5965 |
{ call the API }
|
5966 |
Result := _NetServerTransportDel(S.Value, Level, Buffer);
|
5967 |
finally
|
5968 |
FreeMem(S.Value, S.Length);
|
5969 |
end;
|
5970 |
end else
|
5971 |
RaiseStWin32Error(EStNetException, GetLastError);
|
5972 |
end else begin
|
5973 |
{ EStNetException }
|
5974 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
5975 |
end;
|
5976 |
end;
|
5977 |
|
5978 |
function StNetServerTransportEnum(ServerName: string; Level: DWord;
|
5979 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
5980 |
var EntriesRead, TotalEntries,
|
5981 |
ResumeHandle: DWord): NET_API_STATUS;
|
5982 |
var
|
5983 |
S : TLMWideChar;
|
5984 |
begin
|
5985 |
Result := 0;
|
5986 |
if IsNetApi32 then begin
|
5987 |
if (@_NetServerTransportEnum = nil) then
|
5988 |
@_NetServerTransportEnum := GetProcAddress(NETAPI32, 'NetServerTransportEnum');
|
5989 |
|
5990 |
if (@_NetServerTransportEnum <> nil) then begin
|
5991 |
S.Value := nil;
|
5992 |
try
|
5993 |
{ allocate the unicode server name }
|
5994 |
CvtToWideChar(ServerName, S);
|
5995 |
|
5996 |
{ call the API }
|
5997 |
Result := _NetServerTransportEnum(S.Value, Level, Buffer, PrefMaxLen,
|
5998 |
EntriesRead, TotalEntries, ResumeHandle);
|
5999 |
finally
|
6000 |
FreeMem(S.Value, S.Length);
|
6001 |
end;
|
6002 |
end else
|
6003 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6004 |
end else begin
|
6005 |
{ EStNetException }
|
6006 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6007 |
end;
|
6008 |
end;
|
6009 |
|
6010 |
|
6011 |
{LMUSE}
|
6012 |
function StNetUseAdd(UncServerName: string; Level: DWord; Buffer: Pointer;
|
6013 |
var ParmErr: DWord): NET_API_STATUS;
|
6014 |
var
|
6015 |
U : TLMWideChar;
|
6016 |
begin
|
6017 |
Result := 0;
|
6018 |
if IsNetApi32 then begin
|
6019 |
if (@_NetUseAdd = nil) then
|
6020 |
@_NetUseAdd := GetProcAddress(NETAPI32, 'NetUseAdd');
|
6021 |
|
6022 |
if (@_NetUseAdd <> nil) then begin
|
6023 |
U.Value := nil;
|
6024 |
try
|
6025 |
{ allocate the unicode server name }
|
6026 |
CvtToWideChar(UncServerName, U);
|
6027 |
|
6028 |
{ call the API }
|
6029 |
Result := _NetUseAdd(U.Value, Level, Buffer, ParmErr);
|
6030 |
finally
|
6031 |
FreeMem(U.Value, U.Length);
|
6032 |
end;
|
6033 |
end else
|
6034 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6035 |
end else begin
|
6036 |
{ EStNetException }
|
6037 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6038 |
end;
|
6039 |
end;
|
6040 |
|
6041 |
function StNetUseDel(UncServerName, UseName: string; ForceCond: DWord): NET_API_STATUS;
|
6042 |
var
|
6043 |
U, N : TLMWideChar;
|
6044 |
begin
|
6045 |
Result := 0;
|
6046 |
if IsNetApi32 then begin
|
6047 |
if (@_NetUseDel = nil) then
|
6048 |
@_NetUseDel := GetProcAddress(NETAPI32, 'NetUseDel');
|
6049 |
|
6050 |
if (@_NetUseDel <> nil) then begin
|
6051 |
U.Value := nil;
|
6052 |
N.Value := nil;
|
6053 |
try
|
6054 |
{ allocate the unicode server name }
|
6055 |
CvtToWideChar(UncServerName, U);
|
6056 |
|
6057 |
{ allocate the unicode use name }
|
6058 |
CvtToWideChar(UseName, N);
|
6059 |
|
6060 |
{ call the API }
|
6061 |
Result := _NetUseDel(U.Value, N.Value, ForceCond);
|
6062 |
finally
|
6063 |
FreeMem(U.Value, U.Length);
|
6064 |
FreeMem(N.Value, N.Length);
|
6065 |
end;
|
6066 |
end else
|
6067 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6068 |
end else begin
|
6069 |
{ EStNetException }
|
6070 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6071 |
end;
|
6072 |
end;
|
6073 |
|
6074 |
function StNetUseEnum(UncServerName: string; Level : DWord; var Buffer: Pointer;
|
6075 |
PrefMaxSize : DWord; var EntriesRead, TotalEntries,
|
6076 |
ResumeHandle: DWord): NET_API_STATUS;
|
6077 |
var
|
6078 |
U : TLMWideChar;
|
6079 |
begin
|
6080 |
Result := 0;
|
6081 |
if IsNetApi32 then begin
|
6082 |
if (@_NetUseEnum = nil) then
|
6083 |
@_NetUseEnum := GetProcAddress(NETAPI32, 'NetUseEnum');
|
6084 |
|
6085 |
if (@_NetUseEnum <> nil) then begin
|
6086 |
U.Value := nil;
|
6087 |
try
|
6088 |
{ allocate the unicode server name }
|
6089 |
CvtToWideChar(UncServerName, U);
|
6090 |
|
6091 |
{ call the API }
|
6092 |
Result := _NetUseEnum(U.Value, Level, Buffer, PrefMaxSize, EntriesRead,
|
6093 |
TotalEntries, ResumeHandle);
|
6094 |
finally
|
6095 |
FreeMem(U.Value, U.Length);
|
6096 |
end;
|
6097 |
end else
|
6098 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6099 |
end else begin
|
6100 |
{ EStNetException }
|
6101 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6102 |
end;
|
6103 |
end;
|
6104 |
|
6105 |
function StNetUseGetInfo(UncServerName, UseName: string; Level: DWord;
|
6106 |
var Buffer: Pointer): NET_API_STATUS;
|
6107 |
var
|
6108 |
U, N : TLMWideChar;
|
6109 |
begin
|
6110 |
Result := 0;
|
6111 |
if IsNetApi32 then begin
|
6112 |
if (@_NetUseGetInfo = nil) then
|
6113 |
@_NetUseGetInfo := GetProcAddress(NETAPI32, 'NetUseGetInfo');
|
6114 |
|
6115 |
if (@_NetUseGetInfo <> nil) then begin
|
6116 |
U.Value := nil;
|
6117 |
N.Value := nil;
|
6118 |
try
|
6119 |
{ allocate the unicode server name }
|
6120 |
CvtToWideChar(UncServerName, U);
|
6121 |
|
6122 |
{ allocate the unicode use name }
|
6123 |
CvtToWideChar(UseName, N);
|
6124 |
|
6125 |
{ call the API }
|
6126 |
Result := _NetUseGetInfo(U.Value, N.Value, Level, Buffer);
|
6127 |
finally
|
6128 |
FreeMem(U.Value, U.Length);
|
6129 |
FreeMem(N.Value, N.Length);
|
6130 |
end;
|
6131 |
end else
|
6132 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6133 |
end else begin
|
6134 |
{ EStNetException }
|
6135 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6136 |
end;
|
6137 |
end;
|
6138 |
|
6139 |
|
6140 |
{LMWKSTA}
|
6141 |
function StNetWkstaGetInfo(ServerName: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
6142 |
var
|
6143 |
S : TLMWideChar;
|
6144 |
begin
|
6145 |
Result := 0;
|
6146 |
if IsNetApi32 then begin
|
6147 |
if (@_NetWkstaGetInfo = nil) then
|
6148 |
@_NetWkstaGetInfo := GetProcAddress(NETAPI32, 'NetWkstaGetInfo');
|
6149 |
|
6150 |
if (@_NetWkstaGetInfo <> nil) then begin
|
6151 |
S.Value := nil;
|
6152 |
try
|
6153 |
{ allocate the unicode server name }
|
6154 |
CvtToWideChar(ServerName, S);
|
6155 |
|
6156 |
{ call the API }
|
6157 |
Result := _NetWkstaGetInfo(S.Value, Level, Buffer);
|
6158 |
finally
|
6159 |
FreeMem(S.Value, S.Length);
|
6160 |
end;
|
6161 |
end else
|
6162 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6163 |
end else begin
|
6164 |
{ EStNetException }
|
6165 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6166 |
end;
|
6167 |
end;
|
6168 |
|
6169 |
function StNetWkstaSetInfo(ServerName: string; Level: DWord; Buffer: Pointer;
|
6170 |
var ParmErr: DWord): NET_API_STATUS;
|
6171 |
var
|
6172 |
S : TLMWideChar;
|
6173 |
begin
|
6174 |
Result := 0;
|
6175 |
if IsNetApi32 then begin
|
6176 |
if (@_NetWkstaSetInfo = nil) then
|
6177 |
@_NetWkstaSetInfo := GetProcAddress(NETAPI32, 'NetWkstaSetInfo');
|
6178 |
|
6179 |
if (@_NetWkstaSetInfo <> nil) then begin
|
6180 |
S.Value := nil;
|
6181 |
try
|
6182 |
{ allocate the unicode server name }
|
6183 |
CvtToWideChar(ServerName, S);
|
6184 |
|
6185 |
{ call the API }
|
6186 |
Result := _NetWkstaSetInfo(S.Value, Level, Buffer, ParmErr);
|
6187 |
finally
|
6188 |
FreeMem(S.Value, S.Length);
|
6189 |
end;
|
6190 |
end else
|
6191 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6192 |
end else begin
|
6193 |
{ EStNetException }
|
6194 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6195 |
end;
|
6196 |
end;
|
6197 |
|
6198 |
function StNetWkstaUserGetInfo(Reserved: string; Level: DWord; var Buffer: Pointer): NET_API_STATUS;
|
6199 |
begin
|
6200 |
Result := 0;
|
6201 |
if IsNetApi32 then begin
|
6202 |
if (@_NetWkstaUserGetInfo = nil) then
|
6203 |
@_NetWkstaUserGetInfo := GetProcAddress(NETAPI32, 'NetWkstaUserGetInfo');
|
6204 |
|
6205 |
if (@_NetWkstaUserGetInfo <> nil) then
|
6206 |
Result := _NetWkstaUserGetInfo(nil, Level, Buffer)
|
6207 |
else
|
6208 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6209 |
end else begin
|
6210 |
{ EStNetException }
|
6211 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6212 |
end;
|
6213 |
end;
|
6214 |
|
6215 |
function StNetWkstaUserSetInfo(Reserved: string; Level: DWord; Buffer: Pointer;
|
6216 |
var ParmErr: DWord): NET_API_STATUS;
|
6217 |
begin
|
6218 |
Result := 0;
|
6219 |
if IsNetApi32 then begin
|
6220 |
if (@_NetWkstaUserSetInfo = nil) then
|
6221 |
@_NetWkstaUserSetInfo := GetProcAddress(NETAPI32, 'NetWkstaUserSetInfo');
|
6222 |
|
6223 |
if (@_NetWkstaUserSetInfo <> nil) then
|
6224 |
Result := _NetWkstaUserSetInfo(nil, Level, Buffer, ParmErr)
|
6225 |
else
|
6226 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6227 |
end else begin
|
6228 |
{ EStNetException }
|
6229 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6230 |
end;
|
6231 |
end;
|
6232 |
|
6233 |
function StNetWkstaUserEnum(ServerName: string; Level: DWord; var Buffer: Pointer;
|
6234 |
PrefMaxLen: DWord; var EntriesRead, TotalEntries,
|
6235 |
ResumeHandle: DWord): NET_API_STATUS;
|
6236 |
var
|
6237 |
S : TLMWideChar;
|
6238 |
begin
|
6239 |
Result := 0;
|
6240 |
if IsNetApi32 then begin
|
6241 |
if (@_NetWkstaUserEnum = nil) then
|
6242 |
@_NetWkstaUserEnum := GetProcAddress(NETAPI32, 'NetWkstaUserEnum');
|
6243 |
|
6244 |
if (@_NetWkstaUserEnum <> nil) then begin
|
6245 |
S.Value := nil;
|
6246 |
try
|
6247 |
{ allocate the unicode server name }
|
6248 |
CvtToWideChar(ServerName, S);
|
6249 |
|
6250 |
{ call the API }
|
6251 |
Result := _NetWkstaUserEnum(S.Value, Level, Buffer, PrefMaxLen,
|
6252 |
EntriesRead, TotalEntries, ResumeHandle);
|
6253 |
finally
|
6254 |
FreeMem(S.value, S.Length);
|
6255 |
end;
|
6256 |
end else
|
6257 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6258 |
end else begin
|
6259 |
{ EStNetException }
|
6260 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6261 |
end;
|
6262 |
end;
|
6263 |
|
6264 |
function StNetWkstaTransportAdd(ServerName: string; Level: DWord; Buffer: Pointer;
|
6265 |
var ParmErr: DWord): NET_API_STATUS;
|
6266 |
var
|
6267 |
S : TLMWideChar;
|
6268 |
begin
|
6269 |
Result := 0;
|
6270 |
if IsNetApi32 then begin
|
6271 |
if (@_NetWkstaTransportAdd = nil) then
|
6272 |
@_NetWkstaTransportAdd := GetProcAddress(NETAPI32, 'NetWkstaTransportAdd');
|
6273 |
|
6274 |
if (@_NetWkstaTransportAdd <> nil) then begin
|
6275 |
S.Value := nil;
|
6276 |
try
|
6277 |
{ allocate the unicode server name }
|
6278 |
CvtToWideChar(ServerName, S);
|
6279 |
|
6280 |
{ call the API }
|
6281 |
Result := _NetWkstaTransportAdd(S.Value, Level, Buffer, ParmErr);
|
6282 |
finally
|
6283 |
FreeMem(S.Value, S.Length);
|
6284 |
end;
|
6285 |
end else
|
6286 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6287 |
end else begin
|
6288 |
{ EStNetException }
|
6289 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6290 |
end;
|
6291 |
end;
|
6292 |
|
6293 |
function StNetWkstaTransportDel(ServerName, TransportName: string; Ucond: DWord): NET_API_STATUS;
|
6294 |
var
|
6295 |
S, T : TLMWideChar;
|
6296 |
begin
|
6297 |
Result := 0;
|
6298 |
if IsNetApi32 then begin
|
6299 |
if (@_NetWkstaTransportDel = nil) then
|
6300 |
@_NetWkstaTransportDel := GetProcAddress(NETAPI32, 'NetWkstaTransportDel');
|
6301 |
|
6302 |
if (@_NetWkstaTransportDel <> nil) then begin
|
6303 |
S.Value := nil;
|
6304 |
T.Value := nil;
|
6305 |
try
|
6306 |
{ allocate the unicode server name }
|
6307 |
CvtToWideChar(ServerName, S);
|
6308 |
|
6309 |
{ allocate the unicode transport name }
|
6310 |
CvtToWideChar(TransportName, T);
|
6311 |
|
6312 |
{ call the API }
|
6313 |
Result := _NetWkstaTransportDel(S.Value, T.Value, Ucond);
|
6314 |
finally
|
6315 |
FreeMem(S.Value, S.Length);
|
6316 |
FreeMem(T.Value, T.Length);
|
6317 |
end;
|
6318 |
end else
|
6319 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6320 |
end else begin
|
6321 |
{ EStNetException }
|
6322 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6323 |
end;
|
6324 |
end;
|
6325 |
|
6326 |
function StNetWkstaTransportEnum(ServerName: string; Level: DWord;
|
6327 |
var Buffer: Pointer; PrefMaxLen: DWord;
|
6328 |
var EntriesRead, TotalEntries,
|
6329 |
ResumeHandle: DWord): NET_API_STATUS;
|
6330 |
var
|
6331 |
S : TLMWideChar;
|
6332 |
begin
|
6333 |
Result := 0;
|
6334 |
if IsNetApi32 then begin
|
6335 |
if (@_NetWkstaTransportEnum = nil) then
|
6336 |
@_NetWkstaTransportEnum := GetProcAddress(NETAPI32, 'NetWkstaTransportEnum');
|
6337 |
|
6338 |
if (@_NetWkstaTransportEnum <> nil) then begin
|
6339 |
S.Value := nil;
|
6340 |
try
|
6341 |
{ allocate the unicode server name }
|
6342 |
CvtToWideChar(ServerName, S);
|
6343 |
|
6344 |
{ call the API }
|
6345 |
Result := _NetWkstaTransportEnum(S.Value, Level, Buffer, PrefMaxLen,
|
6346 |
EntriesRead, TotalEntries, ResumeHandle);
|
6347 |
finally
|
6348 |
FreeMem(S.Value, S.Length);
|
6349 |
end;
|
6350 |
end else
|
6351 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6352 |
end else begin
|
6353 |
{ EStNetException }
|
6354 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6355 |
end;
|
6356 |
end;
|
6357 |
|
6358 |
{LMAPIBUF}
|
6359 |
function StNetApiBufferAllocate(ByteCount: Cardinal; var Buffer: Pointer): NET_API_STATUS;
|
6360 |
begin
|
6361 |
Result := 0;
|
6362 |
if IsNetApi32 then begin
|
6363 |
if (@_NetApiBufferAllocate = nil) then
|
6364 |
@_NetApiBufferAllocate := GetProcAddress(NETAPI32, 'NetApiBufferAllocate');
|
6365 |
|
6366 |
if (@_NetApiBufferAllocate <> nil) then
|
6367 |
Result := _NetApiBufferAllocate(ByteCount, Buffer)
|
6368 |
else
|
6369 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6370 |
end else begin
|
6371 |
{ EStNetException }
|
6372 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6373 |
end;
|
6374 |
end;
|
6375 |
|
6376 |
function StNetApiBufferFree(Buffer: Pointer): NET_API_STATUS;
|
6377 |
begin
|
6378 |
Result := 0;
|
6379 |
if IsNetApi32 then begin
|
6380 |
if (@_NetApiBufferFree = nil) then
|
6381 |
@_NetApiBufferFree := GetProcAddress(NETAPI32, 'NetApiBufferFree');
|
6382 |
|
6383 |
if (@_NetApiBufferFree <> nil) then
|
6384 |
Result := _NetApiBufferFree(Buffer)
|
6385 |
else
|
6386 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6387 |
end else begin
|
6388 |
{ EStNetException }
|
6389 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6390 |
end;
|
6391 |
end;
|
6392 |
|
6393 |
function StNetApiBufferReallocate(OldBuffer: Pointer; NewByteCount : Cardinal;
|
6394 |
var NewBuffer: Pointer): NET_API_STATUS;
|
6395 |
begin
|
6396 |
Result := 0;
|
6397 |
if IsNetApi32 then begin
|
6398 |
if (@_NetApiBufferReallocate = nil) then
|
6399 |
@_NetApiBufferReallocate := GetProcAddress(NETAPI32, 'NetApiBufferReallocate');
|
6400 |
|
6401 |
if (@_NetApiBufferReallocate <> nil) then
|
6402 |
Result := _NetApiBufferReallocate(OldBuffer, NewByteCount, NewBuffer)
|
6403 |
else
|
6404 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6405 |
end else begin
|
6406 |
{ EStNetException }
|
6407 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6408 |
end;
|
6409 |
end;
|
6410 |
|
6411 |
function StNetApiBufferSize(Buffer: Pointer; var ByteCount: DWord): NET_API_STATUS;
|
6412 |
begin
|
6413 |
Result := 0;
|
6414 |
if IsNetApi32 then begin
|
6415 |
if (@_NetApiBufferSize = nil) then
|
6416 |
@_NetApiBufferSize := GetProcAddress(NETAPI32, 'NetApiBufferSize');
|
6417 |
|
6418 |
if (@_NetApiBufferSize <> nil) then
|
6419 |
Result := _NetApiBufferSize(Buffer, ByteCount)
|
6420 |
else
|
6421 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6422 |
end else begin
|
6423 |
{ EStNetException }
|
6424 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6425 |
end;
|
6426 |
end;
|
6427 |
|
6428 |
{LMSTATS}
|
6429 |
function StNetStatisticsGet(ServerName, ServiceName: string; Level, Options: DWord;
|
6430 |
var Buffer: Pointer): NET_API_STATUS;
|
6431 |
var
|
6432 |
S, S1 : TLMWideChar;
|
6433 |
begin
|
6434 |
Result := 0;
|
6435 |
if IsNetApi32 then begin
|
6436 |
if (@_NetStatisticsGet = nil) then
|
6437 |
@_NetStatisticsGet := GetProcAddress(NETAPI32, 'NetStatisticsGet');
|
6438 |
|
6439 |
if (@_NetStatisticsGet <> nil) then begin
|
6440 |
S.Value := nil;
|
6441 |
S1.Value := nil;
|
6442 |
try
|
6443 |
{ allocate the unicode server name }
|
6444 |
CvtToWideChar(ServerName, S);
|
6445 |
|
6446 |
{ allocate the unicode service name }
|
6447 |
CvtToWideChar(ServiceName, S1);
|
6448 |
|
6449 |
{ call the API }
|
6450 |
Result := _NetStatisticsGet(S.Value, S1.Value, Level, Options, Buffer);
|
6451 |
finally
|
6452 |
FreeMem(S.Value, S.Length);
|
6453 |
FreeMem(S1.Value, S1.Length);
|
6454 |
end;
|
6455 |
end else
|
6456 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6457 |
end else begin
|
6458 |
{ EStNetException }
|
6459 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, NETAPI32DLL);
|
6460 |
end;
|
6461 |
end;
|
6462 |
|
6463 |
{WINBASE}
|
6464 |
function StGetSidIdentifierAuthority(Sid: PSID): PSIDIdentifierAuthority;
|
6465 |
begin
|
6466 |
Result := nil;
|
6467 |
if IsAdvApi32 then begin
|
6468 |
if (@_GetSidIdentifierAuthority = nil) then
|
6469 |
@_GetSidIdentifierAuthority := GetProcAddress(ADVAPI32, 'GetSidIdentifierAuthority');
|
6470 |
|
6471 |
if (@_GetSidIdentifierAuthority <> nil) then begin
|
6472 |
try
|
6473 |
Result := _GetSidIdentifierAuthority(Sid);
|
6474 |
finally
|
6475 |
end;
|
6476 |
end else
|
6477 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6478 |
end else begin
|
6479 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, ADVAPI32DLL);
|
6480 |
end;
|
6481 |
end;
|
6482 |
|
6483 |
function StGetSidSubAuthority(Sid: PSID; SubAuthority: DWord): DWord;
|
6484 |
begin
|
6485 |
Result := 0;
|
6486 |
if IsAdvApi32 then begin
|
6487 |
if (@_GetSidSubAuthority = nil) then
|
6488 |
@_GetSidSubAuthority := GetProcAddress(ADVAPI32, 'GetSidSubAuthority');
|
6489 |
|
6490 |
if (@_GetSidSubAuthority <> nil) then begin
|
6491 |
|
6492 |
try
|
6493 |
Result := _GetSidSubAuthority(Sid, SubAuthority)^;
|
6494 |
finally
|
6495 |
end;
|
6496 |
end else
|
6497 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6498 |
end else begin
|
6499 |
{ EStNetException }
|
6500 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, ADVAPI32DLL);
|
6501 |
end;
|
6502 |
end;
|
6503 |
|
6504 |
function StGetSidSubAuthorityCount(SID: PSID): Byte;
|
6505 |
begin
|
6506 |
Result := 0;
|
6507 |
if IsAdvApi32 then begin
|
6508 |
if (@_GetSidSubAuthorityCount = nil) then
|
6509 |
@_GetSidSubAuthorityCount := GetProcAddress(ADVAPI32, 'GetSidSubAuthorityCount');
|
6510 |
|
6511 |
if (@_GetSidSubAuthorityCount <> nil) then begin
|
6512 |
|
6513 |
try
|
6514 |
Result := _GetSidSubAuthorityCount(Sid)^;
|
6515 |
finally
|
6516 |
end;
|
6517 |
end else
|
6518 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6519 |
end else begin
|
6520 |
{ EStNetException }
|
6521 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, ADVAPI32DLL);
|
6522 |
end;
|
6523 |
end;
|
6524 |
|
6525 |
function StLookupAccountName(SystemName, AccountName: string; var Sid: Pointer;
|
6526 |
var SidLength: DWord; var DomainName: string;
|
6527 |
var peUse: DWord): Boolean;
|
6528 |
var
|
6529 |
BufLen : DWord;
|
6530 |
Buffer : Pointer;
|
6531 |
ErrorD : DWord;
|
6532 |
begin
|
6533 |
Result := False;
|
6534 |
if IsAdvApi32 then begin
|
6535 |
if (@_LookupAccountName = nil) then
|
6536 |
{$IFDEF UNICODE}
|
6537 |
@_LookupAccountName := GetProcAddress(ADVAPI32, 'LookupAccountNameW');
|
6538 |
{$ELSE}
|
6539 |
@_LookupAccountName := GetProcAddress(ADVAPI32, 'LookupAccountNameA');
|
6540 |
{$ENDIF}
|
6541 |
|
6542 |
if (@_LookupAccountName <> nil) then begin
|
6543 |
{ This just sets up the buffer sizes }
|
6544 |
BufLen := 0;
|
6545 |
Buffer := nil;
|
6546 |
Result := _LookupAccountName(PChar(SystemName), PChar(AccountName),
|
6547 |
nil, SidLength, nil, BufLen, peUse);
|
6548 |
ErrorD := GetLastError;
|
6549 |
|
6550 |
{ now for the real call }
|
6551 |
if ErrorD = ERROR_INSUFFICIENT_BUFFER then begin
|
6552 |
StNetApiBufferAllocate(BufLen, Buffer);
|
6553 |
StNetApiBufferAllocate(SidLength, Sid);
|
6554 |
try
|
6555 |
try
|
6556 |
Result := _LookupAccountName(PChar(SystemName),
|
6557 |
PChar(AccountName), Sid, SidLength,
|
6558 |
Buffer, BufLen, peUse);
|
6559 |
if Result then
|
6560 |
DomainName := StrPas(PChar(Buffer))
|
6561 |
else
|
6562 |
StNetApiBufferFree(Sid);
|
6563 |
finally
|
6564 |
StNetApiBufferFree(Buffer);
|
6565 |
end;
|
6566 |
except
|
6567 |
StNetApiBufferFree(Sid);
|
6568 |
raise;
|
6569 |
end;
|
6570 |
end else begin
|
6571 |
SetLastError(ErrorD);
|
6572 |
end;
|
6573 |
end else
|
6574 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6575 |
end else begin
|
6576 |
{ EStNetException }
|
6577 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, ADVAPI32DLL);
|
6578 |
end;
|
6579 |
end;
|
6580 |
|
6581 |
function StLookupAccountSid(SystemName: string; Sid: PSid; var AccountName,
|
6582 |
DomainName: string; var peUse: DWord): Boolean;
|
6583 |
var
|
6584 |
A, D : Pointer;
|
6585 |
ALen, DLen : DWord;
|
6586 |
ErrorD : DWord;
|
6587 |
begin
|
6588 |
Result := False;
|
6589 |
if IsAdvApi32 then begin
|
6590 |
if (@_LookupAccountSid = nil) then
|
6591 |
{$IFDEF UNICODE}
|
6592 |
@_LookupAccountSid := GetProcAddress(ADVAPI32, 'LookupAccountSidW');
|
6593 |
{$ELSE}
|
6594 |
@_LookupAccountSid := GetProcAddress(ADVAPI32, 'LookupAccountSidA');
|
6595 |
{$ENDIF}
|
6596 |
|
6597 |
if (@_LookupAccountSid <> nil) then begin
|
6598 |
{ This just sets up the buffer sizes }
|
6599 |
ALen := 0;
|
6600 |
DLen := 0;
|
6601 |
|
6602 |
A := nil;
|
6603 |
D := nil;
|
6604 |
Result := _LookupAccountName(PChar(SystemName), Sid, nil, ALen, nil,
|
6605 |
DLen, peUse);
|
6606 |
ErrorD := GetLastError;
|
6607 |
if ErrorD = ERROR_INSUFFICIENT_BUFFER then begin
|
6608 |
StNetApiBufferAllocate(ALen, A);
|
6609 |
StNetApiBufferAllocate(DLen, D);
|
6610 |
try
|
6611 |
Result := _LookupAccountName(PChar(SystemName), Sid, A, ALen, D,
|
6612 |
DLen, peUse);
|
6613 |
if Result then begin
|
6614 |
AccountName := StrPas(PChar(A));
|
6615 |
DomainName := StrPas(PChar(D));
|
6616 |
end;
|
6617 |
finally
|
6618 |
StNetApiBufferFree(A);
|
6619 |
StNetApiBufferFree(D);
|
6620 |
end;
|
6621 |
end else begin
|
6622 |
SetLastError(ErrorD);
|
6623 |
end;
|
6624 |
end else
|
6625 |
RaiseStWin32Error(EStNetException, GetLastError);
|
6626 |
end else begin
|
6627 |
{ EStNetException }
|
6628 |
RaiseStWin32ErrorEx(EStNetException, GetLastError, ADVAPI32DLL);
|
6629 |
end;
|
6630 |
end;
|
6631 |
|
6632 |
initialization
|
6633 |
|
6634 |
finalization
|
6635 |
if (NETAPI32 <> 0) then
|
6636 |
FreeLibrary(NETAPI32);
|
6637 |
|
6638 |
if (ADVAPI32 <> 0) then
|
6639 |
FreeLibrary(ADVAPI32);
|
6640 |
|
6641 |
end.
|