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