[NETAPI32]
[reactos.git] / reactos / dll / win32 / netapi32 / user.c
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 #include "netapi32.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
24
25
26 typedef struct _ENUM_CONTEXT
27 {
28 SAM_HANDLE ServerHandle;
29 SAM_HANDLE BuiltinDomainHandle;
30 SAM_HANDLE AccountDomainHandle;
31
32 SAM_ENUMERATE_HANDLE EnumerationContext;
33 PSAM_RID_ENUMERATION Buffer;
34 ULONG Returned;
35 ULONG Index;
36 BOOLEAN BuiltinDone;
37
38 } ENUM_CONTEXT, *PENUM_CONTEXT;
39
40
41 /* NOTE: So far, this is implemented to support tests that require user logins,
42 * but not designed to handle real user databases. Those should probably
43 * be synced with either the host's user database or with Samba.
44 *
45 * FIXME: The user database should hold all the information the USER_INFO_4 struct
46 * needs, but for the first try, I will just implement the USER_INFO_1 fields.
47 */
48
49 struct sam_user
50 {
51 struct list entry;
52 WCHAR user_name[LM20_UNLEN+1];
53 WCHAR user_password[PWLEN + 1];
54 DWORD sec_since_passwd_change;
55 DWORD user_priv;
56 LPWSTR home_dir;
57 LPWSTR user_comment;
58 DWORD user_flags;
59 LPWSTR user_logon_script_path;
60 };
61
62 static struct list user_list = LIST_INIT( user_list );
63
64 BOOL NETAPI_IsLocalComputer(LPCWSTR ServerName);
65
66 /************************************************************
67 * NETAPI_ValidateServername
68 *
69 * Validates server name
70 */
71 static NET_API_STATUS NETAPI_ValidateServername(LPCWSTR ServerName)
72 {
73 if (ServerName)
74 {
75 if (ServerName[0] == 0)
76 return ERROR_BAD_NETPATH;
77 else if (
78 ((ServerName[0] == '\\') &&
79 (ServerName[1] != '\\'))
80 ||
81 ((ServerName[0] == '\\') &&
82 (ServerName[1] == '\\') &&
83 (ServerName[2] == 0))
84 )
85 return ERROR_INVALID_NAME;
86 }
87 return NERR_Success;
88 }
89
90 /************************************************************
91 * NETAPI_FindUser
92 *
93 * Looks for a user in the user database.
94 * Returns a pointer to the entry in the user list when the user
95 * is found, NULL otherwise.
96 */
97 static struct sam_user* NETAPI_FindUser(LPCWSTR UserName)
98 {
99 struct sam_user *user;
100
101 LIST_FOR_EACH_ENTRY(user, &user_list, struct sam_user, entry)
102 {
103 if(lstrcmpW(user->user_name, UserName) == 0)
104 return user;
105 }
106 return NULL;
107 }
108
109
110 static
111 NET_API_STATUS
112 BuildUserInfoBuffer(PUSER_ACCOUNT_INFORMATION UserInfo,
113 DWORD level,
114 ULONG RelativeId,
115 LPVOID *Buffer)
116 {
117 LPVOID LocalBuffer = NULL;
118 PUSER_INFO_0 UserInfo0;
119 PUSER_INFO_1 UserInfo1;
120 PUSER_INFO_10 UserInfo10;
121 PUSER_INFO_20 UserInfo20;
122 LPWSTR Ptr;
123 ULONG Size = 0;
124 NET_API_STATUS ApiStatus = NERR_Success;
125
126 *Buffer = NULL;
127
128 switch (level)
129 {
130 case 0:
131 Size = sizeof(USER_INFO_0) +
132 UserInfo->UserName.Length + sizeof(WCHAR);
133 break;
134
135 case 1:
136 Size = sizeof(USER_INFO_1) +
137 UserInfo->UserName.Length + sizeof(WCHAR);
138
139 if (UserInfo->HomeDirectory.Length > 0)
140 Size += UserInfo->HomeDirectory.Length + sizeof(WCHAR);
141
142 if (UserInfo->AdminComment.Length > 0)
143 Size += UserInfo->AdminComment.Length + sizeof(WCHAR);
144
145 if (UserInfo->ScriptPath.Length > 0)
146 Size = UserInfo->ScriptPath.Length + sizeof(WCHAR);
147 break;
148
149 // case 2:
150 // case 3:
151 // case 4:
152
153 case 10:
154 Size = sizeof(USER_INFO_10) +
155 UserInfo->UserName.Length + sizeof(WCHAR);
156
157 if (UserInfo->AdminComment.Length > 0)
158 Size += UserInfo->AdminComment.Length + sizeof(WCHAR);
159
160 /* FIXME: usri10_usr_comment */
161
162 if (UserInfo->FullName.Length > 0)
163 Size += UserInfo->FullName.Length + sizeof(WCHAR);
164 break;
165
166 // case 11:
167
168 case 20:
169 Size = sizeof(USER_INFO_20) +
170 UserInfo->UserName.Length + sizeof(WCHAR);
171
172 if (UserInfo->FullName.Length > 0)
173 Size += UserInfo->FullName.Length + sizeof(WCHAR);
174
175 if (UserInfo->AdminComment.Length > 0)
176 Size += UserInfo->AdminComment.Length + sizeof(WCHAR);
177 break;
178
179 // case 23:
180
181 default:
182 ApiStatus = ERROR_INVALID_LEVEL;
183 goto done;
184 }
185
186 ApiStatus = NetApiBufferAllocate(Size, &LocalBuffer);
187 if (ApiStatus != NERR_Success)
188 goto done;
189
190 ZeroMemory(LocalBuffer, Size);
191
192 switch (level)
193 {
194 case 0:
195 UserInfo0 = (PUSER_INFO_0)LocalBuffer;
196
197 Ptr = (LPWSTR)((ULONG_PTR)UserInfo0 + sizeof(USER_INFO_0));
198 UserInfo0->usri0_name = Ptr;
199
200 memcpy(UserInfo0->usri0_name,
201 UserInfo->UserName.Buffer,
202 UserInfo->UserName.Length);
203 UserInfo0->usri0_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
204 break;
205
206 case 1:
207 UserInfo1 = (PUSER_INFO_1)LocalBuffer;
208
209 Ptr = (LPWSTR)((ULONG_PTR)UserInfo1 + sizeof(USER_INFO_1));
210
211 UserInfo1->usri1_name = Ptr;
212
213 memcpy(UserInfo1->usri1_name,
214 UserInfo->UserName.Buffer,
215 UserInfo->UserName.Length);
216 UserInfo1->usri1_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
217
218 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
219
220 UserInfo1->usri1_password = NULL;
221
222 /* FIXME: UserInfo1->usri1_password_age */
223 /* FIXME: UserInfo1->usri1_priv */
224
225 if (UserInfo->HomeDirectory.Length > 0)
226 {
227 UserInfo1->usri1_home_dir = Ptr;
228
229 memcpy(UserInfo1->usri1_home_dir,
230 UserInfo->HomeDirectory.Buffer,
231 UserInfo->HomeDirectory.Length);
232 UserInfo1->usri1_home_dir[UserInfo->HomeDirectory.Length / sizeof(WCHAR)] = UNICODE_NULL;
233
234 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->HomeDirectory.Length + sizeof(WCHAR));
235 }
236
237 if (UserInfo->AdminComment.Length > 0)
238 {
239 UserInfo1->usri1_comment = Ptr;
240
241 memcpy(UserInfo1->usri1_comment,
242 UserInfo->AdminComment.Buffer,
243 UserInfo->AdminComment.Length);
244 UserInfo1->usri1_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
245
246 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
247 }
248
249 UserInfo1->usri1_flags = UserInfo->UserAccountControl;
250
251 if (UserInfo->ScriptPath.Length > 0)
252 {
253 UserInfo1->usri1_script_path = Ptr;
254
255 memcpy(UserInfo1->usri1_script_path,
256 UserInfo->ScriptPath.Buffer,
257 UserInfo->ScriptPath.Length);
258 UserInfo1->usri1_script_path[UserInfo->ScriptPath.Length / sizeof(WCHAR)] = UNICODE_NULL;
259 }
260 break;
261
262 // case 2:
263 // case 3:
264 // case 4:
265
266 case 10:
267 UserInfo10 = (PUSER_INFO_10)LocalBuffer;
268
269 Ptr = (LPWSTR)((ULONG_PTR)UserInfo10 + sizeof(USER_INFO_10));
270
271 UserInfo10->usri10_name = Ptr;
272
273 memcpy(UserInfo10->usri10_name,
274 UserInfo->UserName.Buffer,
275 UserInfo->UserName.Length);
276 UserInfo10->usri10_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
277
278 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
279
280 if (UserInfo->AdminComment.Length > 0)
281 {
282 UserInfo10->usri10_comment = Ptr;
283
284 memcpy(UserInfo10->usri10_comment,
285 UserInfo->AdminComment.Buffer,
286 UserInfo->AdminComment.Length);
287 UserInfo10->usri10_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
288
289 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
290 }
291
292 /* FIXME: UserInfo10->usri10_usr_comment */
293
294 if (UserInfo->FullName.Length > 0)
295 {
296 UserInfo10->usri10_full_name = Ptr;
297
298 memcpy(UserInfo10->usri10_full_name,
299 UserInfo->FullName.Buffer,
300 UserInfo->FullName.Length);
301 UserInfo10->usri10_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
302 }
303 break;
304
305 // case 11:
306
307 case 20:
308 UserInfo20 = (PUSER_INFO_20)LocalBuffer;
309
310 Ptr = (LPWSTR)((ULONG_PTR)UserInfo20 + sizeof(USER_INFO_20));
311
312 UserInfo20->usri20_name = Ptr;
313
314 memcpy(UserInfo20->usri20_name,
315 UserInfo->UserName.Buffer,
316 UserInfo->UserName.Length);
317 UserInfo20->usri20_name[UserInfo->UserName.Length / sizeof(WCHAR)] = UNICODE_NULL;
318
319 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->UserName.Length + sizeof(WCHAR));
320
321 if (UserInfo->FullName.Length > 0)
322 {
323 UserInfo20->usri20_full_name = Ptr;
324
325 memcpy(UserInfo20->usri20_full_name,
326 UserInfo->FullName.Buffer,
327 UserInfo->FullName.Length);
328 UserInfo20->usri20_full_name[UserInfo->FullName.Length / sizeof(WCHAR)] = UNICODE_NULL;
329
330 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->FullName.Length + sizeof(WCHAR));
331 }
332
333 if (UserInfo->AdminComment.Length > 0)
334 {
335 UserInfo20->usri20_comment = Ptr;
336
337 memcpy(UserInfo20->usri20_comment,
338 UserInfo->AdminComment.Buffer,
339 UserInfo->AdminComment.Length);
340 UserInfo20->usri20_comment[UserInfo->AdminComment.Length / sizeof(WCHAR)] = UNICODE_NULL;
341
342 Ptr = (LPWSTR)((ULONG_PTR)Ptr + UserInfo->AdminComment.Length + sizeof(WCHAR));
343 }
344
345 UserInfo20->usri20_flags = UserInfo->UserAccountControl;
346 UserInfo20->usri20_user_id = RelativeId;
347 break;
348
349 // case 23:
350 }
351
352 done:
353 if (ApiStatus == NERR_Success)
354 {
355 *Buffer = LocalBuffer;
356 }
357 else
358 {
359 if (LocalBuffer != NULL)
360 NetApiBufferFree(LocalBuffer);
361 }
362
363 return ApiStatus;
364 }
365
366
367 static
368 VOID
369 FreeUserInfo(PUSER_ACCOUNT_INFORMATION UserInfo)
370 {
371 if (UserInfo->UserName.Buffer != NULL)
372 SamFreeMemory(UserInfo->UserName.Buffer);
373
374 if (UserInfo->FullName.Buffer != NULL)
375 SamFreeMemory(UserInfo->FullName.Buffer);
376
377 if (UserInfo->HomeDirectory.Buffer != NULL)
378 SamFreeMemory(UserInfo->HomeDirectory.Buffer);
379
380 if (UserInfo->HomeDirectoryDrive.Buffer != NULL)
381 SamFreeMemory(UserInfo->HomeDirectoryDrive.Buffer);
382
383 if (UserInfo->ScriptPath.Buffer != NULL)
384 SamFreeMemory(UserInfo->ScriptPath.Buffer);
385
386 if (UserInfo->ProfilePath.Buffer != NULL)
387 SamFreeMemory(UserInfo->ProfilePath.Buffer);
388
389 if (UserInfo->AdminComment.Buffer != NULL)
390 SamFreeMemory(UserInfo->AdminComment.Buffer);
391
392 if (UserInfo->WorkStations.Buffer != NULL)
393 SamFreeMemory(UserInfo->WorkStations.Buffer);
394
395 if (UserInfo->LogonHours.LogonHours != NULL)
396 SamFreeMemory(UserInfo->LogonHours.LogonHours);
397
398 SamFreeMemory(UserInfo);
399 }
400
401
402 /************************************************************
403 * NetUserAdd (NETAPI32.@)
404 */
405 NET_API_STATUS
406 WINAPI
407 NetUserAdd(LPCWSTR servername,
408 DWORD level,
409 LPBYTE bufptr,
410 LPDWORD parm_err)
411 {
412 NET_API_STATUS status;
413 struct sam_user * su = NULL;
414
415 FIXME("(%s, %d, %p, %p) stub!\n", debugstr_w(servername), level, bufptr, parm_err);
416
417 if((status = NETAPI_ValidateServername(servername)) != NERR_Success)
418 return status;
419
420 switch(level)
421 {
422 /* Level 3 and 4 are identical for the purposes of NetUserAdd */
423 case 4:
424 case 3:
425 FIXME("Level 3 and 4 not implemented.\n");
426 /* Fall through */
427 case 2:
428 FIXME("Level 2 not implemented.\n");
429 /* Fall through */
430 case 1:
431 {
432 PUSER_INFO_1 ui = (PUSER_INFO_1) bufptr;
433 su = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sam_user));
434 if(!su)
435 {
436 status = NERR_InternalError;
437 break;
438 }
439
440 if(lstrlenW(ui->usri1_name) > LM20_UNLEN)
441 {
442 status = NERR_BadUsername;
443 break;
444 }
445
446 /*FIXME: do other checks for a valid username */
447 lstrcpyW(su->user_name, ui->usri1_name);
448
449 if(lstrlenW(ui->usri1_password) > PWLEN)
450 {
451 /* Always return PasswordTooShort on invalid passwords. */
452 status = NERR_PasswordTooShort;
453 break;
454 }
455 lstrcpyW(su->user_password, ui->usri1_password);
456
457 su->sec_since_passwd_change = ui->usri1_password_age;
458 su->user_priv = ui->usri1_priv;
459 su->user_flags = ui->usri1_flags;
460
461 /*FIXME: set the other LPWSTRs to NULL for now */
462 su->home_dir = NULL;
463 su->user_comment = NULL;
464 su->user_logon_script_path = NULL;
465
466 list_add_head(&user_list, &su->entry);
467 return NERR_Success;
468 }
469 default:
470 TRACE("Invalid level %d specified.\n", level);
471 status = ERROR_INVALID_LEVEL;
472 break;
473 }
474
475 HeapFree(GetProcessHeap(), 0, su);
476
477 return status;
478 }
479
480
481 /******************************************************************************
482 * NetUserChangePassword (NETAPI32.@)
483 * PARAMS
484 * domainname [I] Optional. Domain on which the user resides or the logon
485 * domain of the current user if NULL.
486 * username [I] Optional. Username to change the password for or the name
487 * of the current user if NULL.
488 * oldpassword [I] The user's current password.
489 * newpassword [I] The password that the user will be changed to using.
490 *
491 * RETURNS
492 * Success: NERR_Success.
493 * Failure: NERR_* failure code or win error code.
494 *
495 */
496 NET_API_STATUS
497 WINAPI
498 NetUserChangePassword(LPCWSTR domainname,
499 LPCWSTR username,
500 LPCWSTR oldpassword,
501 LPCWSTR newpassword)
502 {
503 struct sam_user *user;
504
505 TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
506
507 if(domainname)
508 FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
509
510 if((user = NETAPI_FindUser(username)) == NULL)
511 return NERR_UserNotFound;
512
513 if(lstrcmpW(user->user_password, oldpassword) != 0)
514 return ERROR_INVALID_PASSWORD;
515
516 if(lstrlenW(newpassword) > PWLEN)
517 return ERROR_PASSWORD_RESTRICTION;
518
519 lstrcpyW(user->user_password, newpassword);
520
521 return NERR_Success;
522 }
523
524
525 /************************************************************
526 * NetUserDel (NETAPI32.@)
527 */
528 NET_API_STATUS
529 WINAPI
530 NetUserDel(LPCWSTR servername,
531 LPCWSTR username)
532 {
533 NET_API_STATUS status;
534 struct sam_user *user;
535
536 TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
537
538 if((status = NETAPI_ValidateServername(servername))!= NERR_Success)
539 return status;
540
541 if ((user = NETAPI_FindUser(username)) == NULL)
542 return NERR_UserNotFound;
543
544 list_remove(&user->entry);
545
546 HeapFree(GetProcessHeap(), 0, user->home_dir);
547 HeapFree(GetProcessHeap(), 0, user->user_comment);
548 HeapFree(GetProcessHeap(), 0, user->user_logon_script_path);
549 HeapFree(GetProcessHeap(), 0, user);
550
551 return NERR_Success;
552 }
553
554
555 /************************************************************
556 * NetUserEnum (NETAPI32.@)
557 */
558 NET_API_STATUS
559 WINAPI
560 NetUserEnum(LPCWSTR servername,
561 DWORD level,
562 DWORD filter,
563 LPBYTE* bufptr,
564 DWORD prefmaxlen,
565 LPDWORD entriesread,
566 LPDWORD totalentries,
567 LPDWORD resume_handle)
568 {
569 UNICODE_STRING ServerName;
570 PSAM_RID_ENUMERATION CurrentUser;
571 PENUM_CONTEXT EnumContext = NULL;
572 LPVOID Buffer = NULL;
573 ULONG i;
574 SAM_HANDLE UserHandle = NULL;
575 PUSER_ACCOUNT_INFORMATION UserInfo = NULL;
576
577 NET_API_STATUS ApiStatus = NERR_Success;
578 NTSTATUS Status = STATUS_SUCCESS;
579
580 FIXME("(%s %d 0x%d %p %d %p %p %p) stub!\n", debugstr_w(servername), level,
581 filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
582
583 *entriesread = 0;
584 *totalentries = 0;
585 *bufptr = NULL;
586
587 if (servername != NULL)
588 RtlInitUnicodeString(&ServerName, servername);
589
590 if (resume_handle != NULL && *resume_handle != 0)
591 {
592 EnumContext = (PENUM_CONTEXT)*resume_handle;
593 }
594 else
595 {
596 ApiStatus = NetApiBufferAllocate(sizeof(ENUM_CONTEXT), (PVOID*)&EnumContext);
597 if (ApiStatus != NERR_Success)
598 goto done;
599
600 EnumContext->EnumerationContext = 0;
601 EnumContext->Buffer = NULL;
602 EnumContext->Returned = 0;
603 EnumContext->Index = 0;
604 EnumContext->BuiltinDone = FALSE;
605
606 Status = SamConnect((servername != NULL) ? &ServerName : NULL,
607 &EnumContext->ServerHandle,
608 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
609 NULL);
610 if (!NT_SUCCESS(Status))
611 {
612 ERR("SamConnect failed (Status %08lx)\n", Status);
613 ApiStatus = NetpNtStatusToApiStatus(Status);
614 goto done;
615 }
616
617 Status = OpenAccountDomain(EnumContext->ServerHandle,
618 (servername != NULL) ? &ServerName : NULL,
619 DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP,
620 &EnumContext->AccountDomainHandle);
621 if (!NT_SUCCESS(Status))
622 {
623 ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
624 ApiStatus = NetpNtStatusToApiStatus(Status);
625 goto done;
626 }
627
628 Status = OpenBuiltinDomain(EnumContext->ServerHandle,
629 DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP,
630 &EnumContext->BuiltinDomainHandle);
631 if (!NT_SUCCESS(Status))
632 {
633 ERR("OpenBuiltinDomain failed (Status %08lx)\n", Status);
634 ApiStatus = NetpNtStatusToApiStatus(Status);
635 goto done;
636 }
637 }
638
639 // while (TRUE)
640 // {
641 TRACE("EnumContext->Index: %lu\n", EnumContext->Index);
642 TRACE("EnumContext->Returned: %lu\n", EnumContext->Returned);
643
644 if (EnumContext->Index >= EnumContext->Returned)
645 {
646 // if (EnumContext->BuiltinDone == TRUE)
647 // {
648 // ApiStatus = NERR_Success;
649 // goto done;
650 // }
651
652 TRACE("Calling SamEnumerateUsersInDomain\n");
653 Status = SamEnumerateUsersInDomain(EnumContext->AccountDomainHandle, //BuiltinDomainHandle,
654 &EnumContext->EnumerationContext,
655 0,
656 (PVOID *)&EnumContext->Buffer,
657 prefmaxlen,
658 &EnumContext->Returned);
659
660 TRACE("SamEnumerateUsersInDomain returned (Status %08lx)\n", Status);
661 if (!NT_SUCCESS(Status))
662 {
663 ERR("SamEnumerateUsersInDomain failed (Status %08lx)\n", Status);
664 ApiStatus = NetpNtStatusToApiStatus(Status);
665 goto done;
666 }
667
668 if (Status == STATUS_MORE_ENTRIES)
669 {
670 ApiStatus = NERR_BufTooSmall;
671 goto done;
672 }
673 else
674 {
675 EnumContext->BuiltinDone = TRUE;
676 }
677 }
678
679 TRACE("EnumContext: %lu\n", EnumContext);
680 TRACE("EnumContext->Returned: %lu\n", EnumContext->Returned);
681 TRACE("EnumContext->Buffer: %p\n", EnumContext->Buffer);
682
683 /* Get a pointer to the current user */
684 CurrentUser = &EnumContext->Buffer[EnumContext->Index];
685
686 TRACE("RID: %lu\n", CurrentUser->RelativeId);
687
688 Status = SamOpenUser(EnumContext->AccountDomainHandle, //BuiltinDomainHandle,
689 USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT,
690 CurrentUser->RelativeId,
691 &UserHandle);
692 if (!NT_SUCCESS(Status))
693 {
694 ERR("SamOpenUser failed (Status %08lx)\n", Status);
695 ApiStatus = NetpNtStatusToApiStatus(Status);
696 goto done;
697 }
698
699 Status = SamQueryInformationUser(UserHandle,
700 UserAccountInformation,
701 (PVOID *)&UserInfo);
702 if (!NT_SUCCESS(Status))
703 {
704 ERR("SamQueryInformationUser failed (Status %08lx)\n", Status);
705 ApiStatus = NetpNtStatusToApiStatus(Status);
706 goto done;
707 }
708
709 SamCloseHandle(UserHandle);
710 UserHandle = NULL;
711
712 ApiStatus = BuildUserInfoBuffer(UserInfo,
713 level,
714 CurrentUser->RelativeId,
715 &Buffer);
716 if (ApiStatus != NERR_Success)
717 {
718 ERR("BuildUserInfoBuffer failed (ApiStatus %lu)\n", ApiStatus);
719 goto done;
720 }
721
722 if (UserInfo != NULL)
723 {
724 FreeUserInfo(UserInfo);
725 UserInfo = NULL;
726 }
727
728 EnumContext->Index++;
729
730 (*entriesread)++;
731 // }
732
733 done:
734 if (ApiStatus == NERR_Success && EnumContext->Index < EnumContext->Returned)
735 ApiStatus = ERROR_MORE_DATA;
736
737 if (EnumContext != NULL)
738 *totalentries = EnumContext->Returned;
739
740 if (resume_handle == NULL || ApiStatus != ERROR_MORE_DATA)
741 {
742 if (EnumContext != NULL)
743 {
744 if (EnumContext->BuiltinDomainHandle != NULL)
745 SamCloseHandle(EnumContext->BuiltinDomainHandle);
746
747 if (EnumContext->AccountDomainHandle != NULL)
748 SamCloseHandle(EnumContext->AccountDomainHandle);
749
750 if (EnumContext->ServerHandle != NULL)
751 SamCloseHandle(EnumContext->ServerHandle);
752
753 if (EnumContext->Buffer != NULL)
754 {
755 for (i = 0; i < EnumContext->Returned; i++)
756 {
757 SamFreeMemory(EnumContext->Buffer[i].Name.Buffer);
758 }
759
760 SamFreeMemory(EnumContext->Buffer);
761 }
762
763 NetApiBufferFree(EnumContext);
764 EnumContext = NULL;
765 }
766 }
767
768 if (UserHandle != NULL)
769 SamCloseHandle(UserHandle);
770
771 if (UserInfo != NULL)
772 FreeUserInfo(UserInfo);
773
774 if (resume_handle != NULL)
775 *resume_handle = (DWORD_PTR)EnumContext;
776
777 *bufptr = (LPBYTE)Buffer;
778
779 TRACE("return %lu\n", ApiStatus);
780
781 return ApiStatus;
782 }
783
784
785 /************************************************************
786 * NetUserGetGroups (NETAPI32.@)
787 */
788 NET_API_STATUS
789 WINAPI
790 NetUserGetGroups(LPCWSTR servername,
791 LPCWSTR username,
792 DWORD level,
793 LPBYTE *bufptr,
794 DWORD prefixmaxlen,
795 LPDWORD entriesread,
796 LPDWORD totalentries)
797 {
798 FIXME("%s %s %d %p %d %p %p stub\n", debugstr_w(servername),
799 debugstr_w(username), level, bufptr, prefixmaxlen, entriesread,
800 totalentries);
801
802 *bufptr = NULL;
803 *entriesread = 0;
804 *totalentries = 0;
805
806 return ERROR_INVALID_LEVEL;
807 }
808
809
810 /************************************************************
811 * NetUserGetInfo (NETAPI32.@)
812 */
813 NET_API_STATUS
814 WINAPI
815 NetUserGetInfo(LPCWSTR servername,
816 LPCWSTR username,
817 DWORD level,
818 LPBYTE* bufptr)
819 {
820 UNICODE_STRING ServerName;
821 UNICODE_STRING UserName;
822 SAM_HANDLE ServerHandle = NULL;
823 SAM_HANDLE AccountDomainHandle = NULL;
824 SAM_HANDLE UserHandle = NULL;
825 PULONG RelativeIds = NULL;
826 PSID_NAME_USE Use = NULL;
827 PUSER_ACCOUNT_INFORMATION UserInfo = NULL;
828 LPVOID Buffer = NULL;
829 NET_API_STATUS ApiStatus = NERR_Success;
830 NTSTATUS Status = STATUS_SUCCESS;
831
832 TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername),
833 debugstr_w(username), level, bufptr);
834
835 if (servername != NULL)
836 RtlInitUnicodeString(&ServerName, servername);
837
838 RtlInitUnicodeString(&UserName, username);
839
840 /* Connect to the SAM Server */
841 Status = SamConnect((servername != NULL) ? &ServerName : NULL,
842 &ServerHandle,
843 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN,
844 NULL);
845 if (!NT_SUCCESS(Status))
846 {
847 ERR("SamConnect failed (Status %08lx)\n", Status);
848 ApiStatus = NetpNtStatusToApiStatus(Status);
849 goto done;
850 }
851
852 /* Open the Account Domain */
853 Status = OpenAccountDomain(ServerHandle,
854 (servername != NULL) ? &ServerName : NULL,
855 DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP,
856 &AccountDomainHandle);
857 if (!NT_SUCCESS(Status))
858 {
859 ERR("OpenAccountDomain failed (Status %08lx)\n", Status);
860 ApiStatus = NetpNtStatusToApiStatus(Status);
861 goto done;
862 }
863
864 /* Get the RID for the given user name */
865 Status = SamLookupNamesInDomain(AccountDomainHandle,
866 1,
867 &UserName,
868 &RelativeIds,
869 &Use);
870 if (!NT_SUCCESS(Status))
871 {
872 ERR("SamOpenDomain failed (Status %08lx)\n", Status);
873 ApiStatus = NetpNtStatusToApiStatus(Status);
874 goto done;
875 }
876
877 /* Check if the account is a user account */
878 if (Use[0] != SidTypeUser)
879 {
880 ERR("No user found!\n");
881 ApiStatus = NERR_UserNotFound;
882 goto done;
883 }
884
885 TRACE("RID: %lu\n", RelativeIds[0]);
886
887 /* Open the user object */
888 Status = SamOpenUser(AccountDomainHandle,
889 USER_READ_GENERAL | USER_READ_PREFERENCES | USER_READ_LOGON | USER_READ_ACCOUNT,
890 RelativeIds[0],
891 &UserHandle);
892 if (!NT_SUCCESS(Status))
893 {
894 ERR("SamOpenUser failed (Status %08lx)\n", Status);
895 ApiStatus = NetpNtStatusToApiStatus(Status);
896 goto done;
897 }
898
899 Status = SamQueryInformationUser(UserHandle,
900 UserAccountInformation,
901 (PVOID *)&UserInfo);
902 if (!NT_SUCCESS(Status))
903 {
904 ERR("SamQueryInformationUser failed (Status %08lx)\n", Status);
905 ApiStatus = NetpNtStatusToApiStatus(Status);
906 goto done;
907 }
908
909 ApiStatus = BuildUserInfoBuffer(UserInfo,
910 level,
911 RelativeIds[0],
912 &Buffer);
913 if (ApiStatus != NERR_Success)
914 {
915 ERR("BuildUserInfoBuffer failed (ApiStatus %08lu)\n", ApiStatus);
916 goto done;
917 }
918
919 done:
920 if (UserInfo != NULL)
921 FreeUserInfo(UserInfo);
922
923 if (UserHandle != NULL)
924 SamCloseHandle(UserHandle);
925
926 if (RelativeIds != NULL)
927 SamFreeMemory(RelativeIds);
928
929 if (Use != NULL)
930 SamFreeMemory(Use);
931
932 if (AccountDomainHandle != NULL)
933 SamCloseHandle(AccountDomainHandle);
934
935 if (ServerHandle != NULL)
936 SamCloseHandle(ServerHandle);
937
938 *bufptr = (LPBYTE)Buffer;
939
940 return ApiStatus;
941 }
942
943
944 /************************************************************
945 * NetUserGetLocalGroups (NETAPI32.@)
946 */
947 NET_API_STATUS
948 WINAPI
949 NetUserGetLocalGroups(LPCWSTR servername,
950 LPCWSTR username,
951 DWORD level,
952 DWORD flags,
953 LPBYTE* bufptr,
954 DWORD prefmaxlen,
955 LPDWORD entriesread,
956 LPDWORD totalentries)
957 {
958 NET_API_STATUS status;
959 const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
960 LPWSTR currentuser;
961 LOCALGROUP_USERS_INFO_0* info;
962 DWORD size;
963
964 FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
965 debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
966 prefmaxlen, entriesread, totalentries);
967
968 status = NETAPI_ValidateServername(servername);
969 if (status != NERR_Success)
970 return status;
971
972 size = UNLEN + 1;
973 NetApiBufferAllocate(size * sizeof(WCHAR), (LPVOID*)&currentuser);
974 GetUserNameW(currentuser, &size);
975
976 if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
977 {
978 NetApiBufferFree(currentuser);
979 return NERR_UserNotFound;
980 }
981
982 NetApiBufferFree(currentuser);
983 *totalentries = 1;
984 size = sizeof(*info) + sizeof(admins);
985
986 if(prefmaxlen < size)
987 status = ERROR_MORE_DATA;
988 else
989 status = NetApiBufferAllocate(size, (LPVOID*)&info);
990
991 if(status != NERR_Success)
992 {
993 *bufptr = NULL;
994 *entriesread = 0;
995 return status;
996 }
997
998 info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
999 lstrcpyW(info->lgrui0_name, admins);
1000
1001 *bufptr = (LPBYTE)info;
1002 *entriesread = 1;
1003
1004 return NERR_Success;
1005 }
1006
1007
1008 /******************************************************************************
1009 * NetUserSetGroups (NETAPI32.@)
1010 */
1011 NET_API_STATUS
1012 WINAPI
1013 NetUserSetGroups(LPCWSTR servername,
1014 LPCWSTR username,
1015 DWORD level,
1016 LPBYTE buf,
1017 DWORD num_entries)
1018 {
1019 FIXME("(%s %s %lu %p %lu)\n",
1020 debugstr_w(servername), debugstr_w(username), level, buf, num_entries);
1021 return ERROR_ACCESS_DENIED;
1022 }
1023
1024
1025 /******************************************************************************
1026 * NetUserSetInfo (NETAPI32.@)
1027 */
1028 NET_API_STATUS
1029 WINAPI
1030 NetUserSetInfo(LPCWSTR servername,
1031 LPCWSTR username,
1032 DWORD level,
1033 LPBYTE buf,
1034 LPDWORD parm_err)
1035 {
1036 FIXME("(%s %s %lu %p %p)\n",
1037 debugstr_w(servername), debugstr_w(username), level, buf, parm_err);
1038 return ERROR_ACCESS_DENIED;
1039 }
1040
1041 /* EOF */