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     const WCHAR admins[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r','s',0};
 421     LPWSTR currentuser;
 422     LOCALGROUP_USERS_INFO_0* info;
 423     DWORD size;
 424
 425     FIXME("(%s, %s, %d, %08x, %p %d, %p, %p) stub!\n",
 426           debugstr_w(servername), debugstr_w(username), level, flags, bufptr,
 427           prefmaxlen, entriesread, totalentries);
 428
 429     status = NETAPI_ValidateServername(servername);
 430     if (status != NERR_Success)
 431         return status;
 432
 433     size = UNLEN + 1;
 434     NetApiBufferAllocate(size, (LPVOID*)&currentuser);
 435     GetUserNameW(currentuser, &size);
 436
 437     if (lstrcmpiW(username, currentuser) && NETAPI_FindUser(username))
 438     {
 439         NetApiBufferFree(currentuser);
 440         return NERR_UserNotFound;
 441     }
 442
 443     NetApiBufferFree(currentuser);
 444     *totalentries = 1;
 445     size = sizeof(*info) + sizeof(admins);
 446
 447     if(prefmaxlen < size)
 448         status = ERROR_MORE_DATA;
 449     else
 450         status = NetApiBufferAllocate(size, (LPVOID*)&info);
 451
 452     if(status != NERR_Success)
 453     {
 454         *bufptr = NULL;
 455         *entriesread = 0;
 456         return status;
 457     }
 458
 459     info->lgrui0_name = (LPWSTR)((LPBYTE)info + sizeof(*info));
 460     lstrcpyW(info->lgrui0_name, admins);
 461
 462     *bufptr = (LPBYTE)info;
 463     *entriesread = 1;
 464
 465     return NERR_Success;
 466 }
 467
 468 /************************************************************
 469  *                NetUserEnum  (NETAPI32.@)
 470  */
 471 NET_API_STATUS WINAPI
 472 NetUserEnum(LPCWSTR servername, DWORD level, DWORD filter, LPBYTE* bufptr,
 473             DWORD prefmaxlen, LPDWORD entriesread, LPDWORD totalentries,
 474             LPDWORD resume_handle)
 475 {
 476   FIXME("(%s,%d, 0x%d,%p,%d,%p,%p,%p) stub!\n", debugstr_w(servername), level,
 477         filter, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 478
 479   return ERROR_ACCESS_DENIED;
 480 }
 481
 482 /************************************************************
 483  *                ACCESS_QueryAdminDisplayInformation
 484  *
 485  *  Creates a buffer with information for the Admin User
 486  */
 487 static void ACCESS_QueryAdminDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
 488 {
 489     static const WCHAR sAdminUserName[] = {
 490         'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
 491
 492     /* sizes of the field buffers in WCHARS */
 493     int name_sz, comment_sz, full_name_sz;
 494     PNET_DISPLAY_USER usr;
 495
 496     /* set up buffer */
 497     name_sz = lstrlenW(sAdminUserName);
 498     comment_sz = 1;
 499     full_name_sz = 1;
 500
 501     *pdwSize = sizeof(NET_DISPLAY_USER);
 502     *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
 503     NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
 504
 505     usr = *buf;
 506     usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
 507     usr->usri1_comment = (LPWSTR) (
 508         ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
 509     usr->usri1_full_name = (LPWSTR) (
 510         ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
 511
 512     /* set data */
 513     lstrcpyW(usr->usri1_name, sAdminUserName);
 514     usr->usri1_comment[0] = 0;
 515     usr->usri1_flags = UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
 516     usr->usri1_full_name[0] = 0;
 517     usr->usri1_user_id = DOMAIN_USER_RID_ADMIN;
 518     usr->usri1_next_index = 0;
 519 }
 520
 521 /************************************************************
 522  *                ACCESS_QueryGuestDisplayInformation
 523  *
 524  *  Creates a buffer with information for the Guest User
 525  */
 526 static void ACCESS_QueryGuestDisplayInformation(PNET_DISPLAY_USER *buf, PDWORD pdwSize)
 527 {
 528     static const WCHAR sGuestUserName[] = {
 529         'G','u','e','s','t',0 };
 530
 531     /* sizes of the field buffers in WCHARS */
 532     int name_sz, comment_sz, full_name_sz;
 533     PNET_DISPLAY_USER usr;
 534
 535     /* set up buffer */
 536     name_sz = lstrlenW(sGuestUserName);
 537     comment_sz = 1;
 538     full_name_sz = 1;
 539
 540     *pdwSize = sizeof(NET_DISPLAY_USER);
 541     *pdwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
 542     NetApiBufferAllocate(*pdwSize, (LPVOID *) buf);
 543
 544     usr = *buf;
 545     usr->usri1_name = (LPWSTR) ((PBYTE) usr + sizeof(NET_DISPLAY_USER));
 546     usr->usri1_comment = (LPWSTR) (
 547         ((PBYTE) usr->usri1_name) + name_sz * sizeof(WCHAR));
 548     usr->usri1_full_name = (LPWSTR) (
 549         ((PBYTE) usr->usri1_comment) + comment_sz * sizeof(WCHAR));
 550
 551     /* set data */
 552     lstrcpyW(usr->usri1_name, sGuestUserName);
 553     usr->usri1_comment[0] = 0;
 554     usr->usri1_flags = UF_ACCOUNTDISABLE | UF_SCRIPT | UF_NORMAL_ACCOUNT |
 555         UF_DONT_EXPIRE_PASSWD;
 556     usr->usri1_full_name[0] = 0;
 557     usr->usri1_user_id = DOMAIN_USER_RID_GUEST;
 558     usr->usri1_next_index = 0;
 559 }
 560
 561 /************************************************************
 562  * Copies NET_DISPLAY_USER record.
 563  */
 564 static void ACCESS_CopyDisplayUser(const NET_DISPLAY_USER *dest, LPWSTR *dest_buf,
 565                             PNET_DISPLAY_USER src)
 566 {
 567     LPWSTR str = *dest_buf;
 568
 569     src->usri1_name = str;
 570     lstrcpyW(src->usri1_name, dest->usri1_name);
 571     str = (LPWSTR) (
 572         ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
 573
 574     src->usri1_comment = str;
 575     lstrcpyW(src->usri1_comment, dest->usri1_comment);
 576     str = (LPWSTR) (
 577         ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
 578
 579     src->usri1_flags = dest->usri1_flags;
 580
 581     src->usri1_full_name = str;
 582     lstrcpyW(src->usri1_full_name, dest->usri1_full_name);
 583     str = (LPWSTR) (
 584         ((PBYTE) str) + (lstrlenW(str) + 1) * sizeof(WCHAR));
 585
 586     src->usri1_user_id = dest->usri1_user_id;
 587     src->usri1_next_index = dest->usri1_next_index;
 588     *dest_buf = str;
 589 }
 590
 591 /************************************************************
 592  *                NetQueryDisplayInformation  (NETAPI32.@)
 593  *
 594  * The buffer structure:
 595  * - array of fixed size record of the level type
 596  * - strings, referenced by the record of the level type
 597  */
 598 NET_API_STATUS WINAPI
 599 NetQueryDisplayInformation(
 600     LPCWSTR ServerName, DWORD Level, DWORD Index, DWORD EntriesRequested,
 601     DWORD PreferredMaximumLength, LPDWORD ReturnedEntryCount,
 602     PVOID *SortedBuffer)
 603 {
 604     TRACE("(%s, %d, %d, %d, %d, %p, %p)\n", debugstr_w(ServerName),
 605           Level, Index, EntriesRequested, PreferredMaximumLength,
 606           ReturnedEntryCount, SortedBuffer);
 607
 608     if(!NETAPI_IsLocalComputer(ServerName))
 609     {
 610         FIXME("Only implemented on local computer, but requested for "
 611               "remote server %s\n", debugstr_w(ServerName));
 612         return ERROR_ACCESS_DENIED;
 613     }
 614
 615     switch (Level)
 616     {
 617     case 1:
 618     {
 619         /* current record */
 620         PNET_DISPLAY_USER inf;
 621         /* current available strings buffer */
 622         LPWSTR str;
 623         PNET_DISPLAY_USER admin, guest;
 624         DWORD admin_size, guest_size;
 625         LPWSTR name = NULL;
 626         DWORD dwSize;
 627
 628         /* sizes of the field buffers in WCHARS */
 629         int name_sz, comment_sz, full_name_sz;
 630
 631         /* number of the records, returned in SortedBuffer
 632            3 - for current user, Administrator and Guest users
 633          */
 634         int records = 3;
 635
 636         FIXME("Level %d partially implemented\n", Level);
 637         *ReturnedEntryCount = records;
 638         comment_sz = 1;
 639         full_name_sz = 1;
 640
 641         /* get data */
 642         dwSize = UNLEN + 1;
 643         NetApiBufferAllocate(dwSize, (LPVOID *) &name);
 644         if (!GetUserNameW(name, &dwSize))
 645         {
 646             NetApiBufferFree(name);
 647             return ERROR_ACCESS_DENIED;
 648         }
 649         name_sz = dwSize;
 650         ACCESS_QueryAdminDisplayInformation(&admin, &admin_size);
 651         ACCESS_QueryGuestDisplayInformation(&guest, &guest_size);
 652
 653         /* set up buffer */
 654         dwSize = sizeof(NET_DISPLAY_USER) * records;
 655         dwSize += (name_sz + comment_sz + full_name_sz) * sizeof(WCHAR);
 656
 657         NetApiBufferAllocate(dwSize +
 658                              admin_size - sizeof(NET_DISPLAY_USER) +
 659                              guest_size - sizeof(NET_DISPLAY_USER),
 660                              SortedBuffer);
 661         inf = (PNET_DISPLAY_USER) *SortedBuffer;
 662         str = (LPWSTR) ((PBYTE) inf + sizeof(NET_DISPLAY_USER) * records);
 663         inf->usri1_name = str;
 664         str = (LPWSTR) (
 665             ((PBYTE) str) + name_sz * sizeof(WCHAR));
 666         inf->usri1_comment = str;
 667         str = (LPWSTR) (
 668             ((PBYTE) str) + comment_sz * sizeof(WCHAR));
 669         inf->usri1_full_name = str;
 670         str = (LPWSTR) (
 671             ((PBYTE) str) + full_name_sz * sizeof(WCHAR));
 672
 673         /* set data */
 674         lstrcpyW(inf->usri1_name, name);
 675         NetApiBufferFree(name);
 676         inf->usri1_comment[0] = 0;
 677         inf->usri1_flags =
 678             UF_SCRIPT | UF_NORMAL_ACCOUNT | UF_DONT_EXPIRE_PASSWD;
 679         inf->usri1_full_name[0] = 0;
 680         inf->usri1_user_id = 0;
 681         inf->usri1_next_index = 0;
 682
 683         inf++;
 684         ACCESS_CopyDisplayUser(admin, &str, inf);
 685         NetApiBufferFree(admin);
 686
 687         inf++;
 688         ACCESS_CopyDisplayUser(guest, &str, inf);
 689         NetApiBufferFree(guest);
 690         break;
 691     }
 692
 693     case 2:
 694     case 3:
 695     {
 696         FIXME("Level %d is not implemented\n", Level);
 697         break;
 698     }
 699
 700     default:
 701         TRACE("Invalid level %d is specified\n", Level);
 702         return ERROR_INVALID_LEVEL;
 703     }
 704     return NERR_Success;
 705 }
 706
 707 /************************************************************
 708  *                NetGetDCName  (NETAPI32.@)
 709  *
 710  *  Return the name of the primary domain controller (PDC)
 711  */
 712
 713 NET_API_STATUS WINAPI
 714 NetGetDCName(LPCWSTR servername, LPCWSTR domainname, LPBYTE *bufptr)
 715 {
 716   FIXME("(%s, %s, %p) stub!\n", debugstr_w(servername),
 717                  debugstr_w(domainname), bufptr);
 718   return NERR_DCNotFound; /* say we can't find a domain controller */
 719 }
 720
 721 /************************************************************
 722  *                NetGroupEnum  (NETAPI32.@)
 723  *
 724  */
 725 NET_API_STATUS WINAPI
 726 NetGroupEnum(LPCWSTR servername, DWORD level, LPBYTE *bufptr, DWORD prefmaxlen,
 727              LPDWORD entriesread, LPDWORD totalentries, LPDWORD resume_handle)
 728 {
 729     FIXME("(%s, %d, %p, %d, %p, %p, %p) stub!\n", debugstr_w(servername),
 730           level, bufptr, prefmaxlen, entriesread, totalentries, resume_handle);
 731     return ERROR_ACCESS_DENIED;
 732 }
 733
 734 /******************************************************************************
 735  * NetUserModalsGet  (NETAPI32.@)
 736  *
 737  * Retrieves global information for all users and global groups in the security
 738  * database.
 739  *
 740  * PARAMS
 741  *  szServer   [I] Specifies the DNS or the NetBIOS name of the remote server
 742  *                 on which the function is to execute.
 743  *  level      [I] Information level of the data.
 744  *     0   Return global passwords parameters. bufptr points to a
 745  *         USER_MODALS_INFO_0 struct.
 746  *     1   Return logon server and domain controller information. bufptr
 747  *         points to a USER_MODALS_INFO_1 struct.
 748  *     2   Return domain name and identifier. bufptr points to a
 749  *         USER_MODALS_INFO_2 struct.
 750  *     3   Return lockout information. bufptr points to a USER_MODALS_INFO_3
 751  *         struct.
 752  *  pbuffer    [I] Buffer that receives the data.
 753  *
 754  * RETURNS
 755  *  Success: NERR_Success.
 756  *  Failure:
 757  *     ERROR_ACCESS_DENIED - the user does not have access to the info.
 758  *     NERR_InvalidComputer - computer name is invalid.
 759  */
 760 NET_API_STATUS WINAPI NetUserModalsGet(
 761     LPCWSTR szServer, DWORD level, LPBYTE *pbuffer)
 762 {
 763     TRACE("(%s %d %p)\n", debugstr_w(szServer), level, pbuffer);
 764
 765     switch (level)
 766     {
 767         case 0:
 768             /* return global passwords parameters */
 769             FIXME("level 0 not implemented!\n");
 770             *pbuffer = NULL;
 771             return NERR_InternalError;
 772         case 1:
 773             /* return logon server and domain controller info */
 774             FIXME("level 1 not implemented!\n");
 775             *pbuffer = NULL;
 776             return NERR_InternalError;
 777         case 2:
 778         {
 779             /* return domain name and identifier */
 780             PUSER_MODALS_INFO_2 umi;
 781             LSA_HANDLE policyHandle;
 782             LSA_OBJECT_ATTRIBUTES objectAttributes;
 783             PPOLICY_ACCOUNT_DOMAIN_INFO domainInfo;
 784             NTSTATUS ntStatus;
 785             PSID domainIdentifier = NULL;
 786             int domainNameLen;
 787
 788             ZeroMemory(&objectAttributes, sizeof(objectAttributes));
 789             objectAttributes.Length = sizeof(objectAttributes);
 790
 791             ntStatus = LsaOpenPolicy(NULL, &objectAttributes,
 792                                      POLICY_VIEW_LOCAL_INFORMATION,
 793                                      &policyHandle);
 794             if (ntStatus != STATUS_SUCCESS)
 795             {
 796                 WARN("LsaOpenPolicy failed with NT status %x\n",
 797                      LsaNtStatusToWinError(ntStatus));
 798                 return ntStatus;
 799             }
 800
 801             ntStatus = LsaQueryInformationPolicy(policyHandle,
 802                                                  PolicyAccountDomainInformation,
 803                                                  (PVOID *)&domainInfo);
 804             if (ntStatus != STATUS_SUCCESS)
 805             {
 806                 WARN("LsaQueryInformationPolicy failed with NT status %x\n",
 807                      LsaNtStatusToWinError(ntStatus));
 808                 LsaClose(policyHandle);
 809                 return ntStatus;
 810             }
 811
 812             domainIdentifier = domainInfo->DomainSid;
 813             domainNameLen = lstrlenW(domainInfo->DomainName.Buffer) + 1;
 814             LsaClose(policyHandle);
 815
 816             ntStatus = NetApiBufferAllocate(sizeof(USER_MODALS_INFO_2) +
 817                                             GetLengthSid(domainIdentifier) +
 818                                             domainNameLen * sizeof(WCHAR),
 819                                             (LPVOID *)pbuffer);
 820
 821             if (ntStatus != NERR_Success)
 822             {
 823                 WARN("NetApiBufferAllocate() failed\n");
 824                 LsaFreeMemory(domainInfo);
 825                 return ntStatus;
 826             }
 827
 828             umi = (USER_MODALS_INFO_2 *) *pbuffer;
 829             umi->usrmod2_domain_id = (PSID)(*pbuffer +
 830                 sizeof(USER_MODALS_INFO_2));
 831             umi->usrmod2_domain_name = (LPWSTR)(*pbuffer +
 832                 sizeof(USER_MODALS_INFO_2) + GetLengthSid(domainIdentifier));
 833
 834             lstrcpynW(umi->usrmod2_domain_name,
 835                       domainInfo->DomainName.Buffer,
 836                       domainNameLen);
 837             CopySid(GetLengthSid(domainIdentifier), umi->usrmod2_domain_id,
 838                     domainIdentifier);
 839
 840             LsaFreeMemory(domainInfo);
 841
 842             break;
 843         }
 844         case 3:
 845             /* return lockout information */
 846             FIXME("level 3 not implemented!\n");
 847             *pbuffer = NULL;
 848             return NERR_InternalError;
 849         default:
 850             TRACE("Invalid level %d is specified\n", level);
 851             *pbuffer = NULL;
 852             return ERROR_INVALID_LEVEL;
 853     }
 854
 855     return NERR_Success;
 856 }
 857
 858 /******************************************************************************
 859  *                NetUserChangePassword  (NETAPI32.@)
 860  * PARAMS
 861  *  domainname  [I] Optional. Domain on which the user resides or the logon
 862  *                  domain of the current user if NULL.
 863  *  username    [I] Optional. Username to change the password for or the name
 864  *                  of the current user if NULL.
 865  *  oldpassword [I] The user's current password.
 866  *  newpassword [I] The password that the user will be changed to using.
 867  *
 868  * RETURNS
 869  *  Success: NERR_Success.
 870  *  Failure: NERR_* failure code or win error code.
 871  *
 872  */
 873 NET_API_STATUS WINAPI NetUserChangePassword(LPCWSTR domainname, LPCWSTR username,
 874     LPCWSTR oldpassword, LPCWSTR newpassword)
 875 {
 876     struct sam_user *user;
 877
 878     TRACE("(%s, %s, ..., ...)\n", debugstr_w(domainname), debugstr_w(username));
 879
 880     if(domainname)
 881         FIXME("Ignoring domainname %s.\n", debugstr_w(domainname));
 882
 883     if((user = NETAPI_FindUser(username)) == NULL)
 884         return NERR_UserNotFound;
 885
 886     if(lstrcmpW(user->user_password, oldpassword) != 0)
 887         return ERROR_INVALID_PASSWORD;
 888
 889     if(lstrlenW(newpassword) > PWLEN)
 890         return ERROR_PASSWORD_RESTRICTION;
 891
 892     lstrcpyW(user->user_password, newpassword);
 893
 894     return NERR_Success;
 895 }
 896
 897 NET_API_STATUS WINAPI NetUseAdd(LMSTR servername, DWORD level, LPBYTE bufptr, LPDWORD parm_err)
 898 {
 899     FIXME("%s %d %p %p stub\n", debugstr_w(servername), level, bufptr, parm_err);
 900     return NERR_Success;
 901 }