?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemenubuilder: silence an err
[wine/multimedia.git] / dlls / netapi32 / access.c
blob09b5b6336c2941fd0c1892434440b2684f46e09a
1 /*
2 * Copyright 2002 Andriy Palamarchuk
3 *
4 * netapi32 access 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 "config.h"
22 #include <stdarg.h>
23 #include <fcntl.h>
24 #include <errno.h>
25 #ifdef HAVE_SYS_WAIT_H
26 #include <sys/wait.h>
27 #endif
28 #ifdef HAVE_UNISTD_H
29 #include <unistd.h>
30 #endif
31
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winerror.h"
37 #include "lmcons.h"
38 #include "lmaccess.h"
39 #include "lmapibuf.h"
40 #include "lmerr.h"
41 #include "lmuse.h"
42 #include "ntsecapi.h"
43 #include "wine/debug.h"
44 #include "wine/unicode.h"
45 #include "wine/list.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
48
49 /* NOTE: So far, this is implemented to support tests that require user logins,
50 * but not designed to handle real user databases. Those should probably
51 * be synced with either the host's user database or with Samba.
52 *
53 * FIXME: The user database should hold all the information the USER_INFO_4 struct
54 * needs, but for the first try, I will just implement the USER_INFO_1 fields.
55 */
56
57 struct sam_user
58 {
59 struct list entry;
60 WCHAR user_name[LM20_UNLEN+1];
61 WCHAR user_password[PWLEN + 1];
62 DWORD sec_since_passwd_change;
63 DWORD user_priv;
64 LPWSTR home_dir;
65 LPWSTR user_comment;
66 DWORD user_flags;
67 LPWSTR user_logon_script_path;
68 };
69
70 static struct list user_list = LIST_INIT( user_list );
71
72 BOOL NETAPI_IsLocalComputer(LPCWSTR ServerName);
73
74 /************************************************************
75 * NETAPI_ValidateServername
76 *
77 * Validates server name
78 */
79 static NET_API_STATUS NETAPI_ValidateServername(LPCWSTR ServerName)
80 {
81 if (ServerName)
82 {
83 if (ServerName[0] == 0)
84 return ERROR_BAD_NETPATH;
85 else if (
86 ((ServerName[0] == '\\') &&
87 (ServerName[1] != '\\'))
88 ||
89 ((ServerName[0] == '\\') &&
90 (ServerName[1] == '\\') &&
91 (ServerName[2] == 0))
92 )
93 return ERROR_INVALID_NAME;
94 }
95 return NERR_Success;
96 }
97
98 /************************************************************
99 * NETAPI_FindUser
100 *
101 * Looks for a user in the user database.
102 * Returns a pointer to the entry in the user list when the user
103 * is found, NULL otherwise.
104 */
105 static struct sam_user* NETAPI_FindUser(LPCWSTR UserName)
106 {
107 struct sam_user *user;
108
109 LIST_FOR_EACH_ENTRY(user, &user_list, struct sam_user, entry)
110 {
111 if(lstrcmpW(user->user_name, UserName) == 0)
112 return user;
113 }
114 return NULL;
115 }
116
117 static BOOL NETAPI_IsCurrentUser(LPCWSTR username)
118 {
119 LPWSTR curr_user = NULL;
120 DWORD dwSize;
121 BOOL ret = FALSE;
122
123 dwSize = LM20_UNLEN+1;
124 curr_user = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
125 if(!curr_user)
126 {
127 ERR("Failed to allocate memory for user name.\n");
128 goto end;
129 }
130 if(!GetUserNameW(curr_user, &dwSize))
131 {
132 ERR("Failed to get current user's user name.\n");
133 goto end;
134 }
135 if (!lstrcmpW(curr_user, username))
136 {
137 ret = TRUE;
138 }
139
140 end:
141 HeapFree(GetProcessHeap(), 0, curr_user);
142 return ret;
143 }
144
145 /************************************************************
146 * NetUserAdd (NETAPI32.@)
147 */
148 NET_API_STATUS WINAPI NetUserAdd(LPCWSTR servername,
149 DWORD level, LPBYTE bufptr, LPDWORD parm_err)
150 {
151 NET_API_STATUS status;
152 struct sam_user * su = NULL;
153
154 FIXME("(%s, %d, %p, %p) stub!\n", debugstr_w(servername), level, bufptr, parm_err);
155
156 if((status = NETAPI_ValidateServername(servername)) != NERR_Success)
157 return status;
158
159 switch(level)
160 {
161 /* Level 3 and 4 are identical for the purposes of NetUserAdd */
162 case 4:
163 case 3:
164 FIXME("Level 3 and 4 not implemented.\n");
165 /* Fall through */
166 case 2:
167 FIXME("Level 2 not implemented.\n");
168 /* Fall through */
169 case 1:
170 {
171 PUSER_INFO_1 ui = (PUSER_INFO_1) bufptr;
172 su = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sam_user));
173 if(!su)
174 {
175 status = NERR_InternalError;
176 break;
177 }
178
179 if(lstrlenW(ui->usri1_name) > LM20_UNLEN)
180 {
181 status = NERR_BadUsername;
182 break;
183 }
184
185 /*FIXME: do other checks for a valid username */
186 lstrcpyW(su->user_name, ui->usri1_name);
187
188 if(lstrlenW(ui->usri1_password) > PWLEN)
189 {
190 /* Always return PasswordTooShort on invalid passwords. */
191 status = NERR_PasswordTooShort;
192 break;
193 }
194 lstrcpyW(su->user_password, ui->usri1_password);
195
196 su->sec_since_passwd_change = ui->usri1_password_age;
197 su->user_priv = ui->usri1_priv;
198 su->user_flags = ui->usri1_flags;
199
200 /*FIXME: set the other LPWSTRs to NULL for now */
201 su->home_dir = NULL;
202 su->user_comment = NULL;
203 su->user_logon_script_path = NULL;
204
205 list_add_head(&user_list, &su->entry);
206 return NERR_Success;
207 }
208 default:
209 TRACE("Invalid level %d specified.\n", level);
210 status = ERROR_INVALID_LEVEL;
211 break;
212 }
213
214 HeapFree(GetProcessHeap(), 0, su);
215
216 return status;
217 }
218
219 /************************************************************
220 * NetUserDel (NETAPI32.@)
221 */
222 NET_API_STATUS WINAPI NetUserDel(LPCWSTR servername, LPCWSTR username)
223 {
224 NET_API_STATUS status;
225 struct sam_user *user;
226
227 TRACE("(%s, %s)\n", debugstr_w(servername), debugstr_w(username));
228
229 if((status = NETAPI_ValidateServername(servername))!= NERR_Success)
230 return status;
231
232 if ((user = NETAPI_FindUser(username)) == NULL)
233 return NERR_UserNotFound;
234
235 list_remove(&user->entry);
236
237 HeapFree(GetProcessHeap(), 0, user->home_dir);
238 HeapFree(GetProcessHeap(), 0, user->user_comment);
239 HeapFree(GetProcessHeap(), 0, user->user_logon_script_path);
240 HeapFree(GetProcessHeap(), 0, user);
241
242 return NERR_Success;
243 }
244
245 /************************************************************
246 * NetUserGetInfo (NETAPI32.@)
247 */
248 NET_API_STATUS WINAPI
249 NetUserGetInfo(LPCWSTR servername, LPCWSTR username, DWORD level,
250 LPBYTE* bufptr)
251 {
252 NET_API_STATUS status;
253 TRACE("(%s, %s, %d, %p)\n", debugstr_w(servername), debugstr_w(username),
254 level, bufptr);
255 status = NETAPI_ValidateServername(servername);
256 if (status != NERR_Success)
257 return status;
258
259 if(!NETAPI_IsLocalComputer(servername))
260 {
261 FIXME("Only implemented for local computer, but remote server"
262 "%s was requested.\n", debugstr_w(servername));
263 return NERR_InvalidComputer;
264 }
265
266 if(!NETAPI_FindUser(username) && !NETAPI_IsCurrentUser(username))
267 {
268 TRACE("User %s is unknown.\n", debugstr_w(username));
269 return NERR_UserNotFound;
270 }
271
272 switch (level)
273 {
274 case 0:
275 {
276 PUSER_INFO_0 ui;
277 int name_sz;
278
279 name_sz = lstrlenW(username) + 1;
280
281 /* set up buffer */
282 NetApiBufferAllocate(sizeof(USER_INFO_0) + name_sz * sizeof(WCHAR),
283 (LPVOID *) bufptr);
284
285 ui = (PUSER_INFO_0) *bufptr;
286 ui->usri0_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_0));
287
288 /* get data */
289 lstrcpyW(ui->usri0_name, username);
290 break;
291 }
292
293 case 10:
294 {
295 PUSER_INFO_10 ui;
296 PUSER_INFO_0 ui0;
297 /* sizes of the field buffers in WCHARS */
298 int name_sz, comment_sz, usr_comment_sz, full_name_sz;
299
300 comment_sz = 1;
301 usr_comment_sz = 1;
302 full_name_sz = 1;
303
304 /* get data */
305 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
306 if (status != NERR_Success)
307 {
308 NetApiBufferFree(ui0);
309 return status;
310 }
311 name_sz = lstrlenW(ui0->usri0_name) + 1;
312
313 /* set up buffer */
314 NetApiBufferAllocate(sizeof(USER_INFO_10) +
315 (name_sz + comment_sz + usr_comment_sz +
316 full_name_sz) * sizeof(WCHAR),
317 (LPVOID *) bufptr);
318 ui = (PUSER_INFO_10) *bufptr;
319 ui->usri10_name = (LPWSTR) (*bufptr + sizeof(USER_INFO_10));
320 ui->usri10_comment = (LPWSTR) (
321 ((PBYTE) ui->usri10_name) + name_sz * sizeof(WCHAR));
322 ui->usri10_usr_comment = (LPWSTR) (
323 ((PBYTE) ui->usri10_comment) + comment_sz * sizeof(WCHAR));
324 ui->usri10_full_name = (LPWSTR) (
325 ((PBYTE) ui->usri10_usr_comment) + usr_comment_sz * sizeof(WCHAR));
326
327 /* set data */
328 lstrcpyW(ui->usri10_name, ui0->usri0_name);
329 NetApiBufferFree(ui0);
330 ui->usri10_comment[0] = 0;
331 ui->usri10_usr_comment[0] = 0;
332 ui->usri10_full_name[0] = 0;
333 break;
334 }
335
336 case 1:
337 {
338 static const WCHAR homedirW[] = {'H','O','M','E',0};
339 PUSER_INFO_1 ui;
340 PUSER_INFO_0 ui0;
341 /* sizes of the field buffers in WCHARS */
342 int name_sz, password_sz, home_dir_sz, comment_sz, script_path_sz;
343
344 password_sz = 1; /* not filled out for security reasons for NetUserGetInfo*/
345 comment_sz = 1;
346 script_path_sz = 1;
347
348 /* get data */
349 status = NetUserGetInfo(servername, username, 0, (LPBYTE *) &ui0);
350 if (status != NERR_Success)
351 {
352 NetApiBufferFree(ui0);
353 return status;
354 }
355 name_sz = lstrlenW(ui0->usri0_name) + 1;
356 home_dir_sz = GetEnvironmentVariableW(homedirW, NULL,0);
357 /* set up buffer */
358 NetApiBufferAllocate(sizeof(USER_INFO_1) +
359 (name_sz + password_sz + home_dir_sz +
360 comment_sz + script_path_sz) * sizeof(WCHAR),
361 (LPVOID *) bufptr);
362
363 ui = (PUSER_INFO_1) *bufptr;
364 ui->usri1_name = (LPWSTR) (ui + 1);
365 ui->usri1_password = ui->usri1_name + name_sz;
366 ui->usri1_home_dir = ui->usri1_password + password_sz;
367 ui->usri1_comment = ui->usri1_home_dir + home_dir_sz;
368 ui->usri1_script_path = ui->usri1_comment + comment_sz;
369 /* set data */
370 lstrcpyW(ui->usri1_name, ui0->usri0_name);
371 NetApiBufferFree(ui0);
372 ui->usri1_password[0] = 0;
373 ui->usri1_password_age = 0;
374 ui->usri1_priv = 0;
375 GetEnvironmentVariableW(homedirW, ui->usri1_home_dir,home_dir_sz);
376 ui->usri1_comment[0] = 0;
377 ui->usri1_flags = 0;
378 ui->usri1_script_path[0] = 0;
379 break;
380 }
381 case 2:
382 case 3:
383 case 4:
384 case 11:
385 case 20:
386 case 23:
387 case 1003:
388 case 1005:
389 case 1006:
390 case 1007:
391 case 1008:
392 case 1009:
393 case 1010:
394 case 1011:
395 case 1012:
396 case 1013:
397 case 1014:
398 case 1017:
399 case 1018:
400 case 1020:
401 case 1023:
402 case 1024:
403 case 1025:
404 case 1051:
405 case 1052:
406 case 1053:
407 {
408 FIXME("Level %d is not implemented\n", level);
409 return NERR_InternalError;
410 }
411 default:
412 TRACE("Invalid level %d is specified\n", level);
413 return ERROR_INVALID_LEVEL;
414 }
415 return NERR_Success;
416 }
417
418 /************************************************************
419 * NetUserGetLocalGroups (NETAPI32.@)
420 */
421 NET_API_STATUS WINAPI
422 NetUserGetLocalGroups(LPCWSTR servername, LPCWSTR username, DWORD level,
423 DWORD flags, LPBYTE* bufptr, DWORD prefmaxlen,
424 LPDWORD entriesread, LPDWORD totalentries)
425 {
426 NET_API_STATUS status;
427 const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
428 LPWSTR currentuser;
429 LOCALGROUP_USERS_INFO_0* info;
430 DWORD size;
431
432 FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
433 debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
434 prefmaxlen, entriesread, totalentries);
435
436 status = NETAPI_ValidateServername(servername);
437 if (status != NERR_Success)
438 return status;
439
440 size = UNLEN + 1;
441 NetApiBufferAllocate(size * sizeof(WCHAR), (LPVOID*)&currentuser);
442 if (!GetUserNameW(currentuser, &size)) {
443 NetApiBufferFree(currentuser);
444 return ERROR_NOT_ENOUGH_MEMORY;
445 }
446
447 if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
448 {
449 NetApiBufferFree(currentuser);
450 return NERR_UserNotFound;
451 }
452
453 NetApiBufferFree(currentuser);
454 *totalentries = 1;
455 size = sizeof(*info) + sizeof(admins);
456
457 if(prefmaxlen < size)
458 status = ERROR_MORE_DATA;
459 else
460 status = NetApiBufferAllocate(size, (LPVOID*)&info);
461
462 if(status != NERR_Success)
463 {
464 *bufptr = NULL;
465 *entriesread = 0;
466 return status;
467 }
468
469 info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
470 lstrcpyW(info->lgrui0_name, admins);
471
472 *bufptr = (LPBYTE)info;
473 *entriesread = 1;
474
475 return NERR_Success;
476 }
477
478 /************************************************************
479 * NetUserEnum (NETAPI32.@)
480 */
481 NET_API_STATUS WINAPI
482 NetUserEnum(LPCWSTR servername, DWORD level, DWORD filter, LPBYTE* bufptr,
483 DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries,
484 LPDWORD resume_handle)
485 {
486 FIXME("(%s,%d, 0x%d,%p,%d,%p,%p,%p) stub!\n", debugstr_w(servername), level,
487 filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
488
489 return ERROR_ACCESS_DENIED;
490 }
491
492 /************************************************************
493 * ACCESS_QueryAdminDisplayInformation
494 *
495 * Creates a buffer with information for the Admin User
496 */
497 static void ACCESS_QueryAdminDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
498 {
499 static const WCHAR sAdminUserName[] = {
500 'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
501
502 /* sizes of the field buffers in WCHARS */
503 int name_sz, comment_sz, full_name_sz;
504 PNET_DISPLAY_USER usr;
505
506 /* set up buffer */
507 name_sz = lstrlenW(sAdminUserName) + 1;
508 comment_sz = 1;
509 full_name_sz = 1;
510
511 *pdwSize = sizeof(NET_DISPLAY_USER);
512 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
513 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
514
515 usr = *buf;
516 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
517 usr->usri1_comment = (LPWSTR) (
518 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
519 usr->usri1_full_name = (LPWSTR) (
520 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
521
522 /* set data */
523 lstrcpyW(usr->usri1_name, sAdminUserName);
524 usr->usri1_comment[0] = 0;
525 usr->usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
526 usr->usri1_full_name[0] = 0;
527 usr->usri1_user_id = DOMAIN_USER_RID_ADMIN;
528 usr->usri1_next_index = 0;
529 }
530
531 /************************************************************
532 * ACCESS_QueryGuestDisplayInformation
533 *
534 * Creates a buffer with information for the Guest User
535 */
536 static void ACCESS_QueryGuestDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
537 {
538 static const WCHAR sGuestUserName[] = {
539 'G','u','e','s','t',0 };
540
541 /* sizes of the field buffers in WCHARS */
542 int name_sz, comment_sz, full_name_sz;
543 PNET_DISPLAY_USER usr;
544
545 /* set up buffer */
546 name_sz = lstrlenW(sGuestUserName) + 1;
547 comment_sz = 1;
548 full_name_sz = 1;
549
550 *pdwSize = sizeof(NET_DISPLAY_USER);
551 *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
552 NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
553
554 usr = *buf;
555 usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
556 usr->usri1_comment = (LPWSTR) (
557 ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
558 usr->usri1_full_name = (LPWSTR) (
559 ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
560
561 /* set data */
562 lstrcpyW(usr->usri1_name, sGuestUserName);
563 usr->usri1_comment[0] = 0;
564 usr->usri1_flags = UF_ACCOUNTDISABLE | UF_SCRIPT | UF_NORMAL_ACCOUNT |
565 UF_DONT_EXPIRE_PASSWD;
566 usr->usri1_full_name[0] = 0;
567 usr->usri1_user_id = DOMAIN_USER_RID_GUEST;
568 usr->usri1_next_index = 0;
569 }
570
571 /************************************************************
572 * Copies NET_DISPLAY_USER record.
573 */
574 static void ACCESS_CopyDisplayUser(const NET_DISPLAY_USER *dest, LPWSTR *dest_buf,
575 PNET_DISPLAY_USER src)
576 {
577 LPWSTR str = *dest_buf;
578
579 src->usri1_name = str;
580 lstrcpyW(src->usri1_name, dest->usri1_name);
581 str = (LPWSTR) (
582 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
583
584 src->usri1_comment = str;
585 lstrcpyW(src->usri1_comment, dest->usri1_comment);
586 str = (LPWSTR) (
587 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
588
589 src->usri1_flags = dest->usri1_flags;
590
591 src->usri1_full_name = str;
592 lstrcpyW(src->usri1_full_name, dest->usri1_full_name);
593 str = (LPWSTR) (
594 ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
595
596 src->usri1_user_id = dest->usri1_user_id;
597 src->usri1_next_index = dest->usri1_next_index;
598 *dest_buf = str;
599 }
600
601 /************************************************************
602 * NetQueryDisplayInformation (NETAPI32.@)
603 *
604 * The buffer structure:
605 * - array of fixed size record of the level type
606 * - strings, referenced by the record of the level type
607 */
608 NET_API_STATUS WINAPI
609 NetQueryDisplayInformation(
610 LPCWSTR ServerName, DWORD Level, DWORD Index, DWORD EntriesRequested,
611 DWORD PreferredMaximumLength, LPDWORD ReturnedEntryCount,
612 PVOID *SortedBuffer)
613 {
614 TRACE("(%s, %d, %d, %d, %d, %p, %p)\n", debugstr_w(ServerName),
615 Level, Index, EntriesRequested, PreferredMaximumLength,
616 ReturnedEntryCount, SortedBuffer);
617
618 if(!NETAPI_IsLocalComputer(ServerName))
619 {
620 FIXME("Only implemented on local computer, but requested for "
621 "remote server %s\n", debugstr_w(ServerName));
622 return ERROR_ACCESS_DENIED;
623 }
624
625 switch (Level)
626 {
627 case 1:
628 {
629 /* current record */
630 PNET_DISPLAY_USER inf;
631 /* current available strings buffer */
632 LPWSTR str;
633 PNET_DISPLAY_USER admin, guest;
634 DWORD admin_size, guest_size;
635 LPWSTR name = NULL;
636 DWORD dwSize;
637
638 /* sizes of the field buffers in WCHARS */
639 int name_sz, comment_sz, full_name_sz;
640
641 /* number of the records, returned in SortedBuffer
642 3 - for current user, Administrator and Guest users
643 */
644 int records = 3;
645
646 FIXME("Level %d partially implemented\n", Level);
647 *ReturnedEntryCount = records;
648 comment_sz = 1;
649 full_name_sz = 1;
650
651 /* get data */
652 dwSize = UNLEN + 1;
653 NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &name);
654 if (!GetUserNameW(name, &dwSize))
655 {
656 NetApiBufferFree(name);
657 return ERROR_ACCESS_DENIED;
658 }
659 name_sz = dwSize;
660 ACCESS_QueryAdminDisplayInformation(&admin, &admin_size);
661 ACCESS_QueryGuestDisplayInformation(&guest, &guest_size);
662
663 /* set up buffer */
664 dwSize = sizeof(NET_DISPLAY_USER) * records;
665 dwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
666
667 NetApiBufferAllocate(dwSize +
668 admin_size - sizeof(NET_DISPLAY_USER) +
669 guest_size - sizeof(NET_DISPLAY_USER),
670 SortedBuffer);
671 inf = *SortedBuffer;
672 str = (LPWSTR) ((PBYTE) inf + sizeof(NET_DISPLAY_USER) * records);
673 inf->usri1_name = str;
674 str = (LPWSTR) (
675 ((PBYTE) str) + name_sz * sizeof(WCHAR));
676 inf->usri1_comment = str;
677 str = (LPWSTR) (
678 ((PBYTE) str) + comment_sz * sizeof(WCHAR));
679 inf->usri1_full_name = str;
680 str = (LPWSTR) (
681 ((PBYTE) str) + full_name_sz * sizeof(WCHAR));
682
683 /* set data */
684 lstrcpyW(inf->usri1_name, name);
685 NetApiBufferFree(name);
686 inf->usri1_comment[0] = 0;
687 inf->usri1_flags =
688 UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
689 inf->usri1_full_name[0] = 0;
690 inf->usri1_user_id = 0;
691 inf->usri1_next_index = 0;
692
693 inf++;
694 ACCESS_CopyDisplayUser(admin, &str, inf);
695 NetApiBufferFree(admin);
696
697 inf++;
698 ACCESS_CopyDisplayUser(guest, &str, inf);
699 NetApiBufferFree(guest);
700 break;
701 }
702
703 case 2:
704 case 3:
705 {
706 FIXME("Level %d is not implemented\n", Level);
707 break;
708 }
709
710 default:
711 TRACE("Invalid level %d is specified\n", Level);
712 return ERROR_INVALID_LEVEL;
713 }
714 return NERR_Success;
715 }
716
717 /************************************************************
718 * NetGetDCName (NETAPI32.@)
719 *
720 * Return the name of the primary domain controller (PDC)
721 */
722
723 NET_API_STATUS WINAPI
724 NetGetDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
725 {
726 FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
727 debugstr_w(domainname), bufptr);
728 return NERR_DCNotFound; /* say we can't find a domain controller */
729 }
730
731 /************************************************************
732 * NetGroupEnum (NETAPI32.@)
733 *
734 */
735 NET_API_STATUS WINAPI
736 NetGroupEnum(LPCWSTR servername, DWORD level, LPBYTE *bufptr, DWORD prefmaxlen,
737 LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
738 {
739 FIXME("(%s, %d, %p, %d, %p, %p, %p) stub!\n", debugstr_w(servername),
740 level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
741 return ERROR_ACCESS_DENIED;
742 }
743
744 /************************************************************
745 * NetGroupGetInfo (NETAPI32.@)
746 *
747 */
748 NET_API_STATUS WINAPI NetGroupGetInfo(LPCWSTR servername, LPCWSTR groupname, DWORD level, LPBYTE *bufptr)
749 {
750 FIXME("(%s, %s, %d, %p) stub!\n", debugstr_w(servername), debugstr_w(groupname), level, bufptr);
751 return ERROR_ACCESS_DENIED;
752 }
753
754 /******************************************************************************
755 * NetUserModalsGet (NETAPI32.@)
756 *
757 * Retrieves global information for all users and global groups in the security
758 * database.
759 *
760 * PARAMS
761 * szServer [I] Specifies the DNS or the NetBIOS name of the remote server
762 * on which the function is to execute.
763 * level [I] Information level of the data.
764 * 0 Return global passwords parameters. bufptr points to a
765 * USER_MODALS_INFO_0 struct.
766 * 1 Return logon server and domain controller information. bufptr
767 * points to a USER_MODALS_INFO_1 struct.
768 * 2 Return domain name and identifier. bufptr points to a
769 * USER_MODALS_INFO_2 struct.
770 * 3 Return lockout information. bufptr points to a USER_MODALS_INFO_3
771 * struct.
772 * pbuffer [I] Buffer that receives the data.
773 *
774 * RETURNS
775 * Success: NERR_Success.
776 * Failure:
777 * ERROR_ACCESS_DENIED - the user does not have access to the info.
778 * NERR_InvalidComputer - computer name is invalid.
779 */
780 NET_API_STATUS WINAPI NetUserModalsGet(
781 LPCWSTR szServer, DWORD level, LPBYTE *pbuffer)
782 {
783 TRACE("(%s %d %p)\n", debugstr_w(szServer), level, pbuffer);
784
785 switch (level)
786 {
787 case 0:
788 /* return global passwords parameters */
789 FIXME("level 0 not implemented!\n");
790 *pbuffer = NULL;
791 return NERR_InternalError;
792 case 1:
793 /* return logon server and domain controller info */
794 FIXME("level 1 not implemented!\n");
795 *pbuffer = NULL;
796 return NERR_InternalError;
797 case 2:
798 {
799 /* return domain name and identifier */
800 PUSER_MODALS_INFO_2 umi;
801 LSA_HANDLE policyHandle;
802 LSA_OBJECT_ATTRIBUTES objectAttributes;
803 PPOLICY_ACCOUNT_DOMAIN_INFO domainInfo;
804 NTSTATUS ntStatus;
805 PSID domainIdentifier = NULL;
806 int domainNameLen;
807
808 ZeroMemory(&objectAttributes, sizeof(objectAttributes));
809 objectAttributes.Length = sizeof(objectAttributes);
810
811 ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
812 POLICY_VIEW_LOCAL_INFORMATION,
813 &policyHandle);
814 if (ntStatus != STATUS_SUCCESS)
815 {
816 WARN("LsaOpenPolicy failed with NT status %x\n",
817 LsaNtStatusToWinError(ntStatus));
818 return ntStatus;
819 }
820
821 ntStatus = LsaQueryInformationPolicy(policyHandle,
822 PolicyAccountDomainInformation,
823 (PVOID *)&domainInfo);
824 if (ntStatus != STATUS_SUCCESS)
825 {
826 WARN("LsaQueryInformationPolicy failed with NT status %x\n",
827 LsaNtStatusToWinError(ntStatus));
828 LsaClose(policyHandle);
829 return ntStatus;
830 }
831
832 domainIdentifier = domainInfo->DomainSid;
833 domainNameLen = lstrlenW(domainInfo->DomainName.Buffer) + 1;
834 LsaClose(policyHandle);
835
836 ntStatus = NetApiBufferAllocate(sizeof(USER_MODALS_INFO_2) +
837 GetLengthSid(domainIdentifier) +
838 domainNameLen * sizeof(WCHAR),
839 (LPVOID *)pbuffer);
840
841 if (ntStatus != NERR_Success)
842 {
843 WARN("NetApiBufferAllocate() failed\n");
844 LsaFreeMemory(domainInfo);
845 return ntStatus;
846 }
847
848 umi = (USER_MODALS_INFO_2 *) *pbuffer;
849 umi->usrmod2_domain_id = *pbuffer + sizeof(USER_MODALS_INFO_2);
850 umi->usrmod2_domain_name = (LPWSTR)(*pbuffer +
851 sizeof(USER_MODALS_INFO_2) + GetLengthSid(domainIdentifier));
852
853 lstrcpynW(umi->usrmod2_domain_name,
854 domainInfo->DomainName.Buffer,
855 domainNameLen);
856 CopySid(GetLengthSid(domainIdentifier), umi->usrmod2_domain_id,
857 domainIdentifier);
858
859 LsaFreeMemory(domainInfo);
860
861 break;
862 }
863 case 3:
864 /* return lockout information */
865 FIXME("level 3 not implemented!\n");
866 *pbuffer = NULL;
867 return NERR_InternalError;
868 default:
869 TRACE("Invalid level %d is specified\n", level);
870 *pbuffer = NULL;
871 return ERROR_INVALID_LEVEL;
872 }
873
874 return NERR_Success;
875 }
876
877 static char *strdup_unixcp( const WCHAR *str )
878 {
879 char *ret;
880 int len = WideCharToMultiByte( CP_UNIXCP, 0, str, -1, NULL, 0, NULL, NULL );
881 if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
882 WideCharToMultiByte( CP_UNIXCP, 0, str, -1, ret, len, NULL, NULL );
883 return ret;
884 }
885
886 static NET_API_STATUS change_password_smb( LPCWSTR domainname, LPCWSTR username,
887 LPCWSTR oldpassword, LPCWSTR newpassword )
888 {
889 #ifdef HAVE_FORK
890 NET_API_STATUS ret = NERR_Success;
891 static char option_silent[] = "-s";
892 static char option_user[] = "-U";
893 static char option_remote[] = "-r";
894 static char smbpasswd[] = "smbpasswd";
895 int pipe_out[2];
896 pid_t pid, wret;
897 int status;
898 char *server = NULL, *user, *argv[7], *old = NULL, *new = NULL;
899
900 if (domainname && !(server = strdup_unixcp( domainname ))) return ERROR_OUTOFMEMORY;
901 if (!(user = strdup_unixcp( username )))
902 {
903 ret = ERROR_OUTOFMEMORY;
904 goto end;
905 }
906 if (!(old = strdup_unixcp( oldpassword )))
907 {
908 ret = ERROR_OUTOFMEMORY;
909 goto end;
910 }
911 if (!(new = strdup_unixcp( newpassword )))
912 {
913 ret = ERROR_OUTOFMEMORY;
914 goto end;
915 }
916 argv[0] = smbpasswd;
917 argv[1] = option_silent;
918 argv[2] = option_user;
919 argv[3] = user;
920 if (server)
921 {
922 argv[4] = option_remote;
923 argv[5] = server;
924 argv[6] = NULL;
925 }
926 else argv[4] = NULL;
927
928 if (pipe( pipe_out ) == -1)
929 {
930 ret = NERR_InternalError;
931 goto end;
932 }
933 fcntl( pipe_out[0], F_SETFD, FD_CLOEXEC );
934 fcntl( pipe_out[1], F_SETFD, FD_CLOEXEC );
935
936 switch ((pid = fork()))
937 {
938 case -1:
939 close( pipe_out[0] );
940 close( pipe_out[1] );
941 ret = NERR_InternalError;
942 goto end;
943 case 0:
944 dup2( pipe_out[0], 0 );
945 close( pipe_out[0] );
946 close( pipe_out[1] );
947 execvp( "smbpasswd", argv );
948 ERR( "can't execute smbpasswd, is it installed?\n" );
949 _exit(1);
950 default:
951 close( pipe_out[0] );
952 break;
953 }
954 write( pipe_out[1], old, strlen( old ) );
955 write( pipe_out[1], "\n", 1 );
956 write( pipe_out[1], new, strlen( new ) );
957 write( pipe_out[1], "\n", 1 );
958 write( pipe_out[1], new, strlen( new ) );
959 write( pipe_out[1], "\n", 1 );
960 close( pipe_out[1] );
961
962 do {
963 wret = waitpid(pid, &status, 0);
964 } while (wret < 0 && errno == EINTR);
965
966 if (ret == NERR_Success && (wret < 0 || !WIFEXITED(status) || WEXITSTATUS(status)))
967 ret = NERR_InternalError;
968
969 end:
970 HeapFree( GetProcessHeap(), 0, server );
971 HeapFree( GetProcessHeap(), 0, user );
972 HeapFree( GetProcessHeap(), 0, old );
973 HeapFree( GetProcessHeap(), 0, new );
974 return ret;
975 #else
976 ERR( "no fork support on this platform\n" );
977 return NERR_InternalError;
978 #endif
979 }
980
981 /******************************************************************************
982 * NetUserChangePassword (NETAPI32.@)
983 * PARAMS
984 * domainname [I] Optional. Domain on which the user resides or the logon
985 * domain of the current user if NULL.
986 * username [I] Optional. Username to change the password for or the name
987 * of the current user if NULL.
988 * oldpassword [I] The user's current password.
989 * newpassword [I] The password that the user will be changed to using.
990 *
991 * RETURNS
992 * Success: NERR_Success.
993 * Failure: NERR_* failure code or win error code.
994 *
995 */
996 NET_API_STATUS WINAPI NetUserChangePassword(LPCWSTR domainname, LPCWSTR username,
997 LPCWSTR oldpassword, LPCWSTR newpassword)
998 {
999 struct sam_user *user;
1000
1001 TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
1002
1003 if (!change_password_smb( domainname, username, oldpassword, newpassword ))
1004 return NERR_Success;
1005
1006 if(domainname)
1007 FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
1008
1009 if((user = NETAPI_FindUser(username)) == NULL)
1010 return NERR_UserNotFound;
1011
1012 if(lstrcmpW(user->user_password, oldpassword) != 0)
1013 return ERROR_INVALID_PASSWORD;
1014
1015 if(lstrlenW(newpassword) > PWLEN)
1016 return ERROR_PASSWORD_RESTRICTION;
1017
1018 lstrcpyW(user->user_password, newpassword);
1019
1020 return NERR_Success;
1021 }
1022
1023 NET_API_STATUS WINAPI NetUseAdd(LMSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
1024 {
1025 FIXME("%s %d %p %p stub\n", debugstr_w(servername), level, bufptr, parm_err);
1026 return NERR_Success;
1027 }
1028
1029 NET_API_STATUS WINAPI NetUseDel(LMSTR servername, LMSTR usename, DWORD forcecond)
1030 {
1031 FIXME("%s %s %d stub\n", debugstr_w(servername), debugstr_w(usename), forcecond);
1032 return NERR_Success;
1033 }
Maarten's multimedia branch