ReactOS  0.4.15-dev-2721-g5912c11
user.c
Go to the documentation of this file.
1 /*
2  * Copyright 2002 Andriy Palamarchuk
3  *
4  * netapi32 user functions
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 /*
22  * TODO:
23  * Implement NetUserGetGroups (WIP)
24  * Implement NetUserSetGroups
25  * NetUserGetLocalGroups does not support LG_INCLUDE_INDIRECT yet.
26  * Add missing information levels.
27  * ...
28  */
29 
30 #include "netapi32.h"
31 
32 #include <ndk/kefuncs.h>
33 #include <ndk/obfuncs.h>
34 
35 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
36 
37 typedef struct _ENUM_CONTEXT
38 {
39  LIST_ENTRY ListLink;
40  ULONG EnumHandle;
41 
42  SAM_HANDLE ServerHandle;
43  SAM_HANDLE BuiltinDomainHandle;
44  SAM_HANDLE AccountDomainHandle;
45  PSID BuiltinDomainSid;
46  PSID AccountDomainSid;
47 
48  SAM_ENUMERATE_HANDLE EnumerationContext;
49  PSAM_RID_ENUMERATION Buffer;
50  ULONG Count;
51  ULONG Index;
52  BOOLEAN BuiltinDone;
53 
54 } ENUM_CONTEXT, *PENUM_CONTEXT;
55 
56 LIST_ENTRY g_EnumContextListHead;
57 CRITICAL_SECTION g_EnumContextListLock;
58 LONG g_EnumContextHandle = 0;
59 
60 static
61 ULONG
62 DeltaTimeToSeconds(LARGE_INTEGER DeltaTime)
63 {
64  LARGE_INTEGER Seconds;
65 
66  if (DeltaTime.QuadPart == 0)
67  return 0;
68 
69  Seconds.QuadPart = -DeltaTime.QuadPart / 10000000;
70 
71  if (Seconds.HighPart != 0)
72  return TIMEQ_FOREVER;
73 
74  return Seconds.LowPart;
75 }
76 
77 
78 static
79 NTSTATUS
80 GetAllowedWorldAce(IN PACL Acl,
81  OUT PACCESS_ALLOWED_ACE *Ace)
82 {
83  SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
84  ULONG WorldSid[sizeof(SID) / sizeof(ULONG) + SID_MAX_SUB_AUTHORITIES];
85  ACL_SIZE_INFORMATION AclSize;
86  PVOID LocalAce = NULL;
87  ULONG i;
88  NTSTATUS Status;
89 
90  *Ace = NULL;
91 
92  RtlInitializeSid((PSID)WorldSid,
93  &WorldAuthority,
94  1);
95  *(RtlSubAuthoritySid((PSID)WorldSid, 0)) = SECURITY_WORLD_RID;
96 
97  Status = RtlQueryInformationAcl(Acl,
98  &AclSize,
99  sizeof(AclSize),
100  AclSizeInformation);
101  if (!NT_SUCCESS(Status))
102  return Status;
103 
104  for (i = 0; i < AclSize.AceCount; i++)
105  {
106  Status = RtlGetAce(Acl, i, &LocalAce);
107  if (!NT_SUCCESS(Status))
108  return Status;
109 
110  if (((PACE_HEADER)LocalAce)->AceType != ACCESS_ALLOWED_ACE_TYPE)
111  continue;
112 
113  if (RtlEqualSid((PSID)WorldSid,
114  (PSID)&((PACCESS_ALLOWED_ACE)LocalAce)->SidStart))
115  {
116  *Ace = (PACCESS_ALLOWED_ACE)LocalAce;
117  return STATUS_SUCCESS;
118  }
119  }
120 
121  return STATUS_SUCCESS;
122 }
123 
124 
125 static
126 ULONG
127 GetAccountFlags(ULONG AccountControl,
128  PACL Dacl)
129 {
130  PACCESS_ALLOWED_ACE Ace = NULL;
131  ULONG Flags = UF_SCRIPT;
132  NTSTATUS Status;
133 
134  if (Dacl != NULL)
135  {
136  Status = GetAllowedWorldAce(Dacl, &Ace);
137  if (NT_SUCCESS(Status))
138  {
139  if (Ace == NULL)
140  {
141  Flags |= UF_PASSWD_CANT_CHANGE;
142  }
143  else if ((Ace->Mask & USER_CHANGE_PASSWORD) == 0)
144  {
145  Flags |= UF_PASSWD_CANT_CHANGE;
146  }
147  }
148  }
149 
150  if (AccountControl & USER_ACCOUNT_DISABLED)
151  Flags |= UF_ACCOUNTDISABLE;
152 
153  if (AccountControl & USER_HOME_DIRECTORY_REQUIRED)
154  Flags |= UF_HOMEDIR_REQUIRED;
155 
156  if (AccountControl & USER_PASSWORD_NOT_REQUIRED)
157  Flags |= UF_PASSWD_NOTREQD;
158 
159  if (AccountControl & USER_ACCOUNT_AUTO_LOCKED)
160  Flags |= UF_LOCKOUT;
161 
162  if (AccountControl & USER_DONT_EXPIRE_PASSWORD)
163  Flags |= UF_DONT_EXPIRE_PASSWD;
164 
165 /*
166  if (AccountControl & USER_ENCRYPTED_TEXT_PASSWORD_ALLOWED)
167  Flags |= UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED;
168 
169  if (AccountControl & USER_SMARTCARD_REQUIRED)
170  Flags |= UF_SMARTCARD_REQUIRED;
171 
172  if (AccountControl & USER_TRUSTED_FOR_DELEGATION)
173  Flags |= UF_TRUSTED_FOR_DELEGATION;
174 
175  if (AccountControl & USER_NOT_DELEGATED)
176  Flags |= UF_NOT_DELEGATED;
177 
178  if (AccountControl & USER_USE_DES_KEY_ONLY)
179  Flags |= UF_USE_DES_KEY_ONLY;
180 
181  if (AccountControl & USER_DONT_REQUIRE_PREAUTH)
182  Flags |= UF_DONT_REQUIRE_PREAUTH;
183 
184  if (AccountControl & USER_PASSWORD_EXPIRED)
185  Flags |= UF_PASSWORD_EXPIRED;
186 */
187 
188  /* Set account type flags */
189  if (AccountControl & USER_TEMP_DUPLICATE_ACCOUNT)
190  Flags |= UF_TEMP_DUPLICATE_ACCOUNT;
191  else if (AccountControl & USER_NORMAL_ACCOUNT)
192  Flags |= UF_NORMAL_ACCOUNT;
193  else if (AccountControl & USER_INTERDOMAIN_TRUST_ACCOUNT)
194  Flags |= UF_INTERDOMAIN_TRUST_ACCOUNT;
195  else if (AccountControl & USER_WORKSTATION_TRUST_ACCOUNT)
196  Flags |= UF_WORKSTATION_TRUST_ACCOUNT;
197  else if (AccountControl & USER_SERVER_TRUST_ACCOUNT)
198  Flags |= UF_SERVER_TRUST_ACCOUNT;
199 
200  return Flags;
201 }
202 
203 
204 static
205 ULONG
206 GetAccountControl(ULONG Flags)
207 {
208  ULONG AccountControl = 0;
209 
210  if (Flags & UF_ACCOUNTDISABLE)
211  AccountControl |= USER_ACCOUNT_DISABLED;
212 
213  if (Flags & UF_HOMEDIR_REQUIRED)
214  AccountControl |= USER_HOME_DIRECTORY_REQUIRED;
215 
216  if (Flags & UF_PASSWD_NOTREQD)
217  AccountControl |= USER_PASSWORD_NOT_REQUIRED;
218 
219  if (Flags & UF_LOCKOUT)
220  AccountControl |= USER_ACCOUNT_AUTO_LOCKED;
221 
222  if (Flags & UF_DONT_EXPIRE_PASSWD)
223  AccountControl |= USER_DONT_EXPIRE_PASSWORD;
224 
225  /* Set account type flags */
226  if (Flags & UF_TEMP_DUPLICATE_ACCOUNT)
227  AccountControl |= USER_TEMP_DUPLICATE_ACCOUNT;
228  else if (Flags & UF_NORMAL_ACCOUNT)
229  AccountControl |= USER_NORMAL_ACCOUNT;
230  else if (Flags & UF_INTERDOMAIN_TRUST_ACCOUNT)
231  AccountControl |= USER_INTERDOMAIN_TRUST_ACCOUNT;
232  else if (Flags & UF_WORKSTATION_TRUST_ACCOUNT)
233  AccountControl |= USER_WORKSTATION_TRUST_ACCOUNT;
234  else if (Flags & UF_SERVER_TRUST_ACCOUNT)
235  AccountControl |= USER_SERVER_TRUST_ACCOUNT;
236 
237  return AccountControl;
238 }
239 
240 
241 static
242 DWORD
243 GetPasswordAge(IN PLARGE_INTEGER PasswordLastSet)
244 {
245  LARGE_INTEGER SystemTime;
246  ULONG SystemSecondsSince1970;
247  ULONG PasswordSecondsSince1970;
248  NTSTATUS Status;
249 
250  Status = NtQuerySystemTime(&SystemTime);
251  if (!NT_SUCCESS(Status))
252  return 0;
253 
254  RtlTimeToSecondsSince1970(&SystemTime, &SystemSecondsSince1970);
255  RtlTimeToSecondsSince1970(PasswordLastSet, &PasswordSecondsSince1970);
256 
257  return SystemSecondsSince1970 - PasswordSecondsSince1970;
258 }
259 
260 
261 static
262 VOID
263 ChangeUserDacl(IN PACL Dacl,
264  IN ULONG Flags)
265 {
266  PACCESS_ALLOWED_ACE Ace = NULL;
267  NTSTATUS Status;
268 
269  if (Dacl == NULL)
270  return;
271 
272  Status = GetAllowedWorldAce(Dacl, &Ace);
273  if (!NT_SUCCESS(Status))
274  return;
275 
276  if (Flags & UF_PASSWD_CANT_CHANGE)
277  Ace->Mask &= ~USER_CHANGE_PASSWORD;
278  else
279  Ace->Mask |= USER_CHANGE_PASSWORD;
280 }
281 
282 
283 static
284 NET_API_STATUS
285 GetUserDacl(IN SAM_HANDLE UserHandle,
286  OUT PACL *Dacl)
287 {
288  PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
289  PACL SamDacl;
290  PACL LocalDacl;
291  BOOLEAN Defaulted;
292  BOOLEAN Present;
293  ACL_SIZE_INFORMATION AclSize;
294  NET_API_STATUS ApiStatus;
295  NTSTATUS Status;
296 
297  TRACE("(%p %p)\n", UserHandle, Dacl);
298 
299  *Dacl = NULL;
300 
301  Status = SamQuerySecurityObject(UserHandle,
302  DACL_SECURITY_INFORMATION,
303  &SecurityDescriptor);
304  if (!NT_SUCCESS(Status))
305  {
306  TRACE("SamQuerySecurityObject() failed (Status 0x%08lx)\n", Status);
307  ApiStatus = NetpNtStatusToApiStatus(Status);
308  goto done;
309  }
310 
311  Status = RtlGetDaclSecurityDescriptor(SecurityDescriptor,
312  &Present,
313  &SamDacl,
314  &Defaulted);
315  if (!NT_SUCCESS(Status))
316  {
317  TRACE("RtlGetDaclSecurityDescriptor() failed (Status 0x%08lx)\n", Status);
318  ApiStatus = NERR_InternalError;
319  goto done;
320  }
321 
322  if (Present == FALSE)
323  {
324  TRACE("No DACL present\n");
325  ApiStatus = NERR_Success;
326  goto done;
327  }
328 
329  Status = RtlQueryInformationAcl(SamDacl,
330  &AclSize,
331  sizeof(AclSize),
332  AclSizeInformation);
333  if (!NT_SUCCESS(Status))
334  {
335  TRACE("RtlQueryInformationAcl() failed (Status 0x%08lx)\n", Status);
336  ApiStatus = NERR_InternalError;
337  goto done;
338  }
339 
340  LocalDacl = HeapAlloc(GetProcessHeap(), 0, AclSize.AclBytesInUse);
341  if (LocalDacl == NULL)
342  {
343  TRACE("Memory allocation failed\n");
344  ApiStatus = ERROR_NOT_ENOUGH_MEMORY;
345  goto done;
346  }
347 
348  RtlCopyMemory(LocalDacl, SamDacl, AclSize.AclBytesInUse);
349 
350  *Dacl = LocalDacl;
351 
352  ApiStatus = NERR_Success;
353 
354 done:
355  if (SecurityDescriptor != NULL)
356  SamFreeMemory(SecurityDescriptor);
357 
358  TRACE("done (ApiStatus: 0x%08lx)\n", ApiStatus);
359 
360  return ApiStatus;
361 }
362 
363 
364 static
365 VOID
366 FreeUserInfo(PUSER_ALL_INFORMATION UserInfo)
367 {
368  if (UserInfo->UserName.Buffer != NULL)
369  SamFreeMemory(UserInfo->UserName.Buffer);
370 
371  if (UserInfo->FullName.Buffer != NULL)
372  SamFreeMemory(UserInfo->FullName.Buffer);
373 
374  if (UserInfo->HomeDirectory.Buffer != NULL)
375  SamFreeMemory(UserInfo->HomeDirectory.Buffer);
376 
377  if (UserInfo->HomeDirectoryDrive.Buffer != NULL)
378  SamFreeMemory(UserInfo->HomeDirectoryDrive.Buffer);
379 
380  if (UserInfo->ScriptPath.Buffer != NULL)
381  SamFreeMemory(UserInfo->ScriptPath.Buffer);
382 
383  if (UserInfo->ProfilePath.Buffer != NULL)
384  SamFreeMemory(UserInfo->ProfilePath.Buffer);
385 
386  if (UserInfo->AdminComment.Buffer != NULL)
387  SamFreeMemory(UserInfo->AdminComment.Buffer);
388 
389  if (UserInfo->WorkStations.Buffer != NULL)
390  SamFreeMemory(UserInfo->WorkStations.Buffer);
391 
392  if (UserInfo->UserComment.Buffer != NULL)
393  SamFreeMemory(UserInfo->UserComment.Buffer);
394 
395  if (UserInfo->Parameters.Buffer != NULL)
396  SamFreeMemory(UserInfo->Parameters.Buffer);
397 
398  if (UserInfo->PrivateData.Buffer != NULL)
399  SamFreeMemory(UserInfo->PrivateData.Buffer);
400 
401  if (UserInfo->LogonHours.LogonHours != NULL)
402  SamFreeMemory(UserInfo->LogonHours.LogonHours);
403 
404  SamFreeMemory(UserInfo);
405 }
406 
407 
408 static
409 NET_API_STATUS
410 GetUserPrivileges(
411  _In_ SAM_HANDLE BuiltinDomainHandle,
412  _In_ SAM_HANDLE UserHandle,
413  _In_ PSID AccountDomainSid,
414  _In_ ULONG RelativeId,
415  _Out_ PDWORD Priv,
416  _Out_ PDWORD AuthFlags)
417 {
418  PGROUP_MEMBERSHIP GroupMembership = NULL;
419  ULONG GroupCount, SidCount, AliasCount, i;
420  PSID *SidArray = NULL;
421  PULONG AliasArray = NULL;
422  BOOL bAdmin = FALSE, bUser = FALSE;
423  NET_API_STATUS ApiStatus = NERR_Success;
424  NTSTATUS Status;
425 
426  FIXME("GetUserPrivileges(%p)\n", UserHandle);
427 
428  /* Get the users group memberships */
429  Status = SamGetGroupsForUser(UserHandle,
430  &GroupMembership,
431  &GroupCount);
432  if (!NT_SUCCESS(Status))
433  {
434  ERR("SamGetGroupsForUser() failed (Status 0x%08lx)\n", Status);
435  ApiStatus = NetpNtStatusToApiStatus(Status);
436  goto done;
437  }
438 
439  /* Allocate the SID array */
440  ApiStatus = NetApiBufferAllocate((GroupCount + 1) * sizeof(PSID),
441  (PVOID*)&SidArray);
442  if (ApiStatus != NERR_Success)
443  {
444  goto done;
445  }
446 
447  /* Add the user to the SID array */
448  SidCount = 0;
449  ApiStatus = BuildSidFromSidAndRid(AccountDomainSid,
450  RelativeId,
451  &SidArray[0]);
452  if (ApiStatus != NERR_Success)
453  {
454  goto done;
455  }
456 
457  SidCount++;
458 
459  /* Add the groups to the SID array */
460  for (i = 0; i < GroupCount; i++)
461  {
462  ApiStatus = BuildSidFromSidAndRid(AccountDomainSid,
463  GroupMembership[i].RelativeId,
464  &SidArray[i + 1]);
465  if (ApiStatus != NERR_Success)
466  {
467  goto done;
468  }
469 
470  SidCount++;
471  }
472 
473  /* Get aliases for the user and his groups */
474  Status = SamGetAliasMembership(BuiltinDomainHandle,
475  SidCount,
476  SidArray,
477  &AliasCount,
478  &AliasArray);
479  if (!NT_SUCCESS(Status))
480  {
481  ERR("SamGetAliasMembership() failed (Status 0x%08lx)\n", Status);
482  ApiStatus = NetpNtStatusToApiStatus(Status);
483  goto done;
484  }
485 
486  *AuthFlags = 0;
487 
488  /* Set the AuthFlags */
489  for (i = 0; i < AliasCount; i++)
490  {
491  switch (AliasArray[i])
492  {
493  case DOMAIN_ALIAS_RID_ADMINS:
494  bAdmin = TRUE;
495  break;
496 
497  case DOMAIN_ALIAS_RID_USERS:
498  bUser = TRUE;
499  break;
500 
501  case DOMAIN_ALIAS_RID_ACCOUNT_OPS:
502  *AuthFlags |= AF_OP_ACCOUNTS;
503  break;
504 
505  case DOMAIN_ALIAS_RID_SYSTEM_OPS:
506  *AuthFlags |= AF_OP_SERVER;
507  break;
508 
509  case DOMAIN_ALIAS_RID_PRINT_OPS:
510  *AuthFlags |= AF_OP_PRINT;
511  break;
512  }
513  }
514 
515  /* Set the prvileges */
516  if (bAdmin)
517  {
518  *Priv = USER_PRIV_ADMIN;
519  }
520  else if (bUser)
521  {
522  *Priv = USER_PRIV_USER;
523  }
524  else
525  {
526  *Priv = USER_PRIV_GUEST;
527  }
528 
529 done:
530  if (AliasArray != NULL)
531  SamFreeMemory(AliasArray);
532 
533  if (SidArray != NULL)
534  {
535  for (i = 0; i < SidCount; i++)
536  NetApiBufferFree(SidArray[i]);
537 
538  NetApiBufferFree(SidArray);
539  }
540 
541  if (GroupMembership != NULL)
542  SamFreeMemory(GroupMembership);
543 
544  return ApiStatus;
545 }
546 
547 
548 static
549 NET_API_STATUS
550 BuildUserInfoBuffer(
551  _In_ SAM_HANDLE BuiltinDomainHandle,
552  _In_ SAM_HANDLE UserHandle,
553  _In_ PSID AccountDomainSid,
554  _In_ ULONG RelativeId,
555  _In_ DWORD level,
556  _Out_ LPVOID *Buffer)
557 {
558  UNICODE_STRING LogonServer = RTL_CONSTANT_STRING(L"\\\\*");
559  PUSER_ALL_INFORMATION UserInfo = NULL;
560  LPVOID LocalBuffer = NULL;
561  PACL Dacl = NULL;
562  DWORD Priv = 0, AuthFlags = 0;
563  PUSER_INFO_0 UserInfo0;
564  PUSER_INFO_1 UserInfo1;
565  PUSER_INFO_2 UserInfo2;
566  PUSER_INFO_3 UserInfo3;
567  PUSER_INFO_4 UserInfo4;
568  PUSER_INFO_10 UserInfo10;
569  PUSER_INFO_11 UserInfo11;
570  PUSER_INFO_20 UserInfo20;
571  PUSER_INFO_23 UserInfo23;
572  LPWSTR Ptr;
573  ULONG Size = 0;
574  NTSTATUS Status;
575  NET_API_STATUS ApiStatus = NERR_Success;
576 
577  *Buffer = NULL;
578 
579  Status = SamQueryInformationUser(UserHandle,
580  UserAllInformation,
581  (PVOID *)&UserInfo);
582  if (!NT_SUCCESS(Status))
583  {
584  ERR("SamQueryInformationUser failed (Status %08lx)\n", Status);
585  ApiStatus = NetpNtStatusToApiStatus(Status);
586  goto done;
587  }
588 
589  if ((level == 1) || (level == 2) || (level == 3) ||
590  (level == 4) || (level == 20) || (level == 23))
591  {
592  ApiStatus = GetUserDacl(UserHandle, &Dacl);
593  if (ApiStatus != NERR_Success)
594  goto done;
595  }
596 
597  if ((level == 1) || (level == 2) || (level == 3) ||
598  (level == 4) || (level == 11))
599  {
600  ApiStatus = GetUserPrivileges(BuiltinDomainHandle,
601  UserHandle,
602  AccountDomainSid,
603  RelativeId,
604  &Priv,
605  &AuthFlags);
606  if (ApiStatus != NERR_Success)
607  goto done;
608  }
609 
610  switch (level)
611  {
612  case 0:
613  Size = sizeof(USER_INFO_0) +
614  UserInfo->UserName.Length + sizeof(WCHAR);
615  break;
616 
617  case 1:
618  Size = sizeof(USER_INFO_1) +
619  UserInfo->UserName.Length + sizeof(WCHAR) +
620  UserInfo->HomeDirectory.Length + sizeof(WCHAR) +
621  UserInfo->AdminComment.Length + sizeof(WCHAR) +
622  UserInfo->ScriptPath.Length + sizeof(WCHAR);
623  break;
624 
625  case 2:
626  Size = sizeof(USER_INFO_2) +
627  UserInfo->UserName.Length + sizeof(WCHAR) +
628  UserInfo->HomeDirectory.Length + sizeof(WCHAR) +
629  UserInfo->AdminComment.Length + sizeof(WCHAR) +
630  UserInfo->ScriptPath.Length + sizeof(WCHAR) +
631  UserInfo->FullName.Length + sizeof(WCHAR) +
632  UserInfo->UserComment.Length + sizeof(WCHAR) +
633  UserInfo->Parameters.Length + sizeof(WCHAR) +
634  UserInfo->WorkStations.Length + sizeof(WCHAR) +
635  LogonServer.Length + sizeof(WCHAR);
636 
637  if (UserInfo->LogonHours.UnitsPerWeek > 0)
638  Size += (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8;
639  break;
640 
641  case 3:
642  Size = sizeof(USER_INFO_3) +
643  UserInfo->UserName.Length + sizeof(WCHAR) +
644  UserInfo->HomeDirectory.Length + sizeof(WCHAR) +
645  UserInfo->AdminComment.Length + sizeof(WCHAR) +
646  UserInfo->ScriptPath.Length + sizeof(WCHAR) +
647  UserInfo->FullName.Length + sizeof(WCHAR) +
648  UserInfo->UserComment.Length + sizeof(WCHAR) +
649  UserInfo->Parameters.Length + sizeof(WCHAR) +
650  UserInfo->WorkStations.Length + sizeof(WCHAR) +
651  LogonServer.Length + sizeof(WCHAR) +
652  UserInfo->ProfilePath.Length + sizeof(WCHAR) +
653  UserInfo->HomeDirectoryDrive.Length + sizeof(WCHAR);
654 
655  if (UserInfo->LogonHours.UnitsPerWeek > 0)
656  Size += (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8;
657  break;
658 
659  case 4:
660  Size = sizeof(USER_INFO_4) +
661  UserInfo->UserName.Length + sizeof(WCHAR) +
662  UserInfo->HomeDirectory.Length + sizeof(WCHAR) +
663  UserInfo->AdminComment.Length + sizeof(WCHAR) +
664  UserInfo->ScriptPath.Length + sizeof(WCHAR) +
665  UserInfo->FullName.Length + sizeof(WCHAR) +
666  UserInfo->UserComment.Length + sizeof(WCHAR) +
667  UserInfo->Parameters.Length + sizeof(WCHAR) +
668  UserInfo->WorkStations.Length + sizeof(WCHAR) +
669  LogonServer.Length + sizeof(WCHAR) +
670  UserInfo->ProfilePath.Length + sizeof(WCHAR) +
671  UserInfo->HomeDirectoryDrive.Length + sizeof(WCHAR);
672 
673  if (UserInfo->LogonHours.UnitsPerWeek > 0)
674  Size += (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8;
675 
676  Size += RtlLengthSid(AccountDomainSid) + sizeof(ULONG);
677  break;
678 
679  case 10:
680  Size = sizeof(USER_INFO_10) +
681  UserInfo->UserName.Length + sizeof(WCHAR) +
682  UserInfo->AdminComment.Length + sizeof(WCHAR) +
683  UserInfo->UserComment.Length + sizeof(WCHAR) +
684  UserInfo->FullName.Length + sizeof(WCHAR);
685  break;
686 
687  case 11:
688  Size = sizeof(USER_INFO_11) +
689  UserInfo->UserName.Length + sizeof(WCHAR) +
690  UserInfo->AdminComment.Length + sizeof(WCHAR) +
691  UserInfo->UserComment.Length + sizeof(WCHAR) +
692  UserInfo->FullName.Length + sizeof(WCHAR) +
693  UserInfo->HomeDirectory.Length + sizeof(WCHAR) +
694  UserInfo->Parameters.Length + sizeof(WCHAR) +
695  LogonServer.Length + sizeof(WCHAR) +
696  UserInfo->WorkStations.Length + sizeof(WCHAR);
697 
698  if (UserInfo->LogonHours.UnitsPerWeek > 0)
699  Size += (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8;
700  break;
701 
702  case 20:
703  Size = sizeof(USER_INFO_20) +
704  UserInfo->UserName.Length + sizeof(WCHAR) +
705  UserInfo->FullName.Length + sizeof(WCHAR) +
706  UserInfo->AdminComment.Length + sizeof(WCHAR);
707  break;
708 
709  case 23:
710  Size = sizeof(USER_INFO_23) +
711  UserInfo->UserName.Length + sizeof(WCHAR) +
712  UserInfo->FullName.Length + sizeof(WCHAR) +
713  UserInfo->AdminComment.Length + sizeof(WCHAR);
714 
715  Size += RtlLengthSid(AccountDomainSid) + sizeof(ULONG);
716  break;
717 
718  default:
719  ApiStatus = ERROR_INVALID_LEVEL;
720  goto done;
721  }
722 
723  ApiStatus = NetApiBufferAllocate(Size, &LocalBuffer);
724  if (ApiStatus != NERR_Success)
725  goto done;
726 
727  ZeroMemory(LocalBuffer, Size);
728 
729  switch (level)
730  {
731  case 0:
732  UserInfo0 = (PUSER_INFO_0)LocalBuffer;
733 
734  Ptr = (LPWSTR)((ULONG_PTR)UserInfo0 + sizeof(USER_INFO_0));
735 
736  UserInfo0->usri0_name = Ptr;
737 
738  memcpy(UserInfo0->usri0_name,
739  UserInfo->UserName.Buffer,
740  UserInfo->UserName.Length);
741  UserInfo0->usri0_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
742  break;
743 
744  case 1:
745  UserInfo1 = (PUSER_INFO_1)LocalBuffer;
746 
747  Ptr = (LPWSTR)((ULONG_PTR)UserInfo1 + sizeof(USER_INFO_1));
748 
749  UserInfo1->usri1_name = Ptr;
750 
751  memcpy(UserInfo1->usri1_name,
752  UserInfo->UserName.Buffer,
753  UserInfo->UserName.Length);
754  UserInfo1->usri1_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
755 
756  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
757 
758  UserInfo1->usri1_password = NULL;
759  UserInfo1->usri1_password_age = GetPasswordAge(&UserInfo->PasswordLastSet);
760 
761  UserInfo1->usri1_priv = Priv;
762 
763  UserInfo1->usri1_home_dir = Ptr;
764  memcpy(UserInfo1->usri1_home_dir,
765  UserInfo->HomeDirectory.Buffer,
766  UserInfo->HomeDirectory.Length);
767  UserInfo1->usri1_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
768  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
769 
770  UserInfo1->usri1_comment = Ptr;
771  memcpy(UserInfo1->usri1_comment,
772  UserInfo->AdminComment.Buffer,
773  UserInfo->AdminComment.Length);
774  UserInfo1->usri1_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
775  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
776 
777  UserInfo1->usri1_flags = GetAccountFlags(UserInfo->UserAccountControl,
778  Dacl);
779 
780  UserInfo1->usri1_script_path = Ptr;
781  memcpy(UserInfo1->usri1_script_path,
782  UserInfo->ScriptPath.Buffer,
783  UserInfo->ScriptPath.Length);
784  UserInfo1->usri1_script_path[UserInfo->ScriptPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
785  break;
786 
787  case 2:
788  UserInfo2 = (PUSER_INFO_2)LocalBuffer;
789 
790  Ptr = (LPWSTR)((ULONG_PTR)UserInfo2 + sizeof(USER_INFO_2));
791 
792  UserInfo2->usri2_name = Ptr;
793 
794  memcpy(UserInfo2->usri2_name,
795  UserInfo->UserName.Buffer,
796  UserInfo->UserName.Length);
797  UserInfo2->usri2_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
798 
799  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
800 
801  UserInfo2->usri2_password = NULL;
802  UserInfo2->usri2_password_age = GetPasswordAge(&UserInfo->PasswordLastSet);
803 
804  UserInfo2->usri2_priv = Priv;
805 
806  UserInfo2->usri2_home_dir = Ptr;
807  memcpy(UserInfo2->usri2_home_dir,
808  UserInfo->HomeDirectory.Buffer,
809  UserInfo->HomeDirectory.Length);
810  UserInfo2->usri2_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
811  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
812 
813  UserInfo2->usri2_comment = Ptr;
814  memcpy(UserInfo2->usri2_comment,
815  UserInfo->AdminComment.Buffer,
816  UserInfo->AdminComment.Length);
817  UserInfo2->usri2_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
818  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
819 
820  UserInfo2->usri2_flags = GetAccountFlags(UserInfo->UserAccountControl,
821  Dacl);
822 
823  UserInfo2->usri2_script_path = Ptr;
824  memcpy(UserInfo2->usri2_script_path,
825  UserInfo->ScriptPath.Buffer,
826  UserInfo->ScriptPath.Length);
827  UserInfo2->usri2_script_path[UserInfo->ScriptPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
828  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->ScriptPath.Length + sizeof(WCHAR));
829 
830  UserInfo2->usri2_auth_flags = AuthFlags;
831 
832  UserInfo2->usri2_full_name = Ptr;
833  memcpy(UserInfo2->usri2_full_name,
834  UserInfo->FullName.Buffer,
835  UserInfo->FullName.Length);
836  UserInfo2->usri2_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
837  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
838 
839  UserInfo2->usri2_usr_comment = Ptr;
840  memcpy(UserInfo2->usri2_usr_comment,
841  UserInfo->UserComment.Buffer,
842  UserInfo->UserComment.Length);
843  UserInfo2->usri2_usr_comment[UserInfo->UserComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
844  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserComment.Length + sizeof(WCHAR));
845 
846  UserInfo2->usri2_parms = Ptr;
847  memcpy(UserInfo2->usri2_parms,
848  UserInfo->Parameters.Buffer,
849  UserInfo->Parameters.Length);
850  UserInfo2->usri2_parms[UserInfo->Parameters.Length / sizeof(WCHAR)] = UNICODE_NULL;
851  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->Parameters.Length + sizeof(WCHAR));
852 
853  UserInfo2->usri2_workstations = Ptr;
854  memcpy(UserInfo2->usri2_workstations,
855  UserInfo->WorkStations.Buffer,
856  UserInfo->WorkStations.Length);
857  UserInfo2->usri2_workstations[UserInfo->WorkStations.Length / sizeof(WCHAR)] = UNICODE_NULL;
858  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->WorkStations.Length + sizeof(WCHAR));
859 
860  if (UserInfo->LastLogon.QuadPart == 0)
861  UserInfo2->usri2_last_logon = 0;
862  else
863  RtlTimeToSecondsSince1970(&UserInfo->LastLogon,
864  &UserInfo2->usri2_last_logon);
865 
866  if (UserInfo->LastLogoff.QuadPart == 0)
867  UserInfo2->usri2_last_logoff = 0;
868  else
869  RtlTimeToSecondsSince1970(&UserInfo->LastLogoff,
870  &UserInfo2->usri2_last_logoff);
871 
872  if (UserInfo->AccountExpires.QuadPart == MAXLONGLONG)
873  UserInfo2->usri2_acct_expires = TIMEQ_FOREVER;
874  else
875  RtlTimeToSecondsSince1970(&UserInfo->AccountExpires,
876  &UserInfo2->usri2_acct_expires);
877 
878  UserInfo2->usri2_max_storage = USER_MAXSTORAGE_UNLIMITED;
879  UserInfo2->usri2_units_per_week = UserInfo->LogonHours.UnitsPerWeek;
880 
881  if (UserInfo->LogonHours.UnitsPerWeek > 0)
882  {
883  UserInfo2->usri2_logon_hours = (PVOID)Ptr;
884 
885  memcpy(UserInfo2->usri2_logon_hours,
886  UserInfo->LogonHours.LogonHours,
887  (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
888 
889  Ptr = (LPWSTR)((ULONG_PTR)Ptr + (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
890  }
891 
892  UserInfo2->usri2_bad_pw_count = UserInfo->BadPasswordCount;
893  UserInfo2->usri2_num_logons = UserInfo->LogonCount;
894 
895  UserInfo2->usri2_logon_server = Ptr;
896  memcpy(UserInfo2->usri2_logon_server,
897  LogonServer.Buffer,
898  LogonServer.Length);
899  UserInfo2->usri2_logon_server[LogonServer.Length / sizeof(WCHAR)] = UNICODE_NULL;
900  Ptr = (LPWSTR)((ULONG_PTR)Ptr + LogonServer.Length + sizeof(WCHAR));
901 
902  UserInfo2->usri2_country_code = UserInfo->CountryCode;
903  UserInfo2->usri2_code_page = UserInfo->CodePage;
904  break;
905 
906  case 3:
907  UserInfo3 = (PUSER_INFO_3)LocalBuffer;
908 
909  Ptr = (LPWSTR)((ULONG_PTR)UserInfo3 + sizeof(USER_INFO_3));
910 
911  UserInfo3->usri3_name = Ptr;
912 
913  memcpy(UserInfo3->usri3_name,
914  UserInfo->UserName.Buffer,
915  UserInfo->UserName.Length);
916  UserInfo3->usri3_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
917 
918  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
919 
920  UserInfo3->usri3_password = NULL;
921  UserInfo3->usri3_password_age = GetPasswordAge(&UserInfo->PasswordLastSet);
922 
923  UserInfo3->usri3_priv = Priv;
924 
925  UserInfo3->usri3_home_dir = Ptr;
926  memcpy(UserInfo3->usri3_home_dir,
927  UserInfo->HomeDirectory.Buffer,
928  UserInfo->HomeDirectory.Length);
929  UserInfo3->usri3_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
930  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
931 
932  UserInfo3->usri3_comment = Ptr;
933  memcpy(UserInfo3->usri3_comment,
934  UserInfo->AdminComment.Buffer,
935  UserInfo->AdminComment.Length);
936  UserInfo3->usri3_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
937  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
938 
939  UserInfo3->usri3_flags = GetAccountFlags(UserInfo->UserAccountControl,
940  Dacl);
941 
942  UserInfo3->usri3_script_path = Ptr;
943  memcpy(UserInfo3->usri3_script_path,
944  UserInfo->ScriptPath.Buffer,
945  UserInfo->ScriptPath.Length);
946  UserInfo3->usri3_script_path[UserInfo->ScriptPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
947  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->ScriptPath.Length + sizeof(WCHAR));
948 
949  UserInfo3->usri3_auth_flags = AuthFlags;
950 
951  UserInfo3->usri3_full_name = Ptr;
952  memcpy(UserInfo3->usri3_full_name,
953  UserInfo->FullName.Buffer,
954  UserInfo->FullName.Length);
955  UserInfo3->usri3_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
956  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
957 
958  UserInfo3->usri3_usr_comment = Ptr;
959  memcpy(UserInfo3->usri3_usr_comment,
960  UserInfo->UserComment.Buffer,
961  UserInfo->UserComment.Length);
962  UserInfo3->usri3_usr_comment[UserInfo->UserComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
963  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserComment.Length + sizeof(WCHAR));
964 
965  UserInfo3->usri3_parms = Ptr;
966  memcpy(UserInfo3->usri3_parms,
967  UserInfo->Parameters.Buffer,
968  UserInfo->Parameters.Length);
969  UserInfo3->usri3_parms[UserInfo->Parameters.Length / sizeof(WCHAR)] = UNICODE_NULL;
970  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->Parameters.Length + sizeof(WCHAR));
971 
972  UserInfo3->usri3_workstations = Ptr;
973  memcpy(UserInfo3->usri3_workstations,
974  UserInfo->WorkStations.Buffer,
975  UserInfo->WorkStations.Length);
976  UserInfo3->usri3_workstations[UserInfo->WorkStations.Length / sizeof(WCHAR)] = UNICODE_NULL;
977  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->WorkStations.Length + sizeof(WCHAR));
978 
979  if (UserInfo->LastLogon.QuadPart == 0)
980  UserInfo3->usri3_last_logon = 0;
981  else
982  RtlTimeToSecondsSince1970(&UserInfo->LastLogon,
983  &UserInfo3->usri3_last_logon);
984 
985  if (UserInfo->LastLogoff.QuadPart == 0)
986  UserInfo3->usri3_last_logoff = 0;
987  else
988  RtlTimeToSecondsSince1970(&UserInfo->LastLogoff,
989  &UserInfo3->usri3_last_logoff);
990 
991  if (UserInfo->AccountExpires.QuadPart == MAXLONGLONG)
992  UserInfo3->usri3_acct_expires = TIMEQ_FOREVER;
993  else
994  RtlTimeToSecondsSince1970(&UserInfo->AccountExpires,
995  &UserInfo3->usri3_acct_expires);
996 
997  UserInfo3->usri3_max_storage = USER_MAXSTORAGE_UNLIMITED;
998  UserInfo3->usri3_units_per_week = UserInfo->LogonHours.UnitsPerWeek;
999 
1000  if (UserInfo->LogonHours.UnitsPerWeek > 0)
1001  {
1002  UserInfo3->usri3_logon_hours = (PVOID)Ptr;
1003 
1004  memcpy(UserInfo3->usri3_logon_hours,
1005  UserInfo->LogonHours.LogonHours,
1006  (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1007 
1008  Ptr = (LPWSTR)((ULONG_PTR)Ptr + (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1009  }
1010 
1011  UserInfo3->usri3_bad_pw_count = UserInfo->BadPasswordCount;
1012  UserInfo3->usri3_num_logons = UserInfo->LogonCount;
1013 
1014  UserInfo3->usri3_logon_server = Ptr;
1015  memcpy(UserInfo3->usri3_logon_server,
1016  LogonServer.Buffer,
1017  LogonServer.Length);
1018  UserInfo3->usri3_logon_server[LogonServer.Length / sizeof(WCHAR)] = UNICODE_NULL;
1019  Ptr = (LPWSTR)((ULONG_PTR)Ptr + LogonServer.Length + sizeof(WCHAR));
1020 
1021  UserInfo3->usri3_country_code = UserInfo->CountryCode;
1022  UserInfo3->usri3_code_page = UserInfo->CodePage;
1023  UserInfo3->usri3_user_id = RelativeId;
1024  UserInfo3->usri3_primary_group_id = UserInfo->PrimaryGroupId;
1025 
1026  UserInfo3->usri3_profile = Ptr;
1027  memcpy(UserInfo3->usri3_profile,
1028  UserInfo->ProfilePath.Buffer,
1029  UserInfo->ProfilePath.Length);
1030  UserInfo3->usri3_profile[UserInfo->ProfilePath.Length / sizeof(WCHAR)] = UNICODE_NULL;
1031  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->ProfilePath.Length + sizeof(WCHAR));
1032 
1033  UserInfo3->usri3_home_dir_drive = Ptr;
1034  memcpy(UserInfo3->usri3_home_dir_drive,
1035  UserInfo->HomeDirectoryDrive.Buffer,
1036  UserInfo->HomeDirectoryDrive.Length);
1037  UserInfo3->usri3_home_dir_drive[UserInfo->HomeDirectoryDrive.Length / sizeof(WCHAR)] = UNICODE_NULL;
1038  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectoryDrive.Length + sizeof(WCHAR));
1039 
1040  UserInfo3->usri3_password_expired = (UserInfo->UserAccountControl & USER_PASSWORD_EXPIRED);
1041  break;
1042 
1043  case 4:
1044  UserInfo4 = (PUSER_INFO_4)LocalBuffer;
1045 
1046  Ptr = (LPWSTR)((ULONG_PTR)UserInfo4 + sizeof(USER_INFO_4));
1047 
1048  UserInfo4->usri4_name = Ptr;
1049 
1050  memcpy(UserInfo4->usri4_name,
1051  UserInfo->UserName.Buffer,
1052  UserInfo->UserName.Length);
1053  UserInfo4->usri4_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1054 
1055  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
1056 
1057  UserInfo4->usri4_password = NULL;
1058  UserInfo4->usri4_password_age = GetPasswordAge(&UserInfo->PasswordLastSet);
1059 
1060  UserInfo4->usri4_priv = Priv;
1061 
1062  UserInfo4->usri4_home_dir = Ptr;
1063  memcpy(UserInfo4->usri4_home_dir,
1064  UserInfo->HomeDirectory.Buffer,
1065  UserInfo->HomeDirectory.Length);
1066  UserInfo4->usri4_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
1067  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
1068 
1069  UserInfo4->usri4_comment = Ptr;
1070  memcpy(UserInfo4->usri4_comment,
1071  UserInfo->AdminComment.Buffer,
1072  UserInfo->AdminComment.Length);
1073  UserInfo4->usri4_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1074  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
1075 
1076  UserInfo4->usri4_flags = GetAccountFlags(UserInfo->UserAccountControl,
1077  Dacl);
1078 
1079  UserInfo4->usri4_script_path = Ptr;
1080  memcpy(UserInfo4->usri4_script_path,
1081  UserInfo->ScriptPath.Buffer,
1082  UserInfo->ScriptPath.Length);
1083  UserInfo4->usri4_script_path[UserInfo->ScriptPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
1084  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->ScriptPath.Length + sizeof(WCHAR));
1085 
1086  UserInfo4->usri4_auth_flags = AuthFlags;
1087 
1088  UserInfo4->usri4_full_name = Ptr;
1089  memcpy(UserInfo4->usri4_full_name,
1090  UserInfo->FullName.Buffer,
1091  UserInfo->FullName.Length);
1092  UserInfo4->usri4_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1093  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
1094 
1095  UserInfo4->usri4_usr_comment = Ptr;
1096  memcpy(UserInfo4->usri4_usr_comment,
1097  UserInfo->UserComment.Buffer,
1098  UserInfo->UserComment.Length);
1099  UserInfo4->usri4_usr_comment[UserInfo->UserComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1100  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserComment.Length + sizeof(WCHAR));
1101 
1102  UserInfo4->usri4_parms = Ptr;
1103  memcpy(UserInfo4->usri4_parms,
1104  UserInfo->Parameters.Buffer,
1105  UserInfo->Parameters.Length);
1106  UserInfo4->usri4_parms[UserInfo->Parameters.Length / sizeof(WCHAR)] = UNICODE_NULL;
1107  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->Parameters.Length + sizeof(WCHAR));
1108 
1109  UserInfo4->usri4_workstations = Ptr;
1110  memcpy(UserInfo4->usri4_workstations,
1111  UserInfo->WorkStations.Buffer,
1112  UserInfo->WorkStations.Length);
1113  UserInfo4->usri4_workstations[UserInfo->WorkStations.Length / sizeof(WCHAR)] = UNICODE_NULL;
1114  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->WorkStations.Length + sizeof(WCHAR));
1115 
1116  if (UserInfo->LastLogon.QuadPart == 0)
1117  UserInfo4->usri4_last_logon = 0;
1118  else
1119  RtlTimeToSecondsSince1970(&UserInfo->LastLogon,
1120  &UserInfo4->usri4_last_logon);
1121 
1122  if (UserInfo->LastLogoff.QuadPart == 0)
1123  UserInfo4->usri4_last_logoff = 0;
1124  else
1125  RtlTimeToSecondsSince1970(&UserInfo->LastLogoff,
1126  &UserInfo4->usri4_last_logoff);
1127 
1128  if (UserInfo->AccountExpires.QuadPart == MAXLONGLONG)
1129  UserInfo4->usri4_acct_expires = TIMEQ_FOREVER;
1130  else
1131  RtlTimeToSecondsSince1970(&UserInfo->AccountExpires,
1132  &UserInfo4->usri4_acct_expires);
1133 
1134  UserInfo4->usri4_max_storage = USER_MAXSTORAGE_UNLIMITED;
1135  UserInfo4->usri4_units_per_week = UserInfo->LogonHours.UnitsPerWeek;
1136 
1137  if (UserInfo->LogonHours.UnitsPerWeek > 0)
1138  {
1139  UserInfo4->usri4_logon_hours = (PVOID)Ptr;
1140 
1141  memcpy(UserInfo4->usri4_logon_hours,
1142  UserInfo->LogonHours.LogonHours,
1143  (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1144 
1145  Ptr = (LPWSTR)((ULONG_PTR)Ptr + (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1146  }
1147 
1148  UserInfo4->usri4_bad_pw_count = UserInfo->BadPasswordCount;
1149  UserInfo4->usri4_num_logons = UserInfo->LogonCount;
1150 
1151  UserInfo4->usri4_logon_server = Ptr;
1152  memcpy(UserInfo4->usri4_logon_server,
1153  LogonServer.Buffer,
1154  LogonServer.Length);
1155  UserInfo4->usri4_logon_server[LogonServer.Length / sizeof(WCHAR)] = UNICODE_NULL;
1156  Ptr = (LPWSTR)((ULONG_PTR)Ptr + LogonServer.Length + sizeof(WCHAR));
1157 
1158  UserInfo4->usri4_country_code = UserInfo->CountryCode;
1159  UserInfo4->usri4_code_page = UserInfo->CodePage;
1160 
1161  UserInfo4->usri4_user_sid = (PVOID)Ptr;
1162  CopySidFromSidAndRid(UserInfo4->usri4_user_sid, AccountDomainSid, RelativeId);
1163  Ptr = (LPWSTR)((ULONG_PTR)Ptr + RtlLengthSid(AccountDomainSid) + sizeof(ULONG));
1164 
1165  UserInfo4->usri4_primary_group_id = UserInfo->PrimaryGroupId;
1166 
1167  UserInfo4->usri4_profile = Ptr;
1168  memcpy(UserInfo4->usri4_profile,
1169  UserInfo->ProfilePath.Buffer,
1170  UserInfo->ProfilePath.Length);
1171  UserInfo4->usri4_profile[UserInfo->ProfilePath.Length / sizeof(WCHAR)] = UNICODE_NULL;
1172  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->ProfilePath.Length + sizeof(WCHAR));
1173 
1174  UserInfo4->usri4_home_dir_drive = Ptr;
1175  memcpy(UserInfo4->usri4_home_dir_drive,
1176  UserInfo->HomeDirectoryDrive.Buffer,
1177  UserInfo->HomeDirectoryDrive.Length);
1178  UserInfo4->usri4_home_dir_drive[UserInfo->HomeDirectoryDrive.Length / sizeof(WCHAR)] = UNICODE_NULL;
1179  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectoryDrive.Length + sizeof(WCHAR));
1180 
1181  UserInfo4->usri4_password_expired = (UserInfo->UserAccountControl & USER_PASSWORD_EXPIRED);
1182  break;
1183 
1184  case 10:
1185  UserInfo10 = (PUSER_INFO_10)LocalBuffer;
1186 
1187  Ptr = (LPWSTR)((ULONG_PTR)UserInfo10 + sizeof(USER_INFO_10));
1188 
1189  UserInfo10->usri10_name = Ptr;
1190 
1191  memcpy(UserInfo10->usri10_name,
1192  UserInfo->UserName.Buffer,
1193  UserInfo->UserName.Length);
1194  UserInfo10->usri10_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1195 
1196  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
1197 
1198  UserInfo10->usri10_comment = Ptr;
1199  memcpy(UserInfo10->usri10_comment,
1200  UserInfo->AdminComment.Buffer,
1201  UserInfo->AdminComment.Length);
1202  UserInfo10->usri10_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1203  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
1204 
1205  UserInfo10->usri10_usr_comment = Ptr;
1206  memcpy(UserInfo10->usri10_usr_comment,
1207  UserInfo->UserComment.Buffer,
1208  UserInfo->UserComment.Length);
1209  UserInfo10->usri10_usr_comment[UserInfo->UserComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1210  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserComment.Length + sizeof(WCHAR));
1211 
1212  UserInfo10->usri10_full_name = Ptr;
1213  memcpy(UserInfo10->usri10_full_name,
1214  UserInfo->FullName.Buffer,
1215  UserInfo->FullName.Length);
1216  UserInfo10->usri10_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1217  break;
1218 
1219  case 11:
1220  UserInfo11 = (PUSER_INFO_11)LocalBuffer;
1221 
1222  Ptr = (LPWSTR)((ULONG_PTR)UserInfo11 + sizeof(USER_INFO_11));
1223 
1224  UserInfo11->usri11_name = Ptr;
1225 
1226  memcpy(UserInfo11->usri11_name,
1227  UserInfo->UserName.Buffer,
1228  UserInfo->UserName.Length);
1229  UserInfo11->usri11_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1230 
1231  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
1232 
1233  UserInfo11->usri11_comment = Ptr;
1234  memcpy(UserInfo11->usri11_comment,
1235  UserInfo->AdminComment.Buffer,
1236  UserInfo->AdminComment.Length);
1237  UserInfo11->usri11_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1238  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
1239 
1240  UserInfo11->usri11_usr_comment = Ptr;
1241  memcpy(UserInfo11->usri11_usr_comment,
1242  UserInfo->UserComment.Buffer,
1243  UserInfo->UserComment.Length);
1244  UserInfo11->usri11_usr_comment[UserInfo->UserComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1245  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserComment.Length + sizeof(WCHAR));
1246 
1247  UserInfo11->usri11_full_name = Ptr;
1248  memcpy(UserInfo11->usri11_full_name,
1249  UserInfo->FullName.Buffer,
1250  UserInfo->FullName.Length);
1251  UserInfo11->usri11_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1252  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
1253 
1254  UserInfo11->usri11_priv = Priv;
1255  UserInfo11->usri11_auth_flags = AuthFlags;
1256 
1257  UserInfo11->usri11_password_age = GetPasswordAge(&UserInfo->PasswordLastSet);
1258 
1259  UserInfo11->usri11_home_dir = Ptr;
1260  memcpy(UserInfo11->usri11_home_dir,
1261  UserInfo->HomeDirectory.Buffer,
1262  UserInfo->HomeDirectory.Length);
1263  UserInfo11->usri11_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
1264  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
1265 
1266  UserInfo11->usri11_parms = Ptr;
1267  memcpy(UserInfo11->usri11_parms,
1268  UserInfo->Parameters.Buffer,
1269  UserInfo->Parameters.Length);
1270  UserInfo11->usri11_parms[UserInfo->Parameters.Length / sizeof(WCHAR)] = UNICODE_NULL;
1271  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->Parameters.Length + sizeof(WCHAR));
1272 
1273  if (UserInfo->LastLogon.QuadPart == 0)
1274  UserInfo11->usri11_last_logon = 0;
1275  else
1276  RtlTimeToSecondsSince1970(&UserInfo->LastLogon,
1277  &UserInfo11->usri11_last_logon);
1278 
1279  if (UserInfo->LastLogoff.QuadPart == 0)
1280  UserInfo11->usri11_last_logoff = 0;
1281  else
1282  RtlTimeToSecondsSince1970(&UserInfo->LastLogoff,
1283  &UserInfo11->usri11_last_logoff);
1284 
1285  UserInfo11->usri11_bad_pw_count = UserInfo->BadPasswordCount;
1286  UserInfo11->usri11_num_logons = UserInfo->LogonCount;
1287 
1288  UserInfo11->usri11_logon_server = Ptr;
1289  memcpy(UserInfo11->usri11_logon_server,
1290  LogonServer.Buffer,
1291  LogonServer.Length);
1292  UserInfo11->usri11_logon_server[LogonServer.Length / sizeof(WCHAR)] = UNICODE_NULL;
1293  Ptr = (LPWSTR)((ULONG_PTR)Ptr + LogonServer.Length + sizeof(WCHAR));
1294 
1295  UserInfo11->usri11_country_code = UserInfo->CountryCode;
1296 
1297  UserInfo11->usri11_workstations = Ptr;
1298  memcpy(UserInfo11->usri11_workstations,
1299  UserInfo->WorkStations.Buffer,
1300  UserInfo->WorkStations.Length);
1301  UserInfo11->usri11_workstations[UserInfo->WorkStations.Length / sizeof(WCHAR)] = UNICODE_NULL;
1302  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->WorkStations.Length + sizeof(WCHAR));
1303 
1304  UserInfo11->usri11_max_storage = USER_MAXSTORAGE_UNLIMITED;
1305  UserInfo11->usri11_units_per_week = UserInfo->LogonHours.UnitsPerWeek;
1306 
1307  if (UserInfo->LogonHours.UnitsPerWeek > 0)
1308  {
1309  UserInfo11->usri11_logon_hours = (PVOID)Ptr;
1310 
1311  memcpy(UserInfo11->usri11_logon_hours,
1312  UserInfo->LogonHours.LogonHours,
1313  (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1314 
1315  Ptr = (LPWSTR)((ULONG_PTR)Ptr + (((ULONG)UserInfo->LogonHours.UnitsPerWeek) + 7) / 8);
1316  }
1317 
1318  UserInfo11->usri11_code_page = UserInfo->CodePage;
1319  break;
1320 
1321  case 20:
1322  UserInfo20 = (PUSER_INFO_20)LocalBuffer;
1323 
1324  Ptr = (LPWSTR)((ULONG_PTR)UserInfo20 + sizeof(USER_INFO_20));
1325 
1326  UserInfo20->usri20_name = Ptr;
1327 
1328  memcpy(UserInfo20->usri20_name,
1329  UserInfo->UserName.Buffer,
1330  UserInfo->UserName.Length);
1331  UserInfo20->usri20_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1332 
1333  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
1334 
1335  UserInfo20->usri20_full_name = Ptr;
1336  memcpy(UserInfo20->usri20_full_name,
1337  UserInfo->FullName.Buffer,
1338  UserInfo->FullName.Length);
1339  UserInfo20->usri20_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1340  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
1341 
1342  UserInfo20->usri20_comment = Ptr;
1343  memcpy(UserInfo20->usri20_comment,
1344  UserInfo->AdminComment.Buffer,
1345  UserInfo->AdminComment.Length);
1346  UserInfo20->usri20_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1347  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
1348 
1349  UserInfo20->usri20_flags = GetAccountFlags(UserInfo->UserAccountControl,
1350  Dacl);
1351 
1352  UserInfo20->usri20_user_id = RelativeId;
1353  break;
1354 
1355  case 23:
1356  UserInfo23 = (PUSER_INFO_23)LocalBuffer;
1357 
1358  Ptr = (LPWSTR)((ULONG_PTR)UserInfo23 + sizeof(USER_INFO_23));
1359 
1360  UserInfo23->usri23_name = Ptr;
1361 
1362  memcpy(UserInfo23->usri23_name,
1363  UserInfo->UserName.Buffer,
1364  UserInfo->UserName.Length);
1365  UserInfo23->usri23_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1366 
1367  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
1368 
1369  UserInfo23->usri23_full_name = Ptr;
1370  memcpy(UserInfo23->usri23_full_name,
1371  UserInfo->FullName.Buffer,
1372  UserInfo->FullName.Length);
1373  UserInfo23->usri23_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1374  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
1375 
1376  UserInfo23->usri23_comment = Ptr;
1377  memcpy(UserInfo23->usri23_comment,
1378  UserInfo->AdminComment.Buffer,
1379  UserInfo->AdminComment.Length);
1380  UserInfo23->usri23_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
1381  Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
1382 
1383  UserInfo23->usri23_flags = GetAccountFlags(UserInfo->UserAccountControl,
1384  Dacl);
1385 
1386  UserInfo23->usri23_user_sid = (PVOID)Ptr;
1387  CopySidFromSidAndRid(UserInfo23->usri23_user_sid, AccountDomainSid, RelativeId);
1388  Ptr = (LPWSTR)((ULONG_PTR)Ptr + RtlLengthSid(AccountDomainSid) + sizeof(ULONG));
1389  break;
1390  }
1391 
1392 done:
1393  if (UserInfo != NULL)
1394  FreeUserInfo(UserInfo);
1395 
1396  if (Dacl != NULL)
1397  HeapFree(GetProcessHeap(), 0, Dacl);
1398 
1399  if (ApiStatus == NERR_Success)
1400  {
1401  *Buffer = LocalBuffer;
1402  }
1403  else
1404  {
1405  if (LocalBuffer != NULL)
1406  NetApiBufferFree(LocalBuffer);
1407  }
1408 
1409  return ApiStatus;
1410 }
1411 
1412 
1413 static
1414 NET_API_STATUS
1415 SetUserInfo(SAM_HANDLE UserHandle,
1416  LPBYTE UserInfo,
1417  DWORD Level,
1418  PDWORD parm_err)
1419 {
1420  USER_ALL_INFORMATION UserAllInfo;
1421  PUSER_INFO_0 UserInfo0;
1422  PUSER_INFO_1 UserInfo1;
1423  PUSER_INFO_2 UserInfo2;
1424  PUSER_INFO_3 UserInfo3;
1425  PUSER_INFO_4 UserInfo4;
1426  PUSER_INFO_22 UserInfo22;
1427  PUSER_INFO_1003 UserInfo1003;
1428  PUSER_INFO_1006 UserInfo1006;
1429  PUSER_INFO_1007 UserInfo1007;
1430  PUSER_INFO_1008 UserInfo1008;
1431  PUSER_INFO_1009 UserInfo1009;
1432  PUSER_INFO_1011 UserInfo1011;
1433  PUSER_INFO_1012 UserInfo1012;
1434  PUSER_INFO_1013 UserInfo1013;
1435  PUSER_INFO_1014 UserInfo1014;
1436  PUSER_INFO_1017 UserInfo1017;
1437  PUSER_INFO_1020 UserInfo1020;
1438  PUSER_INFO_1024 UserInfo1024;
1439  PUSER_INFO_1025 UserInfo1025;
1440  PUSER_INFO_1051 UserInfo1051;
1441  PUSER_INFO_1052 UserInfo1052;
1442  PUSER_INFO_1053 UserInfo1053;
1443  PACL Dacl = NULL;
1444  NET_API_STATUS ApiStatus = NERR_Success;
1445  NTSTATUS Status = STATUS_SUCCESS;
1446 
1447  ZeroMemory(&UserAllInfo, sizeof(USER_ALL_INFORMATION));
1448 
1449  if ((Level == 1) || (Level == 2) || (Level == 3) ||
1450  (Level == 4) || (Level == 22) || (Level == 1008))
1451  {
1452  ApiStatus = GetUserDacl(UserHandle, &Dacl);
1453  if (ApiStatus != NERR_Success)
1454  goto done;
1455  }
1456 
1457  switch (Level)
1458  {
1459  case 0:
1460  UserInfo0 = (PUSER_INFO_0)UserInfo;
1461 
1462  RtlInitUnicodeString(&UserAllInfo.UserName,
1463  UserInfo0->usri0_name);
1464 
1465  UserAllInfo.WhichFields |= USER_ALL_USERNAME;
1466  break;
1467 
1468  case 1:
1469  UserInfo1 = (PUSER_INFO_1)UserInfo;
1470 
1471  // usri1_name ignored
1472 
1473  if (UserInfo1->usri1_password != NULL)
1474  {
1475  RtlInitUnicodeString(&UserAllInfo.NtPassword,
1476  UserInfo1->usri1_password);
1477  UserAllInfo.NtPasswordPresent = TRUE;
1478  UserAllInfo.WhichFields |= USER_ALL_NTPASSWORDPRESENT;
1479  }
1480 
1481  // usri1_password_age ignored
1482 
1483 // UserInfo1->usri1_priv
1484 
1485  if (UserInfo1->usri1_home_dir != NULL)
1486  {
1487  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
1488  UserInfo1->usri1_home_dir);
1489  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
1490  }
1491 
1492  if (UserInfo1->usri1_comment != NULL)
1493  {
1494  RtlInitUnicodeString(&UserAllInfo.AdminComment,
1495  UserInfo1->usri1_comment);
1496  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
1497  }
1498 
1499  ChangeUserDacl(Dacl, UserInfo1->usri1_flags);
1500  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo1->usri1_flags);
1501  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
1502 
1503  if (UserInfo1->usri1_script_path != NULL)
1504  {
1505  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
1506  UserInfo1->usri1_script_path);
1507  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
1508  }
1509  break;
1510 
1511  case 2:
1512  UserInfo2 = (PUSER_INFO_2)UserInfo;
1513 
1514  // usri2_name ignored
1515 
1516  if (UserInfo2->usri2_password != NULL)
1517  {
1518  RtlInitUnicodeString(&UserAllInfo.NtPassword,
1519  UserInfo2->usri2_password);
1520  UserAllInfo.NtPasswordPresent = TRUE;
1521  UserAllInfo.WhichFields |= USER_ALL_NTPASSWORDPRESENT;
1522  }
1523 
1524  // usri2_password_age ignored
1525 
1526 // UserInfo2->usri2_priv;
1527 
1528  if (UserInfo2->usri2_home_dir != NULL)
1529  {
1530  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
1531  UserInfo2->usri2_home_dir);
1532  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
1533  }
1534 
1535  if (UserInfo2->usri2_comment != NULL)
1536  {
1537  RtlInitUnicodeString(&UserAllInfo.AdminComment,
1538  UserInfo2->usri2_comment);
1539  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
1540  }
1541 
1542  ChangeUserDacl(Dacl, UserInfo2->usri2_flags);
1543  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo2->usri2_flags);
1544  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
1545 
1546  if (UserInfo2->usri2_script_path != NULL)
1547  {
1548  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
1549  UserInfo2->usri2_script_path);
1550  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
1551  }
1552 
1553 // UserInfo2->usri2_auth_flags;
1554 
1555  if (UserInfo2->usri2_full_name != NULL)
1556  {
1557  RtlInitUnicodeString(&UserAllInfo.FullName,
1558  UserInfo2->usri2_full_name);
1559  UserAllInfo.WhichFields |= USER_ALL_FULLNAME;
1560  }
1561 
1562  if (UserInfo2->usri2_usr_comment != NULL)
1563  {
1564  RtlInitUnicodeString(&UserAllInfo.UserComment,
1565  UserInfo2->usri2_usr_comment);
1566  UserAllInfo.WhichFields |= USER_ALL_USERCOMMENT;
1567  }
1568 
1569  if (UserInfo2->usri2_parms != NULL)
1570  {
1571  RtlInitUnicodeString(&UserAllInfo.Parameters,
1572  UserInfo2->usri2_parms);
1573  UserAllInfo.WhichFields |= USER_ALL_PARAMETERS;
1574  }
1575 
1576  if (UserInfo2->usri2_workstations != NULL)
1577  {
1578  RtlInitUnicodeString(&UserAllInfo.WorkStations,
1579  UserInfo2->usri2_workstations);
1580  UserAllInfo.WhichFields |= USER_ALL_WORKSTATIONS;
1581  }
1582 
1583  // usri2_last_logon ignored
1584  // usri2_last_logoff ignored
1585 
1586  if (UserInfo2->usri2_acct_expires == TIMEQ_FOREVER)
1587  {
1588  UserAllInfo.AccountExpires.QuadPart = MAXLONGLONG;
1589  }
1590  else
1591  {
1592  RtlSecondsSince1970ToTime(UserInfo2->usri2_acct_expires,
1593  &UserAllInfo.AccountExpires);
1594  }
1595  UserAllInfo.WhichFields |= USER_ALL_ACCOUNTEXPIRES;
1596 
1597  // usri2_max_storage ignored
1598 
1599  if (UserInfo2->usri2_logon_hours != NULL)
1600  {
1601  if (UserInfo2->usri2_units_per_week > USHRT_MAX)
1602  {
1603  if (parm_err != NULL)
1604  *parm_err = USER_UNITS_PER_WEEK_PARMNUM;
1605  ApiStatus = ERROR_INVALID_PARAMETER;
1606  break;
1607  }
1608 
1609  UserAllInfo.LogonHours.UnitsPerWeek = UserInfo2->usri2_units_per_week;
1610  UserAllInfo.LogonHours.LogonHours = UserInfo2->usri2_logon_hours;
1611  UserAllInfo.WhichFields |= USER_ALL_LOGONHOURS;
1612  }
1613 
1614  // usri2_bad_pw_count ignored
1615  // usri2_num_logons ignored
1616  // usri2_logon_server ignored
1617 
1618  UserAllInfo.CountryCode = UserInfo2->usri2_country_code;
1619  UserAllInfo.WhichFields |= USER_ALL_COUNTRYCODE;
1620 
1621  UserAllInfo.CodePage = UserInfo2->usri2_code_page;
1622  UserAllInfo.WhichFields |= USER_ALL_CODEPAGE;
1623  break;
1624 
1625  case 3:
1626  UserInfo3 = (PUSER_INFO_3)UserInfo;
1627 
1628  // usri3_name ignored
1629 
1630  if (UserInfo3->usri3_password != NULL)
1631  {
1632  RtlInitUnicodeString(&UserAllInfo.NtPassword,
1633  UserInfo3->usri3_password);
1634  UserAllInfo.NtPasswordPresent = TRUE;
1635  UserAllInfo.WhichFields |= USER_ALL_NTPASSWORDPRESENT;
1636  }
1637 
1638  // usri3_password_age ignored
1639 
1640 // UserInfo3->usri3_priv;
1641 
1642  if (UserInfo3->usri3_home_dir != NULL)
1643  {
1644  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
1645  UserInfo3->usri3_home_dir);
1646  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
1647  }
1648 
1649  if (UserInfo3->usri3_comment != NULL)
1650  {
1651  RtlInitUnicodeString(&UserAllInfo.AdminComment,
1652  UserInfo3->usri3_comment);
1653  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
1654  }
1655 
1656  ChangeUserDacl(Dacl, UserInfo3->usri3_flags);
1657  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo3->usri3_flags);
1658  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
1659 
1660  if (UserInfo3->usri3_script_path != NULL)
1661  {
1662  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
1663  UserInfo3->usri3_script_path);
1664  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
1665  }
1666 
1667 // UserInfo3->usri3_auth_flags;
1668 
1669  if (UserInfo3->usri3_full_name != NULL)
1670  {
1671  RtlInitUnicodeString(&UserAllInfo.FullName,
1672  UserInfo3->usri3_full_name);
1673  UserAllInfo.WhichFields |= USER_ALL_FULLNAME;
1674  }
1675 
1676  if (UserInfo3->usri3_usr_comment != NULL)
1677  {
1678  RtlInitUnicodeString(&UserAllInfo.UserComment,
1679  UserInfo3->usri3_usr_comment);
1680  UserAllInfo.WhichFields |= USER_ALL_USERCOMMENT;
1681  }
1682 
1683  if (UserInfo3->usri3_parms != NULL)
1684  {
1685  RtlInitUnicodeString(&UserAllInfo.Parameters,
1686  UserInfo3->usri3_parms);
1687  UserAllInfo.WhichFields |= USER_ALL_PARAMETERS;
1688  }
1689 
1690  if (UserInfo3->usri3_workstations != NULL)
1691  {
1692  RtlInitUnicodeString(&UserAllInfo.WorkStations,
1693  UserInfo3->usri3_workstations);
1694  UserAllInfo.WhichFields |= USER_ALL_WORKSTATIONS;
1695  }
1696 
1697  // usri3_last_logon ignored
1698  // usri3_last_logoff ignored
1699 
1700  if (UserInfo3->usri3_acct_expires == TIMEQ_FOREVER)
1701  {
1702  UserAllInfo.AccountExpires.QuadPart = MAXLONGLONG;
1703  }
1704  else
1705  {
1706  RtlSecondsSince1970ToTime(UserInfo3->usri3_acct_expires,
1707  &UserAllInfo.AccountExpires);
1708  }
1709  UserAllInfo.WhichFields |= USER_ALL_ACCOUNTEXPIRES;
1710 
1711  // usri3_max_storage ignored
1712 
1713  if (UserInfo3->usri3_logon_hours != NULL)
1714  {
1715  if (UserInfo3->usri3_units_per_week > USHRT_MAX)
1716  {
1717  if (parm_err != NULL)
1718  *parm_err = USER_UNITS_PER_WEEK_PARMNUM;
1719  ApiStatus = ERROR_INVALID_PARAMETER;
1720  break;
1721  }
1722 
1723  UserAllInfo.LogonHours.UnitsPerWeek = UserInfo3->usri3_units_per_week;
1724  UserAllInfo.LogonHours.LogonHours = UserInfo3->usri3_logon_hours;
1725  UserAllInfo.WhichFields |= USER_ALL_LOGONHOURS;
1726  }
1727 
1728  // usri3_bad_pw_count ignored
1729  // usri3_num_logons ignored
1730  // usri3_logon_server ignored
1731 
1732  UserAllInfo.CountryCode = UserInfo3->usri3_country_code;
1733  UserAllInfo.WhichFields |= USER_ALL_COUNTRYCODE;
1734 
1735  UserAllInfo.CodePage = UserInfo3->usri3_code_page;
1736  UserAllInfo.WhichFields |= USER_ALL_CODEPAGE;
1737 
1738  // usri3_user_id ignored
1739 
1740  UserAllInfo.PrimaryGroupId = UserInfo3->usri3_primary_group_id;
1741  UserAllInfo.WhichFields |= USER_ALL_PRIMARYGROUPID;
1742 
1743  if (UserInfo3->usri3_profile != NULL)
1744  {
1745  RtlInitUnicodeString(&UserAllInfo.ProfilePath,
1746  UserInfo3->usri3_profile);
1747  UserAllInfo.WhichFields |= USER_ALL_PROFILEPATH;
1748  }
1749 
1750  if (UserInfo3->usri3_home_dir_drive != NULL)
1751  {
1752  RtlInitUnicodeString(&UserAllInfo.HomeDirectoryDrive,
1753  UserInfo3->usri3_home_dir_drive);
1754  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORYDRIVE;
1755  }
1756 
1757  UserAllInfo.PasswordExpired = (UserInfo3->usri3_password_expired != 0);
1758  UserAllInfo.WhichFields |= USER_ALL_PASSWORDEXPIRED;
1759  break;
1760 
1761  case 4:
1762  UserInfo4 = (PUSER_INFO_4)UserInfo;
1763 
1764  // usri4_name ignored
1765 
1766  if (UserInfo4->usri4_password != NULL)
1767  {
1768  RtlInitUnicodeString(&UserAllInfo.NtPassword,
1769  UserInfo4->usri4_password);
1770  UserAllInfo.NtPasswordPresent = TRUE;
1771  UserAllInfo.WhichFields |= USER_ALL_NTPASSWORDPRESENT;
1772  }
1773 
1774  // usri4_password_age ignored
1775 
1776 // UserInfo3->usri4_priv;
1777 
1778  if (UserInfo4->usri4_home_dir != NULL)
1779  {
1780  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
1781  UserInfo4->usri4_home_dir);
1782  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
1783  }
1784 
1785  if (UserInfo4->usri4_comment != NULL)
1786  {
1787  RtlInitUnicodeString(&UserAllInfo.AdminComment,
1788  UserInfo4->usri4_comment);
1789  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
1790  }
1791 
1792  ChangeUserDacl(Dacl, UserInfo4->usri4_flags);
1793  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo4->usri4_flags);
1794  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
1795 
1796  if (UserInfo4->usri4_script_path != NULL)
1797  {
1798  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
1799  UserInfo4->usri4_script_path);
1800  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
1801  }
1802 
1803 // UserInfo4->usri4_auth_flags;
1804 
1805  if (UserInfo4->usri4_full_name != NULL)
1806  {
1807  RtlInitUnicodeString(&UserAllInfo.FullName,
1808  UserInfo4->usri4_full_name);
1809  UserAllInfo.WhichFields |= USER_ALL_FULLNAME;
1810  }
1811 
1812  if (UserInfo4->usri4_usr_comment != NULL)
1813  {
1814  RtlInitUnicodeString(&UserAllInfo.UserComment,
1815  UserInfo4->usri4_usr_comment);
1816  UserAllInfo.WhichFields |= USER_ALL_USERCOMMENT;
1817  }
1818 
1819  if (UserInfo4->usri4_parms != NULL)
1820  {
1821  RtlInitUnicodeString(&UserAllInfo.Parameters,
1822  UserInfo4->usri4_parms);
1823  UserAllInfo.WhichFields |= USER_ALL_PARAMETERS;
1824  }
1825 
1826  if (UserInfo4->usri4_workstations != NULL)
1827  {
1828  RtlInitUnicodeString(&UserAllInfo.WorkStations,
1829  UserInfo4->usri4_workstations);
1830  UserAllInfo.WhichFields |= USER_ALL_WORKSTATIONS;
1831  }
1832 
1833  // usri4_last_logon ignored
1834  // usri4_last_logoff ignored
1835 
1836  if (UserInfo4->usri4_acct_expires == TIMEQ_FOREVER)
1837  {
1838  UserAllInfo.AccountExpires.QuadPart = MAXLONGLONG;
1839  }
1840  else
1841  {
1842  RtlSecondsSince1970ToTime(UserInfo4->usri4_acct_expires,
1843  &UserAllInfo.AccountExpires);
1844  }
1845  UserAllInfo.WhichFields |= USER_ALL_ACCOUNTEXPIRES;
1846 
1847  // usri4_max_storage ignored
1848 
1849  if (UserInfo4->usri4_logon_hours != NULL)
1850  {
1851  if (UserInfo4->usri4_units_per_week > USHRT_MAX)
1852  {
1853  if (parm_err != NULL)
1854  *parm_err = USER_UNITS_PER_WEEK_PARMNUM;
1855  ApiStatus = ERROR_INVALID_PARAMETER;
1856  break;
1857  }
1858 
1859  UserAllInfo.LogonHours.UnitsPerWeek = UserInfo4->usri4_units_per_week;
1860  UserAllInfo.LogonHours.LogonHours = UserInfo4->usri4_logon_hours;
1861  UserAllInfo.WhichFields |= USER_ALL_LOGONHOURS;
1862  }
1863 
1864  // usri4_bad_pw_count ignored
1865  // usri4_num_logons ignored
1866  // usri4_logon_server ignored
1867 
1868  UserAllInfo.CountryCode = UserInfo4->usri4_country_code;
1869  UserAllInfo.WhichFields |= USER_ALL_COUNTRYCODE;
1870 
1871  UserAllInfo.CodePage = UserInfo4->usri4_code_page;
1872  UserAllInfo.WhichFields |= USER_ALL_CODEPAGE;
1873 
1874  // usri4_user_sid ignored
1875 
1876  UserAllInfo.PrimaryGroupId = UserInfo4->usri4_primary_group_id;
1877  UserAllInfo.WhichFields |= USER_ALL_PRIMARYGROUPID;
1878 
1879  if (UserInfo4->usri4_profile != NULL)
1880  {
1881  RtlInitUnicodeString(&UserAllInfo.ProfilePath,
1882  UserInfo4->usri4_profile);
1883  UserAllInfo.WhichFields |= USER_ALL_PROFILEPATH;
1884  }
1885 
1886  if (UserInfo4->usri4_home_dir_drive != NULL)
1887  {
1888  RtlInitUnicodeString(&UserAllInfo.HomeDirectoryDrive,
1889  UserInfo4->usri4_home_dir_drive);
1890  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORYDRIVE;
1891  }
1892 
1893  UserAllInfo.PasswordExpired = (UserInfo4->usri4_password_expired != 0);
1894  UserAllInfo.WhichFields |= USER_ALL_PASSWORDEXPIRED;
1895  break;
1896 
1897 // case 21:
1898 // break;
1899 
1900  case 22:
1901  UserInfo22 = (PUSER_INFO_22)UserInfo;
1902 
1903  // usri22_name ignored
1904 
1905 // UserInfo22->usri22_password[ENCRYPTED_PWLEN];
1906 
1907  // usri22_password_age ignored
1908 
1909 // UserInfo3->usri3_priv;
1910 
1911  if (UserInfo22->usri22_home_dir != NULL)
1912  {
1913  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
1914  UserInfo22->usri22_home_dir);
1915  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
1916  }
1917 
1918  if (UserInfo22->usri22_comment != NULL)
1919  {
1920  RtlInitUnicodeString(&UserAllInfo.AdminComment,
1921  UserInfo22->usri22_comment);
1922  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
1923  }
1924 
1925  ChangeUserDacl(Dacl, UserInfo22->usri22_flags);
1926  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo22->usri22_flags);
1927  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
1928 
1929  if (UserInfo22->usri22_script_path != NULL)
1930  {
1931  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
1932  UserInfo22->usri22_script_path);
1933  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
1934  }
1935 
1936 // UserInfo22->usri22_auth_flags;
1937 
1938  if (UserInfo22->usri22_full_name != NULL)
1939  {
1940  RtlInitUnicodeString(&UserAllInfo.FullName,
1941  UserInfo22->usri22_full_name);
1942  UserAllInfo.WhichFields |= USER_ALL_FULLNAME;
1943  }
1944 
1945  if (UserInfo22->usri22_usr_comment != NULL)
1946  {
1947  RtlInitUnicodeString(&UserAllInfo.UserComment,
1948  UserInfo22->usri22_usr_comment);
1949  UserAllInfo.WhichFields |= USER_ALL_USERCOMMENT;
1950  }
1951 
1952  if (UserInfo22->usri22_parms != NULL)
1953  {
1954  RtlInitUnicodeString(&UserAllInfo.Parameters,
1955  UserInfo22->usri22_parms);
1956  UserAllInfo.WhichFields |= USER_ALL_PARAMETERS;
1957  }
1958 
1959  if (UserInfo22->usri22_workstations != NULL)
1960  {
1961  RtlInitUnicodeString(&UserAllInfo.WorkStations,
1962  UserInfo22->usri22_workstations);
1963  UserAllInfo.WhichFields |= USER_ALL_WORKSTATIONS;
1964  }
1965 
1966  // usri22_last_logon ignored
1967  // usri22_last_logoff ignored
1968 
1969  if (UserInfo22->usri22_acct_expires == TIMEQ_FOREVER)
1970  {
1971  UserAllInfo.AccountExpires.QuadPart = MAXLONGLONG;
1972  }
1973  else
1974  {
1975  RtlSecondsSince1970ToTime(UserInfo22->usri22_acct_expires,
1976  &UserAllInfo.AccountExpires);
1977  }
1978  UserAllInfo.WhichFields |= USER_ALL_ACCOUNTEXPIRES;
1979 
1980  // usri22_max_storage ignored
1981 
1982  if (UserInfo22->usri22_logon_hours != NULL)
1983  {
1984  if (UserInfo22->usri22_units_per_week > USHRT_MAX)
1985  {
1986  if (parm_err != NULL)
1987  *parm_err = USER_UNITS_PER_WEEK_PARMNUM;
1988  ApiStatus = ERROR_INVALID_PARAMETER;
1989  break;
1990  }
1991 
1992  UserAllInfo.LogonHours.UnitsPerWeek = UserInfo22->usri22_units_per_week;
1993  UserAllInfo.LogonHours.LogonHours = UserInfo22->usri22_logon_hours;
1994  UserAllInfo.WhichFields |= USER_ALL_LOGONHOURS;
1995  }
1996 
1997  // usri22_bad_pw_count ignored
1998  // usri22_num_logons ignored
1999  // usri22_logon_server ignored
2000 
2001  UserAllInfo.CountryCode = UserInfo22->usri22_country_code;
2002  UserAllInfo.WhichFields |= USER_ALL_COUNTRYCODE;
2003 
2004  UserAllInfo.CodePage = UserInfo22->usri22_code_page;
2005  UserAllInfo.WhichFields |= USER_ALL_CODEPAGE;
2006  break;
2007 
2008  case 1003:
2009  UserInfo1003 = (PUSER_INFO_1003)UserInfo;
2010 
2011  if (UserInfo1003->usri1003_password != NULL)
2012  {
2013  RtlInitUnicodeString(&UserAllInfo.NtPassword,
2014  UserInfo1003->usri1003_password);
2015  UserAllInfo.NtPasswordPresent = TRUE;
2016  UserAllInfo.WhichFields |= USER_ALL_NTPASSWORDPRESENT;
2017  }
2018  break;
2019 
2020 // case 1005:
2021 // break;
2022 
2023  case 1006:
2024  UserInfo1006 = (PUSER_INFO_1006)UserInfo;
2025 
2026  if (UserInfo1006->usri1006_home_dir != NULL)
2027  {
2028  RtlInitUnicodeString(&UserAllInfo.HomeDirectory,
2029  UserInfo1006->usri1006_home_dir);
2030  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORY;
2031  }
2032  break;
2033 
2034  case 1007:
2035  UserInfo1007 = (PUSER_INFO_1007)UserInfo;
2036 
2037  if (UserInfo1007->usri1007_comment != NULL)
2038  {
2039  RtlInitUnicodeString(&UserAllInfo.AdminComment,
2040  UserInfo1007->usri1007_comment);
2041  UserAllInfo.WhichFields |= USER_ALL_ADMINCOMMENT;
2042  }
2043  break;
2044 
2045  case 1008:
2046  UserInfo1008 = (PUSER_INFO_1008)UserInfo;
2047  ChangeUserDacl(Dacl, UserInfo1008->usri1008_flags);
2048  UserAllInfo.UserAccountControl = GetAccountControl(UserInfo1008->usri1008_flags);
2049  UserAllInfo.WhichFields |= USER_ALL_USERACCOUNTCONTROL;
2050  break;
2051 
2052  case 1009:
2053  UserInfo1009 = (PUSER_INFO_1009)UserInfo;
2054 
2055  if (UserInfo1009->usri1009_script_path != NULL)
2056  {
2057  RtlInitUnicodeString(&UserAllInfo.ScriptPath,
2058  UserInfo1009->usri1009_script_path);
2059  UserAllInfo.WhichFields |= USER_ALL_SCRIPTPATH;
2060  }
2061  break;
2062 
2063 // case 1010:
2064 // break;
2065 
2066  case 1011:
2067  UserInfo1011 = (PUSER_INFO_1011)UserInfo;
2068 
2069  if (UserInfo1011->usri1011_full_name != NULL)
2070  {
2071  RtlInitUnicodeString(&UserAllInfo.FullName,
2072  UserInfo1011->usri1011_full_name);
2073  UserAllInfo.WhichFields |= USER_ALL_FULLNAME;
2074  }
2075  break;
2076 
2077  case 1012:
2078  UserInfo1012 = (PUSER_INFO_1012)UserInfo;
2079 
2080  if (UserInfo1012->usri1012_usr_comment != NULL)
2081  {
2082  RtlInitUnicodeString(&UserAllInfo.UserComment,
2083  UserInfo1012->usri1012_usr_comment);
2084  UserAllInfo.WhichFields |= USER_ALL_USERCOMMENT;
2085  }
2086  break;
2087 
2088  case 1013:
2089  UserInfo1013 = (PUSER_INFO_1013)UserInfo;
2090 
2091  if (UserInfo1013->usri1013_parms != NULL)
2092  {
2093  RtlInitUnicodeString(&UserAllInfo.Parameters,
2094  UserInfo1013->usri1013_parms);
2095  UserAllInfo.WhichFields |= USER_ALL_PARAMETERS;
2096  }
2097  break;
2098 
2099  case 1014:
2100  UserInfo1014 = (PUSER_INFO_1014)UserInfo;
2101 
2102  if (UserInfo1014->usri1014_workstations != NULL)
2103  {
2104  RtlInitUnicodeString(&UserAllInfo.WorkStations,
2105  UserInfo1014->usri1014_workstations);
2106  UserAllInfo.WhichFields |= USER_ALL_WORKSTATIONS;
2107  }
2108  break;
2109 
2110  case 1017:
2111  UserInfo1017 = (PUSER_INFO_1017)UserInfo;
2112 
2113  if (UserInfo1017->usri1017_acct_expires == TIMEQ_FOREVER)
2114  {
2115  UserAllInfo.AccountExpires.QuadPart = MAXLONGLONG;
2116  }
2117  else
2118  {
2119  RtlSecondsSince1970ToTime(UserInfo1017->usri1017_acct_expires,
2120  &UserAllInfo.AccountExpires);
2121  }
2122  UserAllInfo.WhichFields |= USER_ALL_ACCOUNTEXPIRES;
2123  break;
2124 
2125  case 1018:
2126  // usri1018_max_storage ignored
2127  break;
2128 
2129  case 1020:
2130  UserInfo1020 = (PUSER_INFO_1020)UserInfo;
2131 
2132  if (UserInfo1020->usri1020_logon_hours != NULL)
2133  {
2134  if (UserInfo1020->usri1020_units_per_week > USHRT_MAX)
2135  {
2136  if (parm_err != NULL)
2137  *parm_err = USER_UNITS_PER_WEEK_PARMNUM;
2138  ApiStatus = ERROR_INVALID_PARAMETER;
2139  break;
2140  }
2141 
2142  UserAllInfo.LogonHours.UnitsPerWeek = UserInfo1020->usri1020_units_per_week;
2143  UserAllInfo.LogonHours.LogonHours = UserInfo1020->usri1020_logon_hours;
2144  UserAllInfo.WhichFields |= USER_ALL_LOGONHOURS;
2145  }
2146  break;
2147 
2148  case 1024:
2149  UserInfo1024 = (PUSER_INFO_1024)UserInfo;
2150 
2151  UserAllInfo.CountryCode = UserInfo1024->usri1024_country_code;
2152  UserAllInfo.WhichFields |= USER_ALL_COUNTRYCODE;
2153  break;
2154 
2155  case 1025:
2156  UserInfo1025 = (PUSER_INFO_1025)UserInfo;
2157 
2158  UserAllInfo.CodePage = UserInfo1025->usri1025_code_page;
2159  UserAllInfo.WhichFields |= USER_ALL_CODEPAGE;
2160  break;
2161 
2162  case 1051:
2163  UserInfo1051 = (PUSER_INFO_1051)UserInfo;
2164 
2165  UserAllInfo.PrimaryGroupId = UserInfo1051->usri1051_primary_group_id;
2166  UserAllInfo.WhichFields |= USER_ALL_PRIMARYGROUPID;
2167  break;
2168 
2169  case 1052:
2170  UserInfo1052 = (PUSER_INFO_1052)UserInfo;
2171 
2172  if (UserInfo1052->usri1052_profile != NULL)
2173  {
2174  RtlInitUnicodeString(&UserAllInfo.ProfilePath,
2175  UserInfo1052->usri1052_profile);
2176  UserAllInfo.WhichFields |= USER_ALL_PROFILEPATH;
2177  }
2178  break;
2179 
2180  case 1053:
2181  UserInfo1053 = (PUSER_INFO_1053)UserInfo;
2182 
2183  if (UserInfo1053->usri1053_home_dir_drive != NULL)
2184  {
2185  RtlInitUnicodeString(&UserAllInfo.HomeDirectoryDrive,
2186  UserInfo1053->usri1053_home_dir_drive);
2187  UserAllInfo.WhichFields |= USER_ALL_HOMEDIRECTORYDRIVE;
2188  }
2189  break;
2190  }
2191 
2192  if (ApiStatus != NERR_Success)
2193  goto done;
2194 
2195  Status = SamSetInformationUser(UserHandle,
2196  UserAllInformation,
2197  &UserAllInfo);
2198  if (!NT_SUCCESS(Status))
2199  {
2200  ERR("SamSetInformationUser failed (Status %08lx)\n", Status);
2201  ApiStatus = NetpNtStatusToApiStatus(Status);
2202  goto done;
2203  }
2204 
2205 done:
2206  if (Dacl != NULL)
2207  HeapFree(GetProcessHeap(), 0, Dacl);
2208 
2209  return ApiStatus;
2210 }
2211 
2212 
2213 static
2214 NET_API_STATUS
2215 OpenUserByName(SAM_HANDLE DomainHandle,
2216  PUNICODE_STRING UserName,
2217  ULONG DesiredAccess,
2218  PSAM_HANDLE UserHandle)
2219 {
2220  PULONG RelativeIds = NULL;
2221  PSID_NAME_USE Use = NULL;
2222  NET_API_STATUS ApiStatus = NERR_Success;
2223  NTSTATUS Status = STATUS_SUCCESS;
2224 
2225  /* Get the RID for the given user name */
2226  Status = SamLookupNamesInDomain(DomainHandle,
2227  1,
2228  UserName,
2229  &RelativeIds,
2230  &Use);
2231  if (!NT_SUCCESS(Status))
2232  {
2233  ERR("SamLookupNamesInDomain(%wZ) failed (Status %08lx)\n", UserName, Status);
2234  return NetpNtStatusToApiStatus(Status);
2235  }
2236 
2237  /* Fail, if it is not an alias account */
2238  if (Use[0] != SidTypeUser)
2239  {
2240  ERR("Object is not a user!\n");
2241  ApiStatus = NERR_GroupNotFound;
2242  goto done;
2243  }
2244 
2245  /* Open the alias account */
2246  Status = SamOpenUser(DomainHandle,
2247  DesiredAccess,
2248  RelativeIds[0],
2249  UserHandle);
2250  if (!NT_SUCCESS(Status))
2251  {
2252  ERR("SamOpenUser failed (Status %08lx)\n", Status);
2253  ApiStatus = NetpNtStatusToApiStatus(Status);
2254  goto done;
2255  }
2256 
2257 done:
2258  if (RelativeIds != NULL)
2259  SamFreeMemory(RelativeIds);
2260 
2261  if (Use != NULL)
2262  SamFreeMemory(Use);
2263 
2264  return ApiStatus;
2265 }
2266 
2267 
2268 /************************************************************
2269  * NetUserAdd (NETAPI32.@)
2270  */
2271 NET_API_STATUS
2272 WINAPI
2273 NetUserAdd(LPCWSTR servername,
2274  DWORD level,
2275  LPBYTE bufptr,
2276  LPDWORD parm_err)
2277 {
2278  UNICODE_STRING ServerName;
2279  UNICODE_STRING UserName;
2280  SAM_HANDLE ServerHandle = NULL;
2281  SAM_HANDLE DomainHandle = NULL;
2282  SAM_HANDLE UserHandle = NULL;
2283  ULONG GrantedAccess;
2284  ULONG RelativeId;
2285  NET_API_STATUS ApiStatus = NERR_Success;
2286  NTSTATUS Status = STATUS_SUCCESS;
2287 
2288  TRACE("(%s, %d, %p, %p)\n", debugstr_w(servername), level, bufptr, parm_err);
2289 
2290  if (parm_err != NULL)
2291  *parm_err = PARM_ERROR_NONE;
2292 
2293  /* Check the info level */
2294  switch (level)
2295  {
2296  case 1:
2297  case 2:
2298  case 3:
2299  case 4:
2300  break;
2301 
2302  default:
2303  return ERROR_INVALID_LEVEL;
2304  }
2305 
2306  if (servername != NULL)
2307  RtlInitUnicodeString(&ServerName, servername);
2308 
2309  /* Connect to the SAM Server */
2310  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
2311  &ServerHandle,
2312  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
2313  NULL);
2314  if (!NT_SUCCESS(Status))
2315  {
2316  ERR("SamConnect failed (Status %08lx)\n", Status);
2317  ApiStatus = NetpNtStatusToApiStatus(Status);
2318  goto done;
2319  }
2320 
2321  /* Open the Account Domain */
2322  Status = OpenAccountDomain(ServerHandle,
2323  (servername != NULL) ? &ServerName : NULL,
2324  DOMAIN_CREATE_USER | DOMAIN_LOOKUP | DOMAIN_READ_PASSWORD_PARAMETERS,
2325  &DomainHandle);
2326  if (!NT_SUCCESS(Status))
2327  {
2328  ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
2329  ApiStatus = NetpNtStatusToApiStatus(Status);
2330  goto done;
2331  }
2332 
2333  /* Initialize the user name string */
2334  RtlInitUnicodeString(&UserName,
2335  ((PUSER_INFO_1)bufptr)->usri1_name);
2336 
2337  /* Create the user account */
2338  Status = SamCreateUser2InDomain(DomainHandle,
2339  &UserName,
2340  USER_NORMAL_ACCOUNT,
2341  USER_ALL_ACCESS | DELETE | WRITE_DAC,
2342  &UserHandle,
2343  &GrantedAccess,
2344  &RelativeId);
2345  if (!NT_SUCCESS(Status))
2346  {
2347  ERR("SamCreateUser2InDomain failed (Status %08lx)\n", Status);
2348  ApiStatus = NetpNtStatusToApiStatus(Status);
2349  goto done;
2350  }
2351 
2352  /* Set user information */
2353  ApiStatus = SetUserInfo(UserHandle,
2354  bufptr,
2355  level,
2356  parm_err);
2357  if (ApiStatus != NERR_Success)
2358  {
2359  ERR("SetUserInfo failed (Status %lu)\n", ApiStatus);
2360  goto done;
2361  }
2362 
2363 done:
2364  if (UserHandle != NULL)
2365  {
2366  if (ApiStatus != NERR_Success)
2367  SamDeleteUser(UserHandle);
2368  else
2369  SamCloseHandle(UserHandle);
2370  }
2371 
2372  if (DomainHandle != NULL)
2373  SamCloseHandle(DomainHandle);
2374 
2375  if (ServerHandle != NULL)
2376  SamCloseHandle(ServerHandle);
2377 
2378  return ApiStatus;
2379 }
2380 
2381 
2382 /******************************************************************************
2383  * NetUserChangePassword (NETAPI32.@)
2384  * PARAMS
2385  * domainname [I] Optional. Domain on which the user resides or the logon
2386  * domain of the current user if NULL.
2387  * username [I] Optional. Username to change the password for or the name
2388  * of the current user if NULL.
2389  * oldpassword [I] The user's current password.
2390  * newpassword [I] The password that the user will be changed to using.
2391  *
2392  * RETURNS
2393  * Success: NERR_Success.
2394  * Failure: NERR_* failure code or win error code.
2395  *
2396  */
2397 NET_API_STATUS
2398 WINAPI
2399 NetUserChangePassword(LPCWSTR domainname,
2400  LPCWSTR username,
2401  LPCWSTR oldpassword,
2402  LPCWSTR newpassword)
2403 {
2404  PMSV1_0_CHANGEPASSWORD_REQUEST RequestBuffer = NULL;
2405  PMSV1_0_CHANGEPASSWORD_RESPONSE ResponseBuffer = NULL;
2406  ULONG RequestBufferSize;
2407  ULONG ResponseBufferSize = 0;
2408  LPWSTR Ptr;
2409  ANSI_STRING PackageName;
2410  ULONG AuthenticationPackage = 0;
2411  HANDLE LsaHandle = NULL;
2412  NET_API_STATUS ApiStatus = NERR_Success;
2413  NTSTATUS Status = STATUS_SUCCESS;
2414  NTSTATUS ProtocolStatus;
2415 
2416  TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
2417 
2418  /* FIXME: handle null domain or user name */
2419 
2420  /* Check the parameters */
2421  if ((oldpassword == NULL) ||
2422  (newpassword == NULL))
2423  return ERROR_INVALID_PARAMETER;
2424 
2425  /* Connect to the LSA server */
2426  Status = LsaConnectUntrusted(&LsaHandle);
2427  if (!NT_SUCCESS(Status))
2428  return NetpNtStatusToApiStatus(Status);
2429 
2430  /* Get the authentication package ID */
2431  RtlInitAnsiString(&PackageName,
2432  MSV1_0_PACKAGE_NAME);
2433 
2434  Status = LsaLookupAuthenticationPackage(LsaHandle,
2435  &PackageName,
2436  &AuthenticationPackage);
2437  if (!NT_SUCCESS(Status))
2438  {
2439  ApiStatus = NetpNtStatusToApiStatus(Status);
2440  goto done;
2441  }
2442 
2443  /* Calculate the request buffer size */
2444  RequestBufferSize = sizeof(MSV1_0_CHANGEPASSWORD_REQUEST) +
2445  ((wcslen(domainname) + 1) * sizeof(WCHAR)) +
2446  ((wcslen(username) + 1) * sizeof(WCHAR)) +
2447  ((wcslen(oldpassword) + 1) * sizeof(WCHAR)) +
2448  ((wcslen(newpassword) + 1) * sizeof(WCHAR));
2449 
2450  /* Allocate the request buffer */
2451  ApiStatus = NetApiBufferAllocate(RequestBufferSize,
2452  (PVOID*)&RequestBuffer);
2453  if (ApiStatus != NERR_Success)
2454  goto done;
2455 
2456  /* Initialize the request buffer */
2457  RequestBuffer->MessageType = MsV1_0ChangePassword;
2458  RequestBuffer->Impersonating = TRUE;
2459 
2460  Ptr = (LPWSTR)((ULONG_PTR)RequestBuffer + sizeof(MSV1_0_CHANGEPASSWORD_REQUEST));
2461 
2462  /* Pack the domain name */
2463  RequestBuffer->DomainName.Length = wcslen(domainname) * sizeof(WCHAR);
2464  RequestBuffer->DomainName.MaximumLength = RequestBuffer->DomainName.Length + sizeof(WCHAR);
2465  RequestBuffer->DomainName.Buffer = Ptr;
2466 
2467  RtlCopyMemory(RequestBuffer->DomainName.Buffer,
2468  domainname,
2469  RequestBuffer->DomainName.MaximumLength);
2470 
2471  Ptr = (LPWSTR)((ULONG_PTR)Ptr + RequestBuffer->DomainName.MaximumLength);
2472 
2473  /* Pack the user name */
2474  RequestBuffer->AccountName.Length = wcslen(username) * sizeof(WCHAR);
2475  RequestBuffer->AccountName.MaximumLength = RequestBuffer->AccountName.Length + sizeof(WCHAR);
2476  RequestBuffer->AccountName.Buffer = Ptr;
2477 
2478  RtlCopyMemory(RequestBuffer->AccountName.Buffer,
2479  username,
2480  RequestBuffer->AccountName.MaximumLength);
2481 
2482  Ptr = (LPWSTR)((ULONG_PTR)Ptr + RequestBuffer->AccountName.MaximumLength);
2483 
2484  /* Pack the old password */
2485  RequestBuffer->OldPassword.Length = wcslen(oldpassword) * sizeof(WCHAR);
2486  RequestBuffer->OldPassword.MaximumLength = RequestBuffer->OldPassword.Length + sizeof(WCHAR);
2487  RequestBuffer->OldPassword.Buffer = Ptr;
2488 
2489  RtlCopyMemory(RequestBuffer->OldPassword.Buffer,
2490  oldpassword,
2491  RequestBuffer->OldPassword.MaximumLength);
2492 
2493  Ptr = (LPWSTR)((ULONG_PTR)Ptr + RequestBuffer->OldPassword.MaximumLength);
2494 
2495  /* Pack the new password */
2496  RequestBuffer->NewPassword.Length = wcslen(newpassword) * sizeof(WCHAR);
2497  RequestBuffer->NewPassword.MaximumLength = RequestBuffer->NewPassword.Length + sizeof(WCHAR);
2498  RequestBuffer->NewPassword.Buffer = Ptr;
2499 
2500  RtlCopyMemory(RequestBuffer->NewPassword.Buffer,
2501  newpassword,
2502  RequestBuffer->NewPassword.MaximumLength);
2503 
2504  /* Call the authentication package */
2505  Status = LsaCallAuthenticationPackage(LsaHandle,
2506  AuthenticationPackage,
2507  RequestBuffer,
2508  RequestBufferSize,
2509  (PVOID*)&ResponseBuffer,
2510  &ResponseBufferSize,
2511  &ProtocolStatus);
2512  if (!NT_SUCCESS(Status))
2513  {
2514  ApiStatus = NetpNtStatusToApiStatus(Status);
2515  goto done;
2516  }
2517 
2518  if (!NT_SUCCESS(ProtocolStatus))
2519  {
2520  ApiStatus = NetpNtStatusToApiStatus(ProtocolStatus);
2521  goto done;
2522  }
2523 
2524 done:
2525  if (RequestBuffer != NULL)
2526  NetApiBufferFree(RequestBuffer);
2527 
2528  if (ResponseBuffer != NULL)
2529  LsaFreeReturnBuffer(ResponseBuffer);
2530 
2531  if (LsaHandle != NULL)
2532  NtClose(LsaHandle);
2533 
2534  return ApiStatus;
2535 }
2536 
2537 
2538 /************************************************************
2539  * NetUserDel (NETAPI32.@)
2540  */
2541 NET_API_STATUS
2542 WINAPI
2543 NetUserDel(LPCWSTR servername,
2544  LPCWSTR username)
2545 {
2546  UNICODE_STRING ServerName;
2547  UNICODE_STRING UserName;
2548  SAM_HANDLE ServerHandle = NULL;
2549  SAM_HANDLE DomainHandle = NULL;
2550  SAM_HANDLE UserHandle = NULL;
2551  NET_API_STATUS ApiStatus = NERR_Success;
2552  NTSTATUS Status = STATUS_SUCCESS;
2553 
2554  TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
2555 
2556  if (servername != NULL)
2557  RtlInitUnicodeString(&ServerName, servername);
2558 
2559  RtlInitUnicodeString(&UserName, username);
2560 
2561  /* Connect to the SAM Server */
2562  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
2563  &ServerHandle,
2564  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
2565  NULL);
2566  if (!NT_SUCCESS(Status))
2567  {
2568  ERR("SamConnect failed (Status %08lx)\n", Status);
2569  ApiStatus = NetpNtStatusToApiStatus(Status);
2570  goto done;
2571  }
2572 
2573  /* Open the Builtin Domain */
2574  Status = OpenBuiltinDomain(ServerHandle,
2575  DOMAIN_LOOKUP,
2576  &DomainHandle);
2577  if (!NT_SUCCESS(Status))
2578  {
2579  ERR("OpenBuiltinDomain failed (Status %08lx)\n", Status);
2580  ApiStatus = NetpNtStatusToApiStatus(Status);
2581  goto done;
2582  }
2583 
2584  /* Open the user account in the builtin domain */
2585  ApiStatus = OpenUserByName(DomainHandle,
2586  &UserName,
2587  DELETE,
2588  &UserHandle);
2589  if (ApiStatus != NERR_Success && ApiStatus != ERROR_NONE_MAPPED)
2590  {
2591  TRACE("OpenUserByName(%wZ) failed (ApiStatus %lu)\n", &UserName, ApiStatus);
2592  goto done;
2593  }
2594 
2595  if (UserHandle == NULL)
2596  {
2597  if (DomainHandle != NULL)
2598  {
2599  SamCloseHandle(DomainHandle);
2600  DomainHandle = NULL;
2601  }
2602 
2603  /* Open the Acount Domain */
2604  Status = OpenAccountDomain(ServerHandle,
2605  (servername != NULL) ? &ServerName : NULL,
2606  DOMAIN_LOOKUP,
2607  &DomainHandle);
2608  if (!NT_SUCCESS(Status))
2609  {
2610  ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
2611  ApiStatus = NetpNtStatusToApiStatus(Status);
2612  goto done;
2613  }
2614 
2615  /* Open the user account in the account domain */
2616  ApiStatus = OpenUserByName(DomainHandle,
2617  &UserName,
2618  DELETE,
2619  &UserHandle);
2620  if (ApiStatus != NERR_Success)
2621  {
2622  ERR("OpenUserByName(%wZ) failed (ApiStatus %lu)\n", &UserName, ApiStatus);
2623  if (ApiStatus == ERROR_NONE_MAPPED)
2624  ApiStatus = NERR_UserNotFound;
2625  goto done;
2626  }
2627  }
2628 
2629  /* Delete the user */
2630  Status = SamDeleteUser(UserHandle);
2631  if (!NT_SUCCESS(Status))
2632  {
2633  ERR("SamDeleteUser failed (Status %08lx)\n", Status);
2634  ApiStatus = NetpNtStatusToApiStatus(Status);
2635  goto done;
2636  }
2637 
2638  /* A successful delete invalidates the handle */
2639  UserHandle = NULL;
2640 
2641 done:
2642  if (UserHandle != NULL)
2643  SamCloseHandle(UserHandle);
2644 
2645  if (DomainHandle != NULL)
2646  SamCloseHandle(DomainHandle);
2647 
2648  if (ServerHandle != NULL)
2649  SamCloseHandle(ServerHandle);
2650 
2651  return ApiStatus;
2652 }
2653 
2654 static
2655 NET_API_STATUS
2656 AllocateEnumContext(
2657  PENUM_CONTEXT *AllocatedEnumContext)
2658 {
2659  NET_API_STATUS ApiStatus;
2660  PENUM_CONTEXT EnumContext;
2661 
2662  /* Allocate the context structure */
2663  ApiStatus = NetApiBufferAllocate(sizeof(ENUM_CONTEXT), (PVOID*)&EnumContext);
2664  if (ApiStatus != NERR_Success)
2665  return ApiStatus;
2666 
2667  /* Initialize the fields */
2668  EnumContext->EnumerationContext = 0;
2669  EnumContext->Buffer = NULL;
2670  EnumContext->Count = 0;
2671  EnumContext->Index = 0;
2672  EnumContext->BuiltinDone = FALSE;
2673 
2674  /* Set a "unique" handle */
2675  EnumContext->EnumHandle = InterlockedIncrement(&g_EnumContextHandle);
2676  if (EnumContext->EnumHandle == 0)
2677  {
2678  EnumContext->EnumHandle = InterlockedIncrement(&g_EnumContextHandle);
2679  }
2680 
2681  /* Insert the context in the list */
2682  EnterCriticalSection(&g_EnumContextListLock);
2683  InsertTailList(&g_EnumContextListHead, &EnumContext->ListLink);
2684  LeaveCriticalSection(&g_EnumContextListLock);
2685 
2686  *AllocatedEnumContext = EnumContext;
2687  return NERR_Success;
2688 }
2689 
2690 static
2691 VOID
2692 FreeEnumContext(
2693  PENUM_CONTEXT EnumContext)
2694 
2695 {
2696  /* Remove the context from the list */
2697  EnterCriticalSection(&g_EnumContextListLock);
2698  RemoveEntryList(&EnumContext->ListLink);
2699  LeaveCriticalSection(&g_EnumContextListLock);
2700 
2701  /* Free it */
2702  NetApiBufferFree(EnumContext);
2703 }
2704 
2705 static
2706 PENUM_CONTEXT
2707 LookupEnumContext(
2708  SAM_ENUMERATE_HANDLE EnumerationHandle)
2709 {
2710  PENUM_CONTEXT FoundEnumContext = NULL;
2711  PLIST_ENTRY ListEntry;
2712 
2713  /* Acquire the list lock */
2714  EnterCriticalSection(&g_EnumContextListLock);
2715 
2716  /* Search the list for the handle */
2717  for (ListEntry = g_EnumContextListHead.Flink;
2718  ListEntry != &g_EnumContextListHead;
2719  ListEntry = ListEntry->Flink)
2720  {
2721  PENUM_CONTEXT EnumContext = CONTAINING_RECORD(ListEntry, ENUM_CONTEXT, ListLink);
2722  if (EnumContext->EnumHandle == EnumerationHandle)
2723  {
2724  FoundEnumContext = EnumContext;
2725  break;
2726  }
2727  }
2728 
2729  /* Release the list lock */
2730  LeaveCriticalSection(&g_EnumContextListLock);
2731 
2732  return FoundEnumContext;
2733 }
2734 
2735 /************************************************************
2736  * NetUserEnum (NETAPI32.@)
2737  */
2738 NET_API_STATUS
2739 WINAPI
2740 NetUserEnum(LPCWSTR servername,
2741  DWORD level,
2742  DWORD filter,
2743  LPBYTE* bufptr,
2744  DWORD prefmaxlen,
2745  LPDWORD entriesread,
2746  LPDWORD totalentries,
2747  LPDWORD resume_handle)
2748 {
2749  UNICODE_STRING ServerName;
2750  PSAM_RID_ENUMERATION CurrentUser;
2751  PENUM_CONTEXT EnumContext = NULL;
2752  LPVOID Buffer = NULL;
2753  ULONG i;
2754  SAM_HANDLE UserHandle = NULL;
2755  ACCESS_MASK DesiredAccess;
2756  NET_API_STATUS ApiStatus = NERR_Success;
2757  NTSTATUS Status = STATUS_SUCCESS;
2758 
2759  TRACE("(%s %d 0x%d %p %d %p %p %p)\n", debugstr_w(servername), level,
2760  filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
2761 
2762  *entriesread = 0;
2763  *totalentries = 0;
2764  *bufptr = NULL;
2765 
2766  if (servername != NULL)
2767  RtlInitUnicodeString(&ServerName, servername);
2768 
2769  if (resume_handle != NULL && *resume_handle != 0)
2770  {
2771  EnumContext = LookupEnumContext(*resume_handle);
2772  }
2773  else
2774  {
2775  ApiStatus = AllocateEnumContext(&EnumContext);
2776  if (ApiStatus != NERR_Success)
2777  goto done;
2778 
2779  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
2780  &EnumContext->ServerHandle,
2781  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
2782  NULL);
2783  if (!NT_SUCCESS(Status))
2784  {
2785  ERR("SamConnect failed (Status %08lx)\n", Status);
2786  ApiStatus = NetpNtStatusToApiStatus(Status);
2787  goto done;
2788  }
2789 
2790  /* Get the Account Domain SID */
2791  Status = GetAccountDomainSid((servername != NULL) ? &ServerName : NULL,
2792  &EnumContext->AccountDomainSid);
2793  if (!NT_SUCCESS(Status))
2794  {
2795  ERR("GetAccountDomainSid failed (Status %08lx)\n", Status);
2796  ApiStatus = NetpNtStatusToApiStatus(Status);
2797  goto done;
2798  }
2799 
2800  /* Open the Account Domain */
2801  Status = SamOpenDomain(EnumContext->ServerHandle,
2802  DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP,
2803  EnumContext->AccountDomainSid,
2804  &EnumContext->AccountDomainHandle);
2805  if (!NT_SUCCESS(Status))
2806  {
2807  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
2808  ApiStatus = NetpNtStatusToApiStatus(Status);
2809  goto done;
2810  }
2811 
2812  /* Get the Builtin Domain SID */
2813  Status = GetBuiltinDomainSid(&EnumContext->BuiltinDomainSid);
2814  if (!NT_SUCCESS(Status))
2815  {
2816  ERR("GetBuiltinDomainSid failed (Status %08lx)\n", Status);
2817  ApiStatus = NetpNtStatusToApiStatus(Status);
2818  goto done;
2819  }
2820 
2821  DesiredAccess = DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP;
2822  if ((level == 1) || (level == 2) || (level == 3) || (level == 4) || (level == 11))
2823  DesiredAccess |= DOMAIN_GET_ALIAS_MEMBERSHIP;
2824 
2825  /* Open the Builtin Domain */
2826  Status = SamOpenDomain(EnumContext->ServerHandle,
2827  DesiredAccess,
2828  EnumContext->BuiltinDomainSid,
2829  &EnumContext->BuiltinDomainHandle);
2830  if (!NT_SUCCESS(Status))
2831  {
2832  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
2833  ApiStatus = NetpNtStatusToApiStatus(Status);
2834  goto done;
2835  }
2836  }
2837 
2838 // while (TRUE)
2839 // {
2840  TRACE("EnumContext->Index: %lu\n", EnumContext->Index);
2841  TRACE("EnumContext->Count: %lu\n", EnumContext->Count);
2842 
2843  if (EnumContext->Index >= EnumContext->Count)
2844  {
2845 // if (EnumContext->BuiltinDone != FALSE)
2846 // {
2847 // ApiStatus = NERR_Success;
2848 // goto done;
2849 // }
2850 
2851  TRACE("Calling SamEnumerateUsersInDomain\n");
2852  Status = SamEnumerateUsersInDomain(EnumContext->AccountDomainHandle, //BuiltinDomainHandle,
2853  &EnumContext->EnumerationContext,
2854  0,
2855  (PVOID *)&EnumContext->Buffer,
2856  prefmaxlen,
2857  &EnumContext->Count);
2858 
2859  TRACE("SamEnumerateUsersInDomain returned (Status %08lx)\n", Status);
2860  if (!NT_SUCCESS(Status))
2861  {
2862  ERR("SamEnumerateUsersInDomain failed (Status %08lx)\n", Status);
2863  ApiStatus = NetpNtStatusToApiStatus(Status);
2864  goto done;
2865  }
2866 
2867  if (Status == STATUS_MORE_ENTRIES)
2868  {
2869  ApiStatus = NERR_BufTooSmall;
2870  goto done;
2871  }
2872  else
2873  {
2874  EnumContext->BuiltinDone = TRUE;
2875  }
2876  }
2877 
2878  TRACE("EnumContext: %lu\n", EnumContext);
2879  TRACE("EnumContext->Count: %lu\n", EnumContext->Count);
2880  TRACE("EnumContext->Buffer: %p\n", EnumContext->Buffer);
2881 
2882  /* Get a pointer to the current user */
2883  CurrentUser = &EnumContext->Buffer[EnumContext->Index];
2884 
2885  TRACE("RID: %lu\n", CurrentUser->RelativeId);
2886 
2887  DesiredAccess = READ_CONTROL | USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT;
2888  if ((level == 1) || (level == 2) || (level == 3) || (level == 4) || (level == 11))
2889  DesiredAccess |= USER_LIST_GROUPS;
2890 
2891  Status = SamOpenUser(EnumContext->AccountDomainHandle, //BuiltinDomainHandle,
2892  DesiredAccess,
2893  CurrentUser->RelativeId,
2894  &UserHandle);
2895  if (!NT_SUCCESS(Status))
2896  {
2897  ERR("SamOpenUser failed (Status %08lx)\n", Status);
2898  ApiStatus = NetpNtStatusToApiStatus(Status);
2899  goto done;
2900  }
2901 
2902  ApiStatus = BuildUserInfoBuffer(EnumContext->BuiltinDomainHandle,
2903  UserHandle,
2904  EnumContext->AccountDomainSid,
2905  CurrentUser->RelativeId,
2906  level,
2907  &Buffer);
2908  if (ApiStatus != NERR_Success)
2909  {
2910  ERR("BuildUserInfoBuffer failed (ApiStatus %lu)\n", ApiStatus);
2911  goto done;
2912  }
2913 
2914  SamCloseHandle(UserHandle);
2915  UserHandle = NULL;
2916 
2917  EnumContext->Index++;
2918 
2919  (*entriesread)++;
2920 // }
2921 
2922 done:
2923  if (ApiStatus == NERR_Success && EnumContext != NULL && EnumContext->Index < EnumContext->Count)
2924  ApiStatus = ERROR_MORE_DATA;
2925 
2926  if (EnumContext != NULL)
2927  *totalentries = EnumContext->Count;
2928 
2929  if (resume_handle == NULL || ApiStatus != ERROR_MORE_DATA)
2930  {
2931  if (EnumContext != NULL)
2932  {
2933  if (EnumContext->BuiltinDomainHandle != NULL)
2934  SamCloseHandle(EnumContext->BuiltinDomainHandle);
2935 
2936  if (EnumContext->AccountDomainHandle != NULL)
2937  SamCloseHandle(EnumContext->AccountDomainHandle);
2938 
2939  if (EnumContext->BuiltinDomainSid != NULL)
2940  RtlFreeHeap(RtlGetProcessHeap(), 0, EnumContext->BuiltinDomainSid);
2941 
2942  if (EnumContext->AccountDomainSid != NULL)
2943  RtlFreeHeap(RtlGetProcessHeap(), 0, EnumContext->AccountDomainSid);
2944 
2945  if (EnumContext->ServerHandle != NULL)
2946  SamCloseHandle(EnumContext->ServerHandle);
2947 
2948  if (EnumContext->Buffer != NULL)
2949  {
2950  for (i = 0; i < EnumContext->Count; i++)
2951  {
2952  SamFreeMemory(EnumContext->Buffer[i].Name.Buffer);
2953  }
2954 
2955  SamFreeMemory(EnumContext->Buffer);
2956  }
2957 
2958  FreeEnumContext(EnumContext);
2959  EnumContext = NULL;
2960  }
2961  }
2962 
2963  if (UserHandle != NULL)
2964  SamCloseHandle(UserHandle);
2965 
2966  if (resume_handle != NULL)
2967  *resume_handle = EnumContext ? EnumContext->EnumHandle : 0;
2968 
2969  *bufptr = (LPBYTE)Buffer;
2970 
2971  TRACE("return %lu\n", ApiStatus);
2972 
2973  return ApiStatus;
2974 }
2975 
2976 
2977 /************************************************************
2978  * NetUserGetGroups (NETAPI32.@)
2979  */
2980 NET_API_STATUS
2981 WINAPI
2982 NetUserGetGroups(LPCWSTR servername,
2983  LPCWSTR username,
2984  DWORD level,
2985  LPBYTE *bufptr,
2986  DWORD prefixmaxlen,
2987  LPDWORD entriesread,
2988  LPDWORD totalentries)
2989 {
2990  UNICODE_STRING ServerName;
2991  UNICODE_STRING UserName;
2992  SAM_HANDLE ServerHandle = NULL;
2993  SAM_HANDLE AccountDomainHandle = NULL;
2994  SAM_HANDLE UserHandle = NULL;
2995  PSID AccountDomainSid = NULL;
2996  PULONG RelativeIds = NULL;
2997  PSID_NAME_USE Use = NULL;
2998  PGROUP_MEMBERSHIP GroupMembership = NULL;
2999  ULONG GroupCount;
3000 
3001  NET_API_STATUS ApiStatus = NERR_Success;
3002  NTSTATUS Status = STATUS_SUCCESS;
3003 
3004  TRACE("%s %s %d %p %d %p %p stub\n", debugstr_w(servername),
3005  debugstr_w(username), level, bufptr, prefixmaxlen, entriesread,
3006  totalentries);
3007 
3008  if (servername != NULL)
3009  RtlInitUnicodeString(&ServerName, servername);
3010 
3011  RtlInitUnicodeString(&UserName, username);
3012 
3013  /* Connect to the SAM Server */
3014  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
3015  &ServerHandle,
3016  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
3017  NULL);
3018  if (!NT_SUCCESS(Status))
3019  {
3020  ERR("SamConnect failed (Status %08lx)\n", Status);
3021  ApiStatus = NetpNtStatusToApiStatus(Status);
3022  goto done;
3023  }
3024 
3025  /* Get the Account Domain SID */
3026  Status = GetAccountDomainSid((servername != NULL) ? &ServerName : NULL,
3027  &AccountDomainSid);
3028  if (!NT_SUCCESS(Status))
3029  {
3030  ERR("GetAccountDomainSid failed (Status %08lx)\n", Status);
3031  ApiStatus = NetpNtStatusToApiStatus(Status);
3032  goto done;
3033  }
3034 
3035  /* Open the Account Domain */
3036  Status = SamOpenDomain(ServerHandle,
3037  DOMAIN_LOOKUP | DOMAIN_GET_ALIAS_MEMBERSHIP,
3038  AccountDomainSid,
3039  &AccountDomainHandle);
3040  if (!NT_SUCCESS(Status))
3041  {
3042  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
3043  ApiStatus = NetpNtStatusToApiStatus(Status);
3044  goto done;
3045  }
3046 
3047  /* Get the RID for the given user name */
3048  Status = SamLookupNamesInDomain(AccountDomainHandle,
3049  1,
3050  &UserName,
3051  &RelativeIds,
3052  &Use);
3053  if (!NT_SUCCESS(Status))
3054  {
3055  ERR("SamLookupNamesInDomain(%wZ) failed (Status %08lx)\n", &UserName, Status);
3056  if (Status == STATUS_NONE_MAPPED)
3057  ApiStatus = NERR_UserNotFound;
3058  else
3059  ApiStatus = NetpNtStatusToApiStatus(Status);
3060  goto done;
3061  }
3062 
3063  /* Fail, if it is not a user account */
3064  if (Use[0] != SidTypeUser)
3065  {
3066  ERR("Account is not a User!\n");
3067  ApiStatus = NERR_UserNotFound;
3068  goto done;
3069  }
3070 
3071  /* Open the user object */
3072  Status = SamOpenUser(AccountDomainHandle,
3073  USER_LIST_GROUPS,
3074  RelativeIds[0],
3075  &UserHandle);
3076  if (!NT_SUCCESS(Status))
3077  {
3078  ERR("SamOpenUser failed (Status %08lx)\n", Status);
3079  ApiStatus = NetpNtStatusToApiStatus(Status);
3080  goto done;
3081  }
3082 
3083  /* Get the group memberships of this user */
3084  Status = SamGetGroupsForUser(UserHandle,
3085  &GroupMembership,
3086  &GroupCount);
3087  if (!NT_SUCCESS(Status))
3088  {
3089  ERR("SamGetGroupsForUser failed (Status %08lx)\n", Status);
3090  ApiStatus = NetpNtStatusToApiStatus(Status);
3091  goto done;
3092  }
3093 
3094  /* If there is no group membership, we're done */
3095  if (GroupCount == 0)
3096  {
3097  ApiStatus = NERR_Success;
3098  goto done;
3099  }
3100 
3101 
3102 done:
3103 
3104  if (GroupMembership != NULL)
3105  SamFreeMemory(GroupMembership);
3106 
3107  if (UserHandle != NULL)
3108  SamCloseHandle(UserHandle);
3109 
3110  if (RelativeIds != NULL)
3111  SamFreeMemory(RelativeIds);
3112 
3113  if (Use != NULL)
3114  SamFreeMemory(Use);
3115 
3116  if (AccountDomainSid != NULL)
3117  RtlFreeHeap(RtlGetProcessHeap(), 0, AccountDomainSid);
3118 
3119  if (AccountDomainHandle != NULL)
3120  SamCloseHandle(AccountDomainHandle);
3121 
3122  if (ServerHandle != NULL)
3123  SamCloseHandle(ServerHandle);
3124 
3125  if (ApiStatus != NERR_Success && ApiStatus != ERROR_MORE_DATA)
3126  {
3127  *entriesread = 0;
3128  *totalentries = 0;
3129  }
3130  else
3131  {
3132 // *entriesread = Count;
3133 // *totalentries = Count;
3134  }
3135 
3136 // *bufptr = (LPBYTE)Buffer;
3137 
3138  return ApiStatus;
3139 }
3140 
3141 
3142 /************************************************************
3143  * NetUserGetInfo (NETAPI32.@)
3144  */
3145 NET_API_STATUS
3146 WINAPI
3147 NetUserGetInfo(LPCWSTR servername,
3148  LPCWSTR username,
3149  DWORD level,
3150  LPBYTE* bufptr)
3151 {
3152  UNICODE_STRING ServerName;
3153  UNICODE_STRING UserName;
3154  SAM_HANDLE ServerHandle = NULL;
3155  SAM_HANDLE AccountDomainHandle = NULL;
3156  SAM_HANDLE BuiltinDomainHandle = NULL;
3157  SAM_HANDLE UserHandle = NULL;
3158  PULONG RelativeIds = NULL;
3159  PSID_NAME_USE Use = NULL;
3160  LPVOID Buffer = NULL;
3161  PSID AccountDomainSid = NULL;
3162  PSID BuiltinDomainSid = NULL;
3163  ACCESS_MASK DesiredAccess;
3164  NET_API_STATUS ApiStatus = NERR_Success;
3165  NTSTATUS Status = STATUS_SUCCESS;
3166 
3167  TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername),
3168  debugstr_w(username), level, bufptr);
3169 
3170  if (servername != NULL)
3171  RtlInitUnicodeString(&ServerName, servername);
3172 
3173  RtlInitUnicodeString(&UserName, username);
3174 
3175  /* Connect to the SAM Server */
3176  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
3177  &ServerHandle,
3178  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
3179  NULL);
3180  if (!NT_SUCCESS(Status))
3181  {
3182  ERR("SamConnect failed (Status %08lx)\n", Status);
3183  ApiStatus = NetpNtStatusToApiStatus(Status);
3184  goto done;
3185  }
3186 
3187  /* Get the Builtin Domain SID */
3188  Status = GetBuiltinDomainSid(&BuiltinDomainSid);
3189  if (!NT_SUCCESS(Status))
3190  {
3191  ERR("GetBuiltinDomainSid failed (Status %08lx)\n", Status);
3192  ApiStatus = NetpNtStatusToApiStatus(Status);
3193  goto done;
3194  }
3195 
3196  DesiredAccess = DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP;
3197  if ((level == 1) || (level == 2) || (level == 3) || (level == 4) || (level == 11))
3198  DesiredAccess |= DOMAIN_GET_ALIAS_MEMBERSHIP;
3199 
3200  /* Open the Builtin Domain */
3201  Status = SamOpenDomain(ServerHandle,
3202  DesiredAccess,
3203  BuiltinDomainSid,
3204  &BuiltinDomainHandle);
3205  if (!NT_SUCCESS(Status))
3206  {
3207  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
3208  ApiStatus = NetpNtStatusToApiStatus(Status);
3209  goto done;
3210  }
3211 
3212  /* Get the Account Domain SID */
3213  Status = GetAccountDomainSid((servername != NULL) ? &ServerName : NULL,
3214  &AccountDomainSid);
3215  if (!NT_SUCCESS(Status))
3216  {
3217  ERR("GetAccountDomainSid failed (Status %08lx)\n", Status);
3218  ApiStatus = NetpNtStatusToApiStatus(Status);
3219  goto done;
3220  }
3221 
3222  /* Open the Account Domain */
3223  Status = SamOpenDomain(ServerHandle,
3224  DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP,
3225  AccountDomainSid,
3226  &AccountDomainHandle);
3227  if (!NT_SUCCESS(Status))
3228  {
3229  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
3230  ApiStatus = NetpNtStatusToApiStatus(Status);
3231  goto done;
3232  }
3233 
3234  /* Get the RID for the given user name */
3235  Status = SamLookupNamesInDomain(AccountDomainHandle,
3236  1,
3237  &UserName,
3238  &RelativeIds,
3239  &Use);
3240  if (!NT_SUCCESS(Status))
3241  {
3242  ERR("SamLookupNamesInDomain(%wZ) failed (Status %08lx)\n", &UserName, Status);
3243  if (Status == STATUS_NONE_MAPPED)
3244  ApiStatus = NERR_UserNotFound;
3245  else
3246  ApiStatus = NetpNtStatusToApiStatus(Status);
3247  goto done;
3248  }
3249 
3250  /* Check if the account is a user account */
3251  if (Use[0] != SidTypeUser)
3252  {
3253  ERR("No user found!\n");
3254  ApiStatus = NERR_UserNotFound;
3255  goto done;
3256  }
3257 
3258  TRACE("RID: %lu\n", RelativeIds[0]);
3259 
3260  DesiredAccess = READ_CONTROL | USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT;
3261  if ((level == 1) || (level == 2) || (level == 3) || (level == 4) || (level == 11))
3262  DesiredAccess |= USER_LIST_GROUPS;
3263 
3264  /* Open the user object */
3265  Status = SamOpenUser(AccountDomainHandle,
3266  DesiredAccess,
3267  RelativeIds[0],
3268  &UserHandle);
3269  if (!NT_SUCCESS(Status))
3270  {
3271  ERR("SamOpenUser failed (Status %08lx)\n", Status);
3272  ApiStatus = NetpNtStatusToApiStatus(Status);
3273  goto done;
3274  }
3275 
3276  ApiStatus = BuildUserInfoBuffer(BuiltinDomainHandle,
3277  UserHandle,
3278  AccountDomainSid,
3279  RelativeIds[0],
3280  level,
3281  &Buffer);
3282  if (ApiStatus != NERR_Success)
3283  {
3284  ERR("BuildUserInfoBuffer failed (ApiStatus %08lu)\n", ApiStatus);
3285  goto done;
3286  }
3287 
3288 done:
3289  if (UserHandle != NULL)
3290  SamCloseHandle(UserHandle);
3291 
3292  if (RelativeIds != NULL)
3293  SamFreeMemory(RelativeIds);
3294 
3295  if (Use != NULL)
3296  SamFreeMemory(Use);
3297 
3298  if (AccountDomainHandle != NULL)
3299  SamCloseHandle(AccountDomainHandle);
3300 
3301  if (AccountDomainSid != NULL)
3302  RtlFreeHeap(RtlGetProcessHeap(), 0, AccountDomainSid);
3303 
3304  if (BuiltinDomainHandle != NULL)
3305  SamCloseHandle(BuiltinDomainHandle);
3306 
3307  if (BuiltinDomainSid != NULL)
3308  RtlFreeHeap(RtlGetProcessHeap(), 0, BuiltinDomainSid);
3309 
3310  if (ServerHandle != NULL)
3311  SamCloseHandle(ServerHandle);
3312 
3313  *bufptr = (LPBYTE)Buffer;
3314 
3315  return ApiStatus;
3316 }
3317 
3318 
3319 /************************************************************
3320  * NetUserGetLocalGroups (NETAPI32.@)
3321  */
3322 NET_API_STATUS
3323 WINAPI
3324 NetUserGetLocalGroups(LPCWSTR servername,
3325  LPCWSTR username,
3326  DWORD level,
3327  DWORD flags,
3328  LPBYTE* bufptr,
3329  DWORD prefmaxlen,
3330  LPDWORD entriesread,
3331  LPDWORD totalentries)
3332 {
3333  UNICODE_STRING ServerName;
3334  UNICODE_STRING UserName;
3335  SAM_HANDLE ServerHandle = NULL;
3336  SAM_HANDLE BuiltinDomainHandle = NULL;
3337  SAM_HANDLE AccountDomainHandle = NULL;
3338  PSID AccountDomainSid = NULL;
3339  PSID UserSid = NULL;
3340  PULONG RelativeIds = NULL;
3341  PSID_NAME_USE Use = NULL;
3342  ULONG BuiltinMemberCount = 0;
3343  ULONG AccountMemberCount = 0;
3344  PULONG BuiltinAliases = NULL;
3345  PULONG AccountAliases = NULL;
3346  PUNICODE_STRING BuiltinNames = NULL;
3347  PUNICODE_STRING AccountNames = NULL;
3348  PLOCALGROUP_USERS_INFO_0 Buffer = NULL;
3349  ULONG Size;
3350  ULONG Count = 0;
3351  ULONG Index;
3352  ULONG i;
3353  LPWSTR StrPtr;
3354  NET_API_STATUS ApiStatus = NERR_Success;
3355  NTSTATUS Status = STATUS_SUCCESS;
3356 
3357  TRACE("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
3358  debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
3359  prefmaxlen, entriesread, totalentries);
3360 
3361  if (level != 0)
3362  return ERROR_INVALID_LEVEL;
3363 
3364  if (flags & ~LG_INCLUDE_INDIRECT)
3365  return ERROR_INVALID_PARAMETER;
3366 
3367  if (flags & LG_INCLUDE_INDIRECT)
3368  {
3369  WARN("The flag LG_INCLUDE_INDIRECT is not supported yet!\n");
3370  }
3371 
3372  if (servername != NULL)
3373  RtlInitUnicodeString(&ServerName, servername);
3374 
3375  RtlInitUnicodeString(&UserName, username);
3376 
3377  /* Connect to the SAM Server */
3378  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
3379  &ServerHandle,
3380  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
3381  NULL);
3382  if (!NT_SUCCESS(Status))
3383  {
3384  ERR("SamConnect failed (Status %08lx)\n", Status);
3385  ApiStatus = NetpNtStatusToApiStatus(Status);
3386  goto done;
3387  }
3388 
3389  /* Open the Builtin Domain */
3390  Status = OpenBuiltinDomain(ServerHandle,
3391  DOMAIN_LOOKUP | DOMAIN_GET_ALIAS_MEMBERSHIP,
3392  &BuiltinDomainHandle);
3393  if (!NT_SUCCESS(Status))
3394  {
3395  ERR("OpenBuiltinDomain failed (Status %08lx)\n", Status);
3396  ApiStatus = NetpNtStatusToApiStatus(Status);
3397  goto done;
3398  }
3399 
3400  /* Get the Account Domain SID */
3401  Status = GetAccountDomainSid((servername != NULL) ? &ServerName : NULL,
3402  &AccountDomainSid);
3403  if (!NT_SUCCESS(Status))
3404  {
3405  ERR("GetAccountDomainSid failed (Status %08lx)\n", Status);
3406  ApiStatus = NetpNtStatusToApiStatus(Status);
3407  goto done;
3408  }
3409 
3410  /* Open the Account Domain */
3411  Status = SamOpenDomain(ServerHandle,
3412  DOMAIN_LOOKUP | DOMAIN_GET_ALIAS_MEMBERSHIP,
3413  AccountDomainSid,
3414  &AccountDomainHandle);
3415  if (!NT_SUCCESS(Status))
3416  {
3417  ERR("SamOpenDomain failed (Status %08lx)\n", Status);
3418  ApiStatus = NetpNtStatusToApiStatus(Status);
3419  goto done;
3420  }
3421 
3422  /* Get the RID for the given user name */
3423  Status = SamLookupNamesInDomain(AccountDomainHandle,
3424  1,
3425  &UserName,
3426  &RelativeIds,
3427  &Use);
3428  if (!NT_SUCCESS(Status))
3429  {
3430  ERR("SamLookupNamesInDomain(%wZ) failed (Status %08lx)\n", &UserName, Status);
3431  if (Status == STATUS_NONE_MAPPED)
3432  ApiStatus = NERR_UserNotFound;
3433  else
3434  ApiStatus = NetpNtStatusToApiStatus(Status);
3435  goto done;
3436  }
3437 
3438  /* Fail, if it is not a user account */
3439  if (Use[0] != SidTypeUser)
3440  {
3441  ERR("Account is not a User!\n");
3442  ApiStatus = NERR_UserNotFound;
3443  goto done;
3444  }
3445 
3446  /* Build the User SID from the Account Domain SID and the users RID */
3447  ApiStatus = BuildSidFromSidAndRid(AccountDomainSid,
3448  RelativeIds[0],
3449  &UserSid);
3450  if (ApiStatus != NERR_Success)
3451  {
3452  ERR("BuildSidFromSidAndRid failed!\n");
3453  goto done;
3454  }
3455 
3456  /* Get alias memberships in the Builtin Domain */
3457  Status = SamGetAliasMembership(BuiltinDomainHandle,
3458  1,
3459  &UserSid,
3460  &BuiltinMemberCount,
3461  &BuiltinAliases);
3462  if (!NT_SUCCESS(Status))
3463  {
3464  ERR("SamGetAliasMembership failed (Status %08lx)\n", Status);
3465  ApiStatus = NetpNtStatusToApiStatus(Status);
3466  goto done;
3467  }
3468 
3469  if (BuiltinMemberCount > 0)
3470  {
3471  /* Get the Names of the builtin alias members */
3472  Status = SamLookupIdsInDomain(BuiltinDomainHandle,
3473  BuiltinMemberCount,
3474  BuiltinAliases,
3475  &BuiltinNames,
3476  NULL);
3477  if (!NT_SUCCESS(Status))
3478  {
3479  ERR("SamLookupIdsInDomain failed (Status %08lx)\n", Status);
3480  ApiStatus = NetpNtStatusToApiStatus(Status);
3481  goto done;
3482  }
3483  }
3484 
3485  /* Get alias memberships in the Account Domain */
3486  Status = SamGetAliasMembership(AccountDomainHandle,
3487  1,
3488  &UserSid,
3489  &AccountMemberCount,
3490  &AccountAliases);
3491  if (!NT_SUCCESS(Status))
3492  {
3493  ERR("SamGetAliasMembership failed (Status %08lx)\n", Status);
3494  ApiStatus = NetpNtStatusToApiStatus(Status);
3495  goto done;
3496  }
3497 
3498  if (AccountMemberCount > 0)
3499  {
3500  /* Get the Names of the builtin alias members */
3501  Status = SamLookupIdsInDomain(AccountDomainHandle,
3502  AccountMemberCount,
3503  AccountAliases,
3504  &AccountNames,
3505  NULL);
3506  if (!NT_SUCCESS(Status))
3507  {
3508  ERR("SamLookupIdsInDomain failed (Status %08lx)\n", Status);
3509  ApiStatus = NetpNtStatusToApiStatus(Status);
3510  goto done;
3511  }
3512  }
3513 
3514  /* Calculate the required buffer size */
3515  Size = 0;
3516 
3517  for (i = 0; i < BuiltinMemberCount; i++)
3518  {
3519  if (BuiltinNames[i].Length > 0)
3520  {
3521  Size += (sizeof(LOCALGROUP_USERS_INFO_0) + BuiltinNames[i].Length + sizeof(UNICODE_NULL));
3522  Count++;
3523  }
3524  }
3525 
3526  for (i = 0; i < AccountMemberCount; i++)
3527  {
3528  if (AccountNames[i].Length > 0)
3529  {
3530  Size += (sizeof(LOCALGROUP_USERS_INFO_0) + AccountNames[i].Length + sizeof(UNICODE_NULL));
3531  Count++;
3532  }
3533  }
3534 
3535  if (Size == 0)
3536  {
3537  ApiStatus = NERR_Success;
3538  goto done;
3539  }
3540 
3541  /* Allocate buffer */
3542  ApiStatus = NetApiBufferAllocate(Size, (LPVOID*)&Buffer);
3543  if (ApiStatus != NERR_Success)
3544  goto done;
3545 
3546  ZeroMemory(Buffer, Size);
3547 
3548  StrPtr = (LPWSTR)((INT_PTR)Buffer + Count * sizeof(LOCALGROUP_USERS_INFO_0));
3549 
3550  /* Copy data to the allocated buffer */
3551  Index = 0;
3552  for (i = 0; i < BuiltinMemberCount; i++)
3553  {
3554  if (BuiltinNames[i].Length > 0)
3555  {
3556  CopyMemory(StrPtr,
3557  BuiltinNames[i].Buffer,
3558  BuiltinNames[i].Length);
3559  Buffer[Index].lgrui0_name = StrPtr;
3560 
3561  StrPtr = (LPWSTR)((INT_PTR)StrPtr + BuiltinNames[i].Length + sizeof(UNICODE_NULL));
3562  Index++;
3563  }
3564  }
3565 
3566  for (i = 0; i < AccountMemberCount; i++)
3567  {
3568  if (AccountNames[i].Length > 0)
3569  {
3570  CopyMemory(StrPtr,
3571  AccountNames[i].Buffer,
3572  AccountNames[i].Length);
3573  Buffer[Index].lgrui0_name = StrPtr;
3574 
3575  StrPtr = (LPWSTR)((INT_PTR)StrPtr + AccountNames[i].Length + sizeof(UNICODE_NULL));
3576  Index++;
3577  }
3578  }
3579 
3580 done:
3581  if (AccountNames != NULL)
3582  SamFreeMemory(AccountNames);
3583 
3584  if (BuiltinNames != NULL)
3585  SamFreeMemory(BuiltinNames);
3586 
3587  if (AccountAliases != NULL)
3588  SamFreeMemory(AccountAliases);
3589 
3590  if (BuiltinAliases != NULL)
3591  SamFreeMemory(BuiltinAliases);
3592 
3593  if (RelativeIds != NULL)
3594  SamFreeMemory(RelativeIds);
3595 
3596  if (Use != NULL)
3597  SamFreeMemory(Use);
3598 
3599  if (UserSid != NULL)
3600  NetApiBufferFree(UserSid);
3601 
3602  if (AccountDomainSid != NULL)
3603  RtlFreeHeap(RtlGetProcessHeap(), 0, AccountDomainSid);
3604 
3605  if (AccountDomainHandle != NULL)
3606  SamCloseHandle(AccountDomainHandle);
3607 
3608  if (BuiltinDomainHandle != NULL)
3609  SamCloseHandle(BuiltinDomainHandle);
3610 
3611  if (ServerHandle != NULL)
3612  SamCloseHandle(ServerHandle);
3613 
3614  if (ApiStatus != NERR_Success && ApiStatus != ERROR_MORE_DATA)
3615  {
3616  *entriesread = 0;
3617  *totalentries = 0;
3618  }
3619  else
3620  {
3621  *entriesread = Count;
3622  *totalentries = Count;
3623  }
3624 
3625  *bufptr = (LPBYTE)Buffer;
3626 
3627  return ApiStatus;
3628 }
3629 
3630 
3631 /******************************************************************************
3632  * NetUserModalsGet (NETAPI32.@)
3633  *
3634  * Retrieves global information for all users and global groups in the security
3635  * database.
3636  *
3637  * PARAMS
3638  * servername [I] Specifies the DNS or the NetBIOS name of the remote server
3639  * on which the function is to execute.
3640  * level [I] Information level of the data.
3641  * 0 Return global passwords parameters. bufptr points to a
3642  * USER_MODALS_INFO_0 struct.
3643  * 1 Return logon server and domain controller information. bufptr
3644  * points to a USER_MODALS_INFO_1 struct.
3645  * 2 Return domain name and identifier. bufptr points to a
3646  * USER_MODALS_INFO_2 struct.
3647  * 3 Return lockout information. bufptr points to a USER_MODALS_INFO_3
3648  * struct.
3649  * bufptr [O] Buffer that receives the data.
3650  *
3651  * RETURNS
3652  * Success: NERR_Success.
3653  * Failure:
3654  * ERROR_ACCESS_DENIED - the user does not have access to the info.
3655  * NERR_InvalidComputer - computer name is invalid.
3656  */
3657 NET_API_STATUS
3658 WINAPI
3659 NetUserModalsGet(LPCWSTR servername,
3660  DWORD level,
3661  LPBYTE *bufptr)
3662 {
3663  UNICODE_STRING ServerName;
3664  SAM_HANDLE ServerHandle = NULL;
3665  SAM_HANDLE DomainHandle = NULL;
3666  PSID DomainSid = NULL;
3667  PDOMAIN_PASSWORD_INFORMATION PasswordInfo = NULL;
3668  PDOMAIN_LOGOFF_INFORMATION LogoffInfo = NULL;
3669  PDOMAIN_SERVER_ROLE_INFORMATION ServerRoleInfo = NULL;
3670  PDOMAIN_REPLICATION_INFORMATION ReplicationInfo = NULL;
3671  PDOMAIN_NAME_INFORMATION NameInfo = NULL;
3672  PDOMAIN_LOCKOUT_INFORMATION LockoutInfo = NULL;
3673  ULONG DesiredAccess;
3674  ULONG BufferSize;
3675  PUSER_MODALS_INFO_0 umi0;
3676  PUSER_MODALS_INFO_1 umi1;
3677  PUSER_MODALS_INFO_2 umi2;
3678  PUSER_MODALS_INFO_3 umi3;
3679  NET_API_STATUS ApiStatus = NERR_Success;
3680  NTSTATUS Status = STATUS_SUCCESS;
3681 
3682  TRACE("(%s %d %p)\n", debugstr_w(servername), level, bufptr);
3683 
3684  *bufptr = NULL;
3685 
3686  if (servername != NULL)
3687  RtlInitUnicodeString(&ServerName, servername);
3688 
3689  /* Connect to the SAM Server */
3690  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
3691  &ServerHandle,
3692  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
3693  NULL);
3694  if (!NT_SUCCESS(Status))
3695  {
3696  ERR("SamConnect failed (Status %08lx)\n", Status);
3697  ApiStatus = NetpNtStatusToApiStatus(Status);
3698  goto done;
3699  }
3700 
3701  /* Get the Account Domain SID */
3702  Status = GetAccountDomainSid((servername != NULL) ? &ServerName : NULL,
3703  &DomainSid);
3704  if (!NT_SUCCESS(Status))
3705  {
3706  ERR("GetAccountDomainSid failed (Status %08lx)\n", Status);
3707  ApiStatus = NetpNtStatusToApiStatus(Status);
3708  goto done;
3709  }
3710 
3711  switch (level)
3712  {
3713  case 0:
3714  DesiredAccess = DOMAIN_READ_OTHER_PARAMETERS | DOMAIN_READ_PASSWORD_PARAMETERS;
3715  break;
3716 
3717  case 1:
3718  DesiredAccess = DOMAIN_READ_OTHER_PARAMETERS;
3719  break;
3720 
3721  case 2:
3722  DesiredAccess = DOMAIN_READ_OTHER_PARAMETERS;
3723  break;
3724 
3725  case 3:
3726  DesiredAccess = DOMAIN_READ_PASSWORD_PARAMETERS;
3727  break;
3728 
3729  default:
3730  ApiStatus = ERROR_INVALID_LEVEL;
3731  goto done;
3732  }
3733 
3734  /* Open the Account Domain */
3735  Status = SamOpenDomain(ServerHandle,
3736  DesiredAccess,
3737  DomainSid,
3738  &DomainHandle);
3739  if (!NT_SUCCESS(Status))
3740  {
3741  ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
3742  ApiStatus = NetpNtStatusToApiStatus(Status);
3743  goto done;
3744  }
3745 
3746  switch (level)
3747  {
3748  case 0:
3749  /* return global passwords parameters */
3750  Status = SamQueryInformationDomain(DomainHandle,
3751  DomainPasswordInformation,
3752  (PVOID*)&PasswordInfo);
3753  if (!NT_SUCCESS(Status))
3754  {
3755  ApiStatus = NetpNtStatusToApiStatus(Status);
3756  goto done;
3757  }
3758 
3759  Status = SamQueryInformationDomain(DomainHandle,
3760  DomainLogoffInformation,
3761  (PVOID*)&LogoffInfo);
3762  if (!NT_SUCCESS(Status))
3763  {
3764  ApiStatus = NetpNtStatusToApiStatus(Status);
3765  goto done;
3766  }
3767 
3768  BufferSize = sizeof(USER_MODALS_INFO_0);
3769  break;
3770 
3771  case 1:
3772  /* return logon server and domain controller info */
3773  Status = SamQueryInformationDomain(DomainHandle,
3774  DomainServerRoleInformation,
3775  (PVOID*)&ServerRoleInfo);
3776  if (!NT_SUCCESS(Status))
3777  {
3778  ApiStatus = NetpNtStatusToApiStatus(Status);
3779  goto done;
3780  }
3781 
3782  Status = SamQueryInformationDomain(DomainHandle,
3783  DomainReplicationInformation,
3784  (PVOID*)&ReplicationInfo);
3785  if (!NT_SUCCESS(Status))
3786  {
3787  ApiStatus = NetpNtStatusToApiStatus(Status);
3788  goto done;
3789  }
3790 
3791  BufferSize = sizeof(USER_MODALS_INFO_1) +
3792  ReplicationInfo->ReplicaSourceNodeName.Length + sizeof(WCHAR);
3793  break;
3794 
3795  case 2:
3796  /* return domain name and identifier */
3797  Status = SamQueryInformationDomain(DomainHandle,
3798  DomainNameInformation,
3799  (PVOID*)&NameInfo);
3800  if (!NT_SUCCESS(Status))
3801  {
3802  ApiStatus = NetpNtStatusToApiStatus(Status);
3803  goto done;
3804  }
3805 
3806  BufferSize = sizeof( USER_MODALS_INFO_2 ) +
3807  NameInfo->DomainName.Length + sizeof(WCHAR) +
3808  RtlLengthSid(DomainSid);
3809  break;
3810 
3811  case 3:
3812  /* return lockout information */
3813  Status = SamQueryInformationDomain(DomainHandle,
3814  DomainLockoutInformation,
3815  (PVOID*)&LockoutInfo);
3816  if (!NT_SUCCESS(Status))
3817  {
3818  ApiStatus = NetpNtStatusToApiStatus(Status);
3819  goto done;
3820  }
3821 
3822  BufferSize = sizeof(USER_MODALS_INFO_3);
3823  break;
3824 
3825  default:
3826  TRACE("Invalid level %d is specified\n", level);
3827  ApiStatus = ERROR_INVALID_LEVEL;
3828  goto done;
3829  }
3830 
3831 
3832  ApiStatus = NetApiBufferAllocate(BufferSize,
3833  (LPVOID *)bufptr);
3834  if (ApiStatus != NERR_Success)
3835  {
3836  WARN("NetApiBufferAllocate() failed\n");
3837  goto done;
3838  }
3839 
3840  switch (level)
3841  {
3842  case 0:
3843  umi0 = (PUSER_MODALS_INFO_0)*bufptr;
3844 
3845  umi0->usrmod0_min_passwd_len = PasswordInfo->MinPasswordLength;
3846  umi0->usrmod0_max_passwd_age = (ULONG)(-PasswordInfo->MaxPasswordAge.QuadPart / 10000000);
3847  umi0->usrmod0_min_passwd_age =
3848  DeltaTimeToSeconds(PasswordInfo->MinPasswordAge);
3849  umi0->usrmod0_force_logoff =
3850  DeltaTimeToSeconds(LogoffInfo->ForceLogoff);
3851  umi0->usrmod0_password_hist_len = PasswordInfo->PasswordHistoryLength;
3852  break;
3853 
3854  case 1:
3855  umi1 = (PUSER_MODALS_INFO_1)*bufptr;
3856 
3857  switch (ServerRoleInfo->DomainServerRole)
3858  {
3859  case DomainServerRolePrimary:
3860  umi1->usrmod1_role = UAS_ROLE_PRIMARY;
3861  break;
3862 
3863  case DomainServerRoleBackup:
3864  umi1->usrmod1_role = UAS_ROLE_BACKUP;
3865  break;
3866 
3867  default:
3868  ApiStatus = NERR_InternalError;
3869  goto done;
3870  }
3871 
3872  umi1->usrmod1_primary = (LPWSTR)(*bufptr + sizeof(USER_MODALS_INFO_1));
3873  RtlCopyMemory(umi1->usrmod1_primary,
3874  ReplicationInfo->ReplicaSourceNodeName.Buffer,
3875  ReplicationInfo->ReplicaSourceNodeName.Length);
3876  umi1->usrmod1_primary[ReplicationInfo->ReplicaSourceNodeName.Length / sizeof(WCHAR)] = UNICODE_NULL;
3877  break;
3878 
3879  case 2:
3880  umi2 = (PUSER_MODALS_INFO_2)*bufptr;
3881 
3882  umi2->usrmod2_domain_name = (LPWSTR)(*bufptr + sizeof(USER_MODALS_INFO_2));
3883  RtlCopyMemory(umi2->usrmod2_domain_name,
3884  NameInfo->DomainName.Buffer,
3885  NameInfo->DomainName.Length);
3886  umi2->usrmod2_domain_name[NameInfo->DomainName.Length / sizeof(WCHAR)] = UNICODE_NULL;
3887 
3888  umi2->usrmod2_domain_id = *bufptr +
3889  sizeof(USER_MODALS_INFO_2) +
3890  NameInfo->DomainName.Length + sizeof(WCHAR);
3891  RtlCopyMemory(umi2->usrmod2_domain_id,
3892  DomainSid,
3893  RtlLengthSid(DomainSid));
3894  break;
3895 
3896  case 3:
3897  umi3 = (PUSER_MODALS_INFO_3)*bufptr;
3898  umi3->usrmod3_lockout_duration =
3899  DeltaTimeToSeconds(LockoutInfo->LockoutDuration);
3900  umi3->usrmod3_lockout_observation_window =
3901  DeltaTimeToSeconds(LockoutInfo->LockoutObservationWindow );
3902  umi3->usrmod3_lockout_threshold = LockoutInfo->LockoutThreshold;
3903  break;
3904  }
3905 
3906 done:
3907  if (LockoutInfo != NULL)
3908  SamFreeMemory(LockoutInfo);
3909 
3910  if (NameInfo != NULL)
3911  SamFreeMemory(NameInfo);
3912 
3913  if (ReplicationInfo != NULL)
3914  SamFreeMemory(ReplicationInfo);
3915 
3916  if (ServerRoleInfo != NULL)
3917  SamFreeMemory(ServerRoleInfo);
3918 
3919  if (LogoffInfo != NULL)
3920  SamFreeMemory(LogoffInfo);
3921 
3922  if (PasswordInfo != NULL)
3923  SamFreeMemory(PasswordInfo);
3924 
3925  if (DomainSid != NULL)
3926  RtlFreeHeap(RtlGetProcessHeap(), 0, DomainSid);
3927 
3928  if (DomainHandle != NULL)
3929  SamCloseHandle(DomainHandle);
3930 
3931  if (ServerHandle != NULL)
3932  SamCloseHandle(ServerHandle);
3933 
3934  return ApiStatus;
3935 }
3936 
3937 
3938 /******************************************************************************
3939  * NetUserModalsSet (NETAPI32.@)
3940  */
3941 NET_API_STATUS
3942 WINAPI
3943 NetUserModalsSet(IN LPCWSTR servername,
3944  IN DWORD level,
3945  IN LPBYTE buf,
3946  OUT LPDWORD parm_err)
3947 {
3948  FIXME("(%s %d %p %p)\n", debugstr_w(servername), level, buf, parm_err);
3949  return ERROR_ACCESS_DENIED;
3950 }
3951 
3952 
3953 /******************************************************************************
3954  * NetUserSetGroups (NETAPI32.@)
3955  */
3956 NET_API_STATUS
3957 WINAPI
3958 NetUserSetGroups(LPCWSTR servername,
3959  LPCWSTR username,
3960  DWORD level,
3961  LPBYTE buf,
3962  DWORD num_entries)
3963 {
3964  FIXME("(%s %s %lu %p %lu)\n",
3965  debugstr_w(servername), debugstr_w(username), level, buf, num_entries);
3966  return ERROR_ACCESS_DENIED;
3967 }
3968 
3969 
3970 /******************************************************************************
3971  * NetUserSetInfo (NETAPI32.@)
3972  */
3973 NET_API_STATUS
3974 WINAPI
3975 NetUserSetInfo(LPCWSTR servername,
3976  LPCWSTR username,
3977  DWORD level,
3978  LPBYTE buf,
3979  LPDWORD parm_err)
3980 {
3981  UNICODE_STRING ServerName;
3982  UNICODE_STRING UserName;
3983  SAM_HANDLE ServerHandle = NULL;
3984  SAM_HANDLE AccountDomainHandle = NULL;
3985  SAM_HANDLE UserHandle = NULL;
3986  NET_API_STATUS ApiStatus = NERR_Success;
3987  NTSTATUS Status = STATUS_SUCCESS;
3988 
3989  TRACE("(%s %s %lu %p %p)\n",
3990  debugstr_w(servername), debugstr_w(username), level, buf, parm_err);
3991 
3992  if (parm_err != NULL)
3993  *parm_err = PARM_ERROR_NONE;
3994 
3995  /* Check the info level */
3996  switch (level)
3997  {
3998  case 0:
3999  case 1:
4000  case 2:
4001  case 3:
4002  case 4:
4003 // case 21:
4004  case 22:
4005  case 1003:
4006 // case 1005:
4007  case 1006:
4008  case 1007:
4009  case 1008:
4010  case 1009:
4011 // case 1010:
4012  case 1011:
4013  case 1012:
4014  case 1013:
4015  case 1014:
4016  case 1017:
4017  case 1018:
4018  case 1020:
4019  case 1024:
4020  case 1025:
4021  case 1051:
4022  case 1052:
4023  case 1053:
4024  break;
4025 
4026  default:
4027  return ERROR_INVALID_LEVEL;
4028  }
4029 
4030  if (servername != NULL)
4031  RtlInitUnicodeString(&ServerName, servername);
4032 
4033  RtlInitUnicodeString(&UserName, username);
4034 
4035  /* Connect to the SAM Server */
4036  Status = SamConnect((servername != NULL) ? &ServerName : NULL,
4037  &ServerHandle,
4038  SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
4039  NULL);
4040  if (!NT_SUCCESS(Status))
4041  {
4042  ERR("SamConnect failed (Status %08lx)\n", Status);
4043  ApiStatus = NetpNtStatusToApiStatus(Status);
4044  goto done;
4045  }
4046 
4047  /* Open the Account Domain */
4048  Status = OpenAccountDomain(ServerHandle,
4049  (servername != NULL) ? &ServerName : NULL,
4050  DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP | DOMAIN_READ_PASSWORD_PARAMETERS,
4051  &AccountDomainHandle);
4052  if (!NT_SUCCESS(Status))
4053  {
4054  ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
4055  ApiStatus = NetpNtStatusToApiStatus(Status);
4056  goto done;
4057  }
4058 
4059  /* Open the User Account */
4060  ApiStatus = OpenUserByName(AccountDomainHandle,
4061  &UserName,
4062  USER_ALL_ACCESS,
4063  &UserHandle);
4064  if (ApiStatus != NERR_Success)
4065  {
4066  ERR("OpenUserByName(%wZ) failed (ApiStatus %lu)\n", &UserName, ApiStatus);
4067  goto done;
4068  }
4069 
4070  /* Set user information */
4071  ApiStatus = SetUserInfo(UserHandle,
4072  buf,
4073  level,
4074  parm_err);
4075  if (ApiStatus != NERR_Success)
4076  {
4077  ERR("SetUserInfo failed (Status %lu)\n", ApiStatus);
4078  }
4079 
4080 done:
4081  if (UserHandle != NULL)
4082  SamCloseHandle(UserHandle);
4083 
4084  if (AccountDomainHandle != NULL)
4085  SamCloseHandle(AccountDomainHandle);
4086 
4087  if (ServerHandle != NULL)
4088  SamCloseHandle(ServerHandle);
4089 
4090  return ApiStatus;
4091 }
4092 
4093 /* EOF */
AF_OP_ACCOUNTS
#define AF_OP_ACCOUNTS
Definition: lmaccess.h:48
GetAccountControl
static ULONG GetAccountControl(ULONG Flags)
Definition: user.c:206
_SECURITY_DESCRIPTOR
Definition: ms-dtyp.idl:301
USER_INTERDOMAIN_TRUST_ACCOUNT
#define USER_INTERDOMAIN_TRUST_ACCOUNT
Definition: ntsam.h:173
_USER_INFO_4::usri4_password_expired
DWORD usri4_password_expired
Definition: lmaccess.h:298
_USER_INFO_4::usri4_last_logoff
DWORD usri4_last_logoff
Definition: lmaccess.h:284
NetApiBufferAllocate
NET_API_STATUS WINAPI NetApiBufferAllocate(DWORD ByteCount, LPVOID *Buffer)
Definition: apibuf.c:28
_USER_INFO_11::usri11_usr_comment
LPWSTR usri11_usr_comment
Definition: lmaccess.h:309
_USER_INFO_1014::usri1014_workstations
LPWSTR usri1014_workstations
Definition: lmaccess.h:402
_USER_ALL_INFORMATION::LogonHours
LOGON_HOURS LogonHours
Definition: ntsam.h:682
USER_ALL_PARAMETERS
#define USER_ALL_PARAMETERS
Definition: ntsam.h:217
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
SamCloseHandle
NTSTATUS NTAPI SamCloseHandle(IN SAM_HANDLE SamHandle)
Definition: samlib.c:476
USER_PASSWORD_EXPIRED
#define USER_PASSWORD_EXPIRED
Definition: ntsam.h:184
_USER_INFO_1024
Definition: lmaccess.h:417
_USER_INFO_11::usri11_auth_flags
DWORD usri11_auth_flags
Definition: lmaccess.h:312
_USER_INFO_1::usri1_password_age
DWORD usri1_password_age
Definition: lmaccess.h:205
SamGetGroupsForUser
NTSTATUS NTAPI SamGetGroupsForUser(IN SAM_HANDLE UserHandle, OUT PGROUP_MEMBERSHIP *Groups, OUT PULONG MembershipCount)
Definition: samlib.c:1058
SAM_SERVER_CONNECT
#define SAM_SERVER_CONNECT
Definition: ntsam.h:99
_USER_INFO_1::usri1_password
LPWSTR usri1_password
Definition: lmaccess.h:204
level
GLint level
Definition: gl.h:1546
IN
#define IN
Definition: typedefs.h:39
_USER_INFO_22::usri22_parms
LPWSTR usri22_parms
Definition: lmaccess.h:350
DesiredAccess
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2654
_USER_ALL_INFORMATION::PrimaryGroupId
ULONG PrimaryGroupId
Definition: ntsam.h:679
_USER_INFO_3::usri3_comment
LPWSTR usri3_comment
Definition: lmaccess.h:244
PUSER_INFO_1006
struct _USER_INFO_1006 * PUSER_INFO_1006
USER_ALL_ACCOUNTEXPIRES
#define USER_ALL_ACCOUNTEXPIRES
Definition: ntsam.h:215
USER_UNITS_PER_WEEK_PARMNUM
#define USER_UNITS_PER_WEEK_PARMNUM
Definition: lmaccess.h:71
_USER_INFO_11::usri11_units_per_week
DWORD usri11_units_per_week
Definition: lmaccess.h:324
_USER_ALL_INFORMATION::AccountExpires
LARGE_INTEGER AccountExpires
Definition: ntsam.h:661
MSV1_0_PACKAGE_NAME
#define MSV1_0_PACKAGE_NAME
Definition: ntsecapi.h:42
PUSER_INFO_4
struct _USER_INFO_4 * PUSER_INFO_4
_USER_INFO_23::usri23_name
LPWSTR usri23_name
Definition: lmaccess.h:365
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
_USER_INFO_3::usri3_parms
LPWSTR usri3_parms
Definition: lmaccess.h:250
_USER_INFO_2::usri2_logon_server
LPWSTR usri2_logon_server
Definition: lmaccess.h:234
_USER_MODALS_INFO_3
Definition: lmaccess.h:447
USER_PASSWORD_NOT_REQUIRED
#define USER_PASSWORD_NOT_REQUIRED
Definition: ntsam.h:169
_USER_INFO_11::usri11_logon_hours
PBYTE usri11_logon_hours
Definition: lmaccess.h:325
_USER_INFO_3::usri3_bad_pw_count
DWORD usri3_bad_pw_count
Definition: lmaccess.h:258
_USER_ALL_INFORMATION::ScriptPath
UNICODE_STRING ScriptPath
Definition: ntsam.h:668
MSV1_0_CHANGEPASSWORD_REQUEST
struct _MSV1_0_CHANGEPASSWORD_REQUEST MSV1_0_CHANGEPASSWORD_REQUEST
_USER_INFO_11::usri11_logon_server
LPWSTR usri11_logon_server
Definition: lmaccess.h:320
g_EnumContextListLock
CRITICAL_SECTION g_EnumContextListLock
Definition: user.c:57
_USER_ALL_INFORMATION::PasswordExpired
BOOLEAN PasswordExpired
Definition: ntsam.h:689
bufptr
static unsigned int bufptr
Definition: tncon.cpp:77
_SID
Definition: ms-dtyp.idl:198
BuildUserInfoBuffer
static NET_API_STATUS BuildUserInfoBuffer(_In_ SAM_HANDLE BuiltinDomainHandle, _In_ SAM_HANDLE UserHandle, _In_ PSID AccountDomainSid, _In_ ULONG RelativeId, _In_ DWORD level, _Out_ LPVOID *Buffer)
Definition: user.c:550
_USER_MODALS_INFO_1
Definition: lmaccess.h:439
_USER_ALL_INFORMATION::CountryCode
USHORT CountryCode
Definition: ntsam.h:685
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
DOMAIN_GET_ALIAS_MEMBERSHIP
#define DOMAIN_GET_ALIAS_MEMBERSHIP
Definition: ntsam.h:40
UF_INTERDOMAIN_TRUST_ACCOUNT
#define UF_INTERDOMAIN_TRUST_ACCOUNT
Definition: lmaccess.h:31
_ACCESS_ALLOWED_ACE
Definition: ms-dtyp.idl:215
_USER_ALL_INFORMATION::PrivateData
UNICODE_STRING PrivateData
Definition: ntsam.h:676
_DOMAIN_LOCKOUT_INFORMATION::LockoutDuration
LARGE_INTEGER LockoutDuration
Definition: ntsam.h:422
USER_MODALS_INFO_1
struct _USER_MODALS_INFO_1 USER_MODALS_INFO_1
_USER_INFO_20
Definition: lmaccess.h:328
PUSER_INFO_1009
struct _USER_INFO_1009 * PUSER_INFO_1009
SID
struct _SID SID
PUSER_INFO_11
struct _USER_INFO_11 * PUSER_INFO_11
_ENUM_CONTEXT::BuiltinDomainHandle
SAM_HANDLE BuiltinDomainHandle
Definition: local_group.c:36
_USER_INFO_0
Definition: lmaccess.h:201
TRUE
#define TRUE
Definition: types.h:120
SecurityDescriptor
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:182
_USER_INFO_3::usri3_home_dir
LPWSTR usri3_home_dir
Definition: lmaccess.h:243
_ACL
Definition: ms-dtyp.idl:293
USER_INFO_20
struct _USER_INFO_20 USER_INFO_20
_USER_INFO_2::usri2_priv
DWORD usri2_priv
Definition: lmaccess.h:216
RtlSecondsSince1970ToTime
NTSYSAPI VOID NTAPI RtlSecondsSince1970ToTime(_In_ ULONG SecondsSince1970, _Out_ PLARGE_INTEGER Time)
OpenUserByName
static NET_API_STATUS OpenUserByName(SAM_HANDLE DomainHandle, PUNICODE_STRING UserName, ULONG DesiredAccess, PSAM_HANDLE UserHandle)
Definition: user.c:2215
DOMAIN_ALIAS_RID_ACCOUNT_OPS
#define DOMAIN_ALIAS_RID_ACCOUNT_OPS
Definition: setypes.h:629
_USER_INFO_1012
Definition: lmaccess.h:395
_USER_INFO_11::usri11_last_logon
DWORD usri11_last_logon
Definition: lmaccess.h:316
_USER_INFO_2::usri2_num_logons
DWORD usri2_num_logons
Definition: lmaccess.h:233
_USER_ALL_INFORMATION::HomeDirectoryDrive
UNICODE_STRING HomeDirectoryDrive
Definition: ntsam.h:667
PUSER_MODALS_INFO_1
struct _USER_MODALS_INFO_1 * PUSER_MODALS_INFO_1
_DOMAIN_SERVER_ROLE_INFORMATION::DomainServerRole
DOMAIN_SERVER_ROLE DomainServerRole
Definition: ntsam.h:391
_USER_INFO_11::usri11_last_logoff
DWORD usri11_last_logoff
Definition: lmaccess.h:317
_USER_MODALS_INFO_3::usrmod3_lockout_threshold
DWORD usrmod3_lockout_threshold
Definition: lmaccess.h:450
_USER_INFO_3::usri3_profile
LPWSTR usri3_profile
Definition: lmaccess.h:265
SamOpenDomain
NTSTATUS NTAPI SamOpenDomain(IN SAM_HANDLE ServerHandle, IN ACCESS_MASK DesiredAccess, IN PSID DomainId, OUT PSAM_HANDLE DomainHandle)
Definition: samlib.c:1441
Ptr
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
_USER_INFO_1020
Definition: lmaccess.h:410
WARN
#define WARN(fmt,...)
Definition: debug.h:112
_USER_INFO_2::usri2_name
LPWSTR usri2_name
Definition: lmaccess.h:213
USER_TEMP_DUPLICATE_ACCOUNT
#define USER_TEMP_DUPLICATE_ACCOUNT
Definition: ntsam.h:170
ERROR_NONE_MAPPED
#define ERROR_NONE_MAPPED
Definition: winerror.h:814
_USER_INFO_1006
Definition: lmaccess.h:377
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
_USER_INFO_22::usri22_workstations
LPWSTR usri22_workstations
Definition: lmaccess.h:351
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
WorldAuthority
static SID_IDENTIFIER_AUTHORITY WorldAuthority
Definition: security.c:14
RtlFreeHeap
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
USER_INFO_10
struct _USER_INFO_10 USER_INFO_10
_USER_INFO_0::usri0_name
LPWSTR usri0_name
Definition: lmaccess.h:201
_USER_INFO_1025::usri1025_code_page
DWORD usri1025_code_page
Definition: lmaccess.h:421
UF_TEMP_DUPLICATE_ACCOUNT
#define UF_TEMP_DUPLICATE_ACCOUNT
Definition: lmaccess.h:29
_SAM_RID_ENUMERATION::Name
UNICODE_STRING Name
Definition: ntsam.h:268
_USER_INFO_3::usri3_code_page
DWORD usri3_code_page
Definition: lmaccess.h:262
_USER_MODALS_INFO_1::usrmod1_primary
LPWSTR usrmod1_primary
Definition: lmaccess.h:441
_USER_INFO_22::usri22_country_code
DWORD usri22_country_code
Definition: lmaccess.h:361
_ENUM_CONTEXT::Buffer
PSAM_RID_ENUMERATION Buffer
Definition: local_group.c:40
_USER_INFO_23
Definition: lmaccess.h:364
_USER_INFO_4::usri4_home_dir
LPWSTR usri4_home_dir
Definition: lmaccess.h:274
PUSER_INFO_10
struct _USER_INFO_10 * PUSER_INFO_10
_USER_INFO_10::usri10_comment
LPWSTR usri10_comment
Definition: lmaccess.h:302
ERROR_NOT_ENOUGH_MEMORY
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
_USER_INFO_22::usri22_code_page
DWORD usri22_code_page
Definition: lmaccess.h:362
_USER_MODALS_INFO_3::usrmod3_lockout_duration
DWORD usrmod3_lockout_duration
Definition: lmaccess.h:448
Size
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
ZeroMemory
#define ZeroMemory
Definition: winbase.h:1664
RtlSubAuthoritySid
NTSYSAPI PULONG NTAPI RtlSubAuthoritySid(_In_ PSID Sid, _In_ ULONG SubAuthority)
_DOMAIN_SERVER_ROLE_INFORMATION
Definition: ntsam.h:389
_USER_INFO_1053
Definition: lmaccess.h:429
USER_ALL_LOGONHOURS
#define USER_ALL_LOGONHOURS
Definition: ntsam.h:209
RtlQueryInformationAcl
NTSYSAPI NTSTATUS WINAPI RtlQueryInformationAcl(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS)
SamQueryInformationDomain
NTSTATUS NTAPI SamQueryInformationDomain(IN SAM_HANDLE DomainHandle, IN DOMAIN_INFORMATION_CLASS DomainInformationClass, OUT PVOID *Buffer)
Definition: samlib.c:1641
Level
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
_USER_INFO_10::usri10_name
LPWSTR usri10_name
Definition: lmaccess.h:301
_ENUM_CONTEXT::BuiltinDone
BOOLEAN BuiltinDone
Definition: user.c:52
_USER_INFO_3::usri3_acct_expires
DWORD usri3_acct_expires
Definition: lmaccess.h:254
RtlGetAce
NTSYSAPI NTSTATUS NTAPI RtlGetAce(PACL Acl, ULONG AceIndex, PVOID *Ace)
AF_OP_SERVER
#define AF_OP_SERVER
Definition: lmaccess.h:47
_USER_INFO_1011::usri1011_full_name
LPWSTR usri1011_full_name
Definition: lmaccess.h:393
_USER_INFO_11::usri11_full_name
LPWSTR usri11_full_name
Definition: lmaccess.h:310
USER_INFO_4
struct _USER_INFO_4 USER_INFO_4
USER_HOME_DIRECTORY_REQUIRED
#define USER_HOME_DIRECTORY_REQUIRED
Definition: ntsam.h:168
_USER_INFO_4::usri4_flags
DWORD usri4_flags
Definition: lmaccess.h:276
SamEnumerateUsersInDomain
NTSTATUS NTAPI SamEnumerateUsersInDomain(IN SAM_HANDLE DomainHandle, IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext, IN ULONG UserAccountControl, OUT PVOID *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
Definition: samlib.c:897
_USER_ALL_INFORMATION::ProfilePath
UNICODE_STRING ProfilePath
Definition: ntsam.h:669
_MSV1_0_CHANGEPASSWORD_REQUEST
Definition: ntsecapi.h:510
MAXLONGLONG
#define MAXLONGLONG
_USER_INFO_1020::usri1020_logon_hours
PBYTE usri1020_logon_hours
Definition: lmaccess.h:412
_ENUM_CONTEXT::Index
ULONG Index
Definition: local_group.c:42
_USER_INFO_4::usri4_auth_flags
DWORD usri4_auth_flags
Definition: lmaccess.h:278
_USER_INFO_2::usri2_auth_flags
DWORD usri2_auth_flags
Definition: lmaccess.h:221
BuiltinDomainSid
PSID BuiltinDomainSid
Definition: globals.c:16
NERR_GroupNotFound
#define NERR_GroupNotFound
Definition: lmerr.h:87
_USER_INFO_4::usri4_logon_server
LPWSTR usri4_logon_server
Definition: lmaccess.h:291
INT_PTR
int32_t INT_PTR
Definition: typedefs.h:64
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
_USER_INFO_1009
Definition: lmaccess.h:386
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
_USER_INFO_1008::usri1008_flags
DWORD usri1008_flags
Definition: lmaccess.h:384
_MSV1_0_CHANGEPASSWORD_RESPONSE
Definition: ntsecapi.h:518
PUSER_INFO_1014
struct _USER_INFO_1014 * PUSER_INFO_1014
_USER_ALL_INFORMATION::UserAccountControl
ULONG UserAccountControl
Definition: ntsam.h:680
_USER_ALL_INFORMATION::CodePage
USHORT CodePage
Definition: ntsam.h:686
GetPasswordAge
static DWORD GetPasswordAge(IN PLARGE_INTEGER PasswordLastSet)
Definition: user.c:243
PARM_ERROR_NONE
#define PARM_ERROR_NONE
Definition: lmcons.h:56
OpenAccountDomain
NTSTATUS OpenAccountDomain(IN SAM_HANDLE ServerHandle, IN PUNICODE_STRING ServerName, IN ULONG DesiredAccess, OUT PSAM_HANDLE DomainHandle)
Definition: utils.c:113
_LOGON_HOURS::UnitsPerWeek
USHORT UnitsPerWeek
Definition: ntsam.h:474
_USER_INFO_11::usri11_bad_pw_count
DWORD usri11_bad_pw_count
Definition: lmaccess.h:318
LookupEnumContext
static PENUM_CONTEXT LookupEnumContext(SAM_ENUMERATE_HANDLE EnumerationHandle)
Definition: user.c:2707
_LOCALGROUP_USERS_INFO_0
Definition: lmaccess.h:532
_USER_INFO_3::usri3_num_logons
DWORD usri3_num_logons
Definition: lmaccess.h:259
_USER_INFO_2::usri2_acct_expires
DWORD usri2_acct_expires
Definition: lmaccess.h:228
RtlGetDaclSecurityDescriptor
NTSYSAPI NTSTATUS NTAPI RtlGetDaclSecurityDescriptor(_In_ PSECURITY_DESCRIPTOR SecurityDescriptor, _Out_ PBOOLEAN DaclPresent, _Out_ PACL *Dacl, _Out_ PBOOLEAN DaclDefaulted)
STATUS_NONE_MAPPED
#define STATUS_NONE_MAPPED
Definition: ntstatus.h:351
USER_ALL_USERNAME
#define USER_ALL_USERNAME
Definition: ntsam.h:196
_USER_INFO_4::usri4_priv
DWORD usri4_priv
Definition: lmaccess.h:273
PUSER_INFO_1007
struct _USER_INFO_1007 * PUSER_INFO_1007
USER_ACCOUNT_DISABLED
#define USER_ACCOUNT_DISABLED
Definition: ntsam.h:167
_USER_INFO_3::usri3_home_dir_drive
LPWSTR usri3_home_dir_drive
Definition: lmaccess.h:266
NERR_Success
#define NERR_Success
Definition: lmerr.h:5
_USER_MODALS_INFO_0::usrmod0_min_passwd_len
DWORD usrmod0_min_passwd_len
Definition: lmaccess.h:433
RtlInitAnsiString
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
_ACL_SIZE_INFORMATION
Definition: winnt_old.h:1146
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
USHRT_MAX
#define USHRT_MAX
Definition: limits.h:38
DeltaTimeToSeconds
static ULONG DeltaTimeToSeconds(LARGE_INTEGER DeltaTime)
Definition: user.c:62
USER_MODALS_INFO_3
struct _USER_MODALS_INFO_3 USER_MODALS_INFO_3
NERR_InternalError
#define NERR_InternalError
Definition: lmerr.h:28
PUSER_INFO_1012
struct _USER_INFO_1012 * PUSER_INFO_1012
_USER_INFO_2::usri2_last_logoff
DWORD usri2_last_logoff
Definition: lmaccess.h:227
RemoveEntryList
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
_USER_INFO_11
Definition: lmaccess.h:306
_USER_INFO_4::usri4_country_code
DWORD usri4_country_code
Definition: lmaccess.h:292
USER_PRIV_USER
#define USER_PRIV_USER
Definition: lmaccess.h:117
_USER_INFO_1024::usri1024_country_code
DWORD usri1024_country_code
Definition: lmaccess.h:418
SetUserInfo
static NET_API_STATUS SetUserInfo(SAM_HANDLE UserHandle, LPBYTE UserInfo, DWORD Level, PDWORD parm_err)
Definition: user.c:1415
_USER_INFO_1003::usri1003_password
LPWSTR usri1003_password
Definition: lmaccess.h:372
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
_DOMAIN_LOCKOUT_INFORMATION::LockoutThreshold
USHORT LockoutThreshold
Definition: ntsam.h:424
USER_MAXSTORAGE_UNLIMITED
#define USER_MAXSTORAGE_UNLIMITED
Definition: lmaccess.h:111
UF_PASSWD_CANT_CHANGE
#define UF_PASSWD_CANT_CHANGE
Definition: lmaccess.h:28
RtlInitializeSid
NTSYSAPI NTSTATUS NTAPI RtlInitializeSid(IN OUT PSID Sid, IN PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, IN UCHAR SubAuthorityCount)
GetAccountDomainSid
static NTSTATUS GetAccountDomainSid(PRPC_SID *Sid)
Definition: msv1_0.c:25
_USER_INFO_1
Definition: lmaccess.h:202
GetUserDacl
static NET_API_STATUS GetUserDacl(IN SAM_HANDLE UserHandle, OUT PACL *Dacl)
Definition: user.c:285
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
ProtocolStatus
VOID NTAPI ProtocolStatus(NDIS_HANDLE BindingContext, NDIS_STATUS GenerelStatus, PVOID StatusBuffer, UINT StatusBufferSize)
Called by NDIS when the underlying driver has changed state.
Definition: lan.c:461
USER_READ_GENERAL
#define USER_READ_GENERAL
Definition: ntsam.h:126
USER_ALL_FULLNAME
#define USER_ALL_FULLNAME
Definition: ntsam.h:197
FALSE
#define FALSE
Definition: types.h:117
_USER_INFO_2::usri2_password_age
DWORD usri2_password_age
Definition: lmaccess.h:215
UNICODE_NULL
#define UNICODE_NULL
_USER_INFO_20::usri20_full_name
LPWSTR usri20_full_name
Definition: lmaccess.h:330
ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
_USER_INFO_1011
Definition: lmaccess.h:392
_USER_INFO_2::usri2_units_per_week
DWORD usri2_units_per_week
Definition: lmaccess.h:230
_USER_INFO_11::usri11_password_age
DWORD usri11_password_age
Definition: lmaccess.h:313
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
_USER_MODALS_INFO_0::usrmod0_max_passwd_age
DWORD usrmod0_max_passwd_age
Definition: lmaccess.h:434
LONG
long LONG
Definition: pedump.c:60
_USER_INFO_2::usri2_max_storage
DWORD usri2_max_storage
Definition: lmaccess.h:229
NetUserModalsGet
NET_API_STATUS WINAPI NetUserModalsGet(LPCWSTR servername, DWORD level, LPBYTE *bufptr)
Definition: user.c:3659
_LOGON_HOURS::LogonHours
PUCHAR LogonHours
Definition: ntsam.h:475
_USER_INFO_4::usri4_last_logon
DWORD usri4_last_logon
Definition: lmaccess.h:283
USER_INFO_1
struct _USER_INFO_1 USER_INFO_1
_USER_INFO_3::usri3_primary_group_id
DWORD usri3_primary_group_id
Definition: lmaccess.h:264
SamCreateUser2InDomain
NTSTATUS NTAPI SamCreateUser2InDomain(IN SAM_HANDLE DomainHandle, IN PUNICODE_STRING AccountName, IN ULONG AccountType, IN ACCESS_MASK DesiredAccess, OUT PSAM_HANDLE UserHandle, OUT PULONG GrantedAccess, OUT PULONG RelativeId)
Definition: samlib.c:594
PUSER_INFO_1011
struct _USER_INFO_1011 * PUSER_INFO_1011
_USER_INFO_4::usri4_workstations
LPWSTR usri4_workstations
Definition: lmaccess.h:282
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
GetUserPrivileges
static NET_API_STATUS GetUserPrivileges(_In_ SAM_HANDLE BuiltinDomainHandle, _In_ SAM_HANDLE UserHandle, _In_ PSID AccountDomainSid, _In_ ULONG RelativeId, _Out_ PDWORD Priv, _Out_ PDWORD AuthFlags)
Definition: user.c:410
_DOMAIN_NAME_INFORMATION
Definition: ntsam.h:379
_USER_INFO_4::usri4_full_name
LPWSTR usri4_full_name
Definition: lmaccess.h:279
_ANSI_STRING
Definition: env_spec_w32.h:375
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
FIXME
#define FIXME(fmt,...)
Definition: debug.h:111
_USER_INFO_3::usri3_full_name
LPWSTR usri3_full_name
Definition: lmaccess.h:248
SamLookupIdsInDomain
NTSTATUS NTAPI SamLookupIdsInDomain(IN SAM_HANDLE DomainHandle, IN ULONG Count, IN PULONG RelativeIds, OUT PUNICODE_STRING *Names, OUT PSID_NAME_USE *Use OPTIONAL)
Definition: samlib.c:1220
_ENUM_CONTEXT::AccountDomainSid
PSID AccountDomainSid
Definition: user.c:46
PUSER_INFO_20
struct _USER_INFO_20 * PUSER_INFO_20
PUSER_INFO_2
struct _USER_INFO_2 * PUSER_INFO_2
NetUserAdd
NET_API_STATUS WINAPI NetUserAdd(LPCWSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
Definition: user.c:2273
Ace
Definition: card.h:12
SamLookupNamesInDomain
NTSTATUS NTAPI SamLookupNamesInDomain(IN SAM_HANDLE DomainHandle, IN ULONG Count, IN PUNICODE_STRING Names, OUT PULONG *RelativeIds, OUT PSID_NAME_USE *Use)
Definition: samlib.c:1335
_DOMAIN_PASSWORD_INFORMATION::MinPasswordAge
LARGE_INTEGER MinPasswordAge
Definition: ntsam.h:348
AF_OP_PRINT
#define AF_OP_PRINT
Definition: lmaccess.h:45
_USER_INFO_4::usri4_primary_group_id
DWORD usri4_primary_group_id
Definition: lmaccess.h:295
_USER_INFO_4::usri4_password
LPWSTR usri4_password
Definition: lmaccess.h:271
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
_USER_INFO_20::usri20_comment
LPWSTR usri20_comment
Definition: lmaccess.h:331
SID_MAX_SUB_AUTHORITIES
#define SID_MAX_SUB_AUTHORITIES
Definition: setypes.h:454
PUSER_INFO_1052
struct _USER_INFO_1052 * PUSER_INFO_1052
_LARGE_INTEGER::HighPart
LONG HighPart
Definition: typedefs.h:107
USER_INFO_3
struct _USER_INFO_3 USER_INFO_3
_USER_INFO_1009::usri1009_script_path
LPWSTR usri1009_script_path
Definition: lmaccess.h:387
_USER_INFO_1017::usri1017_acct_expires
DWORD usri1017_acct_expires
Definition: lmaccess.h:405
_USER_INFO_22::usri22_home_dir
LPWSTR usri22_home_dir
Definition: lmaccess.h:343
_USER_INFO_3::usri3_flags
DWORD usri3_flags
Definition: lmaccess.h:245
_Out_
#define _Out_
Definition: no_sal2.h:160
SAM_SERVER_LOOKUP_DOMAIN
#define SAM_SERVER_LOOKUP_DOMAIN
Definition: ntsam.h:104
_ENUM_CONTEXT::EnumerationContext
SAM_ENUMERATE_HANDLE EnumerationContext
Definition: local_group.c:39
ChangeUserDacl
static VOID ChangeUserDacl(IN PACL Dacl, IN ULONG Flags)
Definition: user.c:263
PUSER_INFO_1053
struct _USER_INFO_1053 * PUSER_INFO_1053
LG_INCLUDE_INDIRECT
#define LG_INCLUDE_INDIRECT
Definition: lmaccess.h:44
Buffer
Definition: bufpool.h:45
RtlLengthSid
NTSYSAPI ULONG NTAPI RtlLengthSid(IN PSID Sid)
Definition: sid.c:150
_DOMAIN_PASSWORD_INFORMATION::PasswordHistoryLength
USHORT PasswordHistoryLength
Definition: ntsam.h:345
_USER_INFO_20::usri20_name
LPWSTR usri20_name
Definition: lmaccess.h:329
UAS_ROLE_BACKUP
#define UAS_ROLE_BACKUP
Definition: lmaccess.h:52
USER_ALL_USERACCOUNTCONTROL
#define USER_ALL_USERACCOUNTCONTROL
Definition: ntsam.h:216
UF_PASSWD_NOTREQD
#define UF_PASSWD_NOTREQD
Definition: lmaccess.h:27
SamSetInformationUser
NTSTATUS NTAPI SamSetInformationUser(IN SAM_HANDLE UserHandle, IN USER_INFORMATION_CLASS UserInformationClass, IN PVOID Buffer)
Definition: samlib.c:1964
_DOMAIN_LOGOFF_INFORMATION
Definition: ntsam.h:369
FreeEnumContext
static VOID FreeEnumContext(PENUM_CONTEXT EnumContext)
Definition: user.c:2692
NetUserGetInfo
NET_API_STATUS WINAPI NetUserGetInfo(LPCWSTR servername, LPCWSTR username, DWORD level, LPBYTE *bufptr)
Definition: user.c:3147
PVOID
void * PVOID
Definition: retypes.h:9
_USER_MODALS_INFO_0
Definition: lmaccess.h:432
PUSER_INFO_1
struct _USER_INFO_1 * PUSER_INFO_1
USER_LIST_GROUPS
#define USER_LIST_GROUPS
Definition: ntsam.h:134
_DOMAIN_REPLICATION_INFORMATION
Definition: ntsam.h:384
_USER_ALL_INFORMATION::AdminComment
UNICODE_STRING AdminComment
Definition: ntsam.h:670
_ENUM_CONTEXT::EnumHandle
ULONG EnumHandle
Definition: user.c:40
CONTAINING_RECORD
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_USER_INFO_1007::usri1007_comment
LPWSTR usri1007_comment
Definition: lmaccess.h:381
_USER_INFO_3::usri3_last_logoff
DWORD usri3_last_logoff
Definition: lmaccess.h:253
LsaHandle
HANDLE LsaHandle
Definition: wkssvc.c:41
_ACE_HEADER
Definition: ms-dtyp.idl:209
_USER_INFO_3::usri3_auth_flags
DWORD usri3_auth_flags
Definition: lmaccess.h:247
_DOMAIN_NAME_INFORMATION::DomainName
UNICODE_STRING DomainName
Definition: ntsam.h:381
USER_INFO_11
struct _USER_INFO_11 USER_INFO_11
username
static WCHAR username[]
Definition: url.c:32
PUSER_INFO_1051
struct _USER_INFO_1051 * PUSER_INFO_1051
_USER_INFO_2::usri2_country_code
DWORD usri2_country_code
Definition: lmaccess.h:235
_USER_INFO_2::usri2_parms
LPWSTR usri2_parms
Definition: lmaccess.h:224
PUSER_MODALS_INFO_2
struct _USER_MODALS_INFO_2 * PUSER_MODALS_INFO_2
_SAM_RID_ENUMERATION
Definition: ntsam.h:265
_USER_INFO_4::usri4_units_per_week
DWORD usri4_units_per_week
Definition: lmaccess.h:287
g_EnumContextHandle
LONG g_EnumContextHandle
Definition: user.c:58
NET_API_STATUS
DWORD NET_API_STATUS
Definition: ms-dtyp.idl:91
Status
Status
Definition: gdiplustypes.h:24
_USER_INFO_2::usri2_full_name
LPWSTR usri2_full_name
Definition: lmaccess.h:222
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_USER_INFO_11::usri11_num_logons
DWORD usri11_num_logons
Definition: lmaccess.h:319
_USER_INFO_11::usri11_workstations
LPWSTR usri11_workstations
Definition: lmaccess.h:322
_USER_INFO_2::usri2_code_page
DWORD usri2_code_page
Definition: lmaccess.h:236
Count
int Count
Definition: noreturn.cpp:7
NetUserGetLocalGroups
NET_API_STATUS WINAPI NetUserGetLocalGroups(LPCWSTR servername, LPCWSTR username, DWORD level, DWORD flags, LPBYTE *bufptr, DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries)
Definition: user.c:3324
_USER_INFO_3::usri3_name
LPWSTR usri3_name
Definition: lmaccess.h:239
PSID_NAME_USE
enum _SID_NAME_USE * PSID_NAME_USE
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
USER_ALL_PRIMARYGROUPID
#define USER_ALL_PRIMARYGROUPID
Definition: ntsam.h:199
USER_ALL_HOMEDIRECTORY
#define USER_ALL_HOMEDIRECTORY
Definition: ntsam.h:202
SamDeleteUser
NTSTATUS NTAPI SamDeleteUser(IN SAM_HANDLE UserHandle)
Definition: samlib.c:724
_USER_INFO_1020::usri1020_units_per_week
DWORD usri1020_units_per_week
Definition: lmaccess.h:411
_DOMAIN_PASSWORD_INFORMATION::MinPasswordLength
USHORT MinPasswordLength
Definition: ntsam.h:344
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
_USER_INFO_22::usri22_acct_expires
DWORD usri22_acct_expires
Definition: lmaccess.h:354
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:595
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
_USER_INFO_4::usri4_acct_expires
DWORD usri4_acct_expires
Definition: lmaccess.h:285
_USER_INFO_11::usri11_home_dir
LPWSTR usri11_home_dir
Definition: lmaccess.h:314
PUSER_INFO_23
struct _USER_INFO_23 * PUSER_INFO_23
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
_USER_INFO_2::usri2_workstations
LPWSTR usri2_workstations
Definition: lmaccess.h:225
_USER_INFO_1::usri1_comment
LPWSTR usri1_comment
Definition: lmaccess.h:208
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PENUM_CONTEXT
struct _ENUM_CONTEXT * PENUM_CONTEXT
USER_READ_ACCOUNT
#define USER_READ_ACCOUNT
Definition: ntsam.h:130
PUSER_INFO_1008
struct _USER_INFO_1008 * PUSER_INFO_1008
SECURITY_WORLD_SID_AUTHORITY
#define SECURITY_WORLD_SID_AUTHORITY
Definition: setypes.h:499
NetUserModalsSet
NET_API_STATUS WINAPI NetUserModalsSet(IN LPCWSTR servername, IN DWORD level, IN LPBYTE buf, OUT LPDWORD parm_err)
Definition: user.c:3943
_USER_INFO_11::usri11_max_storage
DWORD usri11_max_storage
Definition: lmaccess.h:323
_USER_INFO_4::usri4_code_page
DWORD usri4_code_page
Definition: lmaccess.h:293
_USER_INFO_3::usri3_logon_server
LPWSTR usri3_logon_server
Definition: lmaccess.h:260
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:179
USER_MODALS_INFO_2
struct _USER_MODALS_INFO_2 USER_MODALS_INFO_2
PUSER_INFO_22
struct _USER_INFO_22 * PUSER_INFO_22
_ENUM_CONTEXT::AccountDomainHandle
SAM_HANDLE AccountDomainHandle
Definition: local_group.c:37
UAS_ROLE_PRIMARY
#define UAS_ROLE_PRIMARY
Definition: lmaccess.h:53
_USER_INFO_22
Definition: lmaccess.h:338
PUSER_INFO_1025
struct _USER_INFO_1025 * PUSER_INFO_1025
_USER_INFO_2::usri2_script_path
LPWSTR usri2_script_path
Definition: lmaccess.h:220
_ENUM_CONTEXT::BuiltinDomainSid
PSID BuiltinDomainSid
Definition: user.c:45
_DOMAIN_PASSWORD_INFORMATION::MaxPasswordAge
LARGE_INTEGER MaxPasswordAge
Definition: ntsam.h:347
_USER_INFO_2
Definition: lmaccess.h:212
DOMAIN_READ_PASSWORD_PARAMETERS
#define DOMAIN_READ_PASSWORD_PARAMETERS
Definition: ntsam.h:33
UF_SERVER_TRUST_ACCOUNT
#define UF_SERVER_TRUST_ACCOUNT
Definition: lmaccess.h:33
WINAPI
#define WINAPI
Definition: msvc.h:6
PUSER_INFO_1017
struct _USER_INFO_1017 * PUSER_INFO_1017
_USER_ALL_INFORMATION::HomeDirectory
UNICODE_STRING HomeDirectory
Definition: ntsam.h:666
FreeUserInfo
static VOID FreeUserInfo(PUSER_ALL_INFORMATION UserInfo)
Definition: user.c:366
_USER_INFO_11::usri11_comment
LPWSTR usri11_comment
Definition: lmaccess.h:308
_USER_INFO_1052
Definition: lmaccess.h:426
CopyMemory
#define CopyMemory
Definition: winbase.h:1662
DOMAIN_ALIAS_RID_SYSTEM_OPS
#define DOMAIN_ALIAS_RID_SYSTEM_OPS
Definition: setypes.h:630
AllocateEnumContext
static NET_API_STATUS AllocateEnumContext(PENUM_CONTEXT *AllocatedEnumContext)
Definition: user.c:2656
NetUserSetGroups
NET_API_STATUS WINAPI NetUserSetGroups(LPCWSTR servername, LPCWSTR username, DWORD level, LPBYTE buf, DWORD num_entries)
Definition: user.c:3958
_USER_INFO_20::usri20_flags
DWORD usri20_flags
Definition: lmaccess.h:332
_USER_INFO_4::usri4_profile
LPWSTR usri4_profile
Definition: lmaccess.h:296
_USER_INFO_1014
Definition: lmaccess.h:401
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
ACCESS_ALLOWED_ACE_TYPE
#define ACCESS_ALLOWED_ACE_TYPE
Definition: setypes.h:685
WRITE_DAC
#define WRITE_DAC
Definition: nt_native.h:59
USER_ALL_ACCESS
#define USER_ALL_ACCESS
Definition: ntsam.h:153
USER_NORMAL_ACCOUNT
#define USER_NORMAL_ACCOUNT
Definition: ntsam.h:171
_USER_INFO_11::usri11_name
LPWSTR usri11_name
Definition: lmaccess.h:307
_USER_INFO_4::usri4_max_storage
DWORD usri4_max_storage
Definition: lmaccess.h:286
NetUserGetGroups
NET_API_STATUS WINAPI NetUserGetGroups(LPCWSTR servername, LPCWSTR username, DWORD level, LPBYTE *bufptr, DWORD prefixmaxlen, LPDWORD entriesread, LPDWORD totalentries)
Definition: user.c:2982
DOMAIN_CREATE_USER
#define DOMAIN_CREATE_USER
Definition: ntsam.h:37
USER_ALL_ADMINCOMMENT
#define USER_ALL_ADMINCOMMENT
Definition: ntsam.h:200
_USER_INFO_4::usri4_password_age
DWORD usri4_password_age
Definition: lmaccess.h:272
_USER_INFO_1::usri1_name
LPWSTR usri1_name
Definition: lmaccess.h:203
_USER_INFO_2::usri2_home_dir
LPWSTR usri2_home_dir
Definition: lmaccess.h:217
_USER_INFO_11::usri11_parms
LPWSTR usri11_parms
Definition: lmaccess.h:315
_USER_MODALS_INFO_0::usrmod0_password_hist_len
DWORD usrmod0_password_hist_len
Definition: lmaccess.h:437