rpcserver.c

Go to the documentation of this file.

/*
 *  ReactOS Services
 *  Copyright (C) 2015 ReactOS Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
/*
 * COPYRIGHT:        See COPYING in the top level directory
 * PROJECT:          ReactOS Services
 * FILE:             base/services/wkssvc/rpcserver.c
 * PURPOSE:          Workstation service
 * PROGRAMMER:       Eric Kohl
 */
 
/* INCLUDES *****************************************************************/
 
#include "precomp.h"
 
#include "lmerr.h"
 
WINE_DEFAULT_DEBUG_CHANNEL(wkssvc);
 
/* FUNCTIONS *****************************************************************/
 
DWORD
WINAPI
RpcThreadRoutine(
    LPVOID lpParameter)
{
    RPC_STATUS Status;
 
    Status = RpcServerUseProtseqEpW(L"ncacn_np", 20, L"\\pipe\\wkssvc", NULL);
    if (Status != RPC_S_OK)
    {
        ERR("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
        return 0;
    }
 
    Status = RpcServerRegisterIf(wkssvc_v1_0_s_ifspec, NULL, NULL);
    if (Status != RPC_S_OK)
    {
        ERR("RpcServerRegisterIf() failed (Status %lx)\n", Status);
        return 0;
    }
 
    Status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, FALSE);
    if (Status != RPC_S_OK)
    {
        ERR("RpcServerListen() failed (Status %lx)\n", Status);
    }
 
    return 0;
}
 
 
void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
{
    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}
 
 
void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
{
    HeapFree(GetProcessHeap(), 0, ptr);
}
 
 
static
NET_API_STATUS
NetpGetClientLogonId(
    _Out_ PLUID LogonId)
{
    HANDLE ThreadToken = NULL;
    TOKEN_STATISTICS Statistics;
    ULONG Length;
    NTSTATUS NtStatus;
    NET_API_STATUS ApiStatus = NERR_Success;
 
    ApiStatus = RpcImpersonateClient(NULL);
    if (ApiStatus != NERR_Success)
        return ApiStatus;
 
    NtStatus = NtOpenThreadToken(NtCurrentThread(),
                                 TOKEN_QUERY,
                                 TRUE,
                                 &ThreadToken);
    if (!NT_SUCCESS(NtStatus))
    {
        ApiStatus = RtlNtStatusToDosError(NtStatus);
        goto done;
    }
 
    NtStatus = NtQueryInformationToken(ThreadToken,
                                       TokenStatistics,
                                       (PVOID)&Statistics,
                                       sizeof(Statistics),
                                       &Length);
    if (!NT_SUCCESS(NtStatus))
    {
        ApiStatus = RtlNtStatusToDosError(NtStatus);
        goto done;
    }
 
    TRACE("Client LUID: %lx\n", Statistics.AuthenticationId.LowPart);
    RtlCopyLuid(LogonId, &Statistics.AuthenticationId);
 
done:
    if (ThreadToken != NULL)
        NtClose(ThreadToken);
 
    RpcRevertToSelf();
 
    return ApiStatus;
}
 
 
/* Function 0 */
unsigned long
__stdcall
NetrWkstaGetInfo(
    _In_ WKSSVC_IDENTIFY_HANDLE ServerName,
    _In_ unsigned long Level,
    _Out_ LPWKSTA_INFO WkstaInfo)
{
    WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD dwComputerNameLength;
    LPCWSTR pszLanRoot = L"";
    PWKSTA_INFO_100 pWkstaInfo100 = NULL;
    PWKSTA_INFO_101 pWkstaInfo101 = NULL;
    PWKSTA_INFO_102 pWkstaInfo102 = NULL;
    PWKSTA_INFO_502 pWkstaInfo502 = NULL;
    LSA_OBJECT_ATTRIBUTES ObjectAttributes;
    LSA_HANDLE PolicyHandle;
    PPOLICY_PRIMARY_DOMAIN_INFO DomainInfo = NULL;
    ULONG LoggedOnUsers;
    NTSTATUS NtStatus;
    DWORD dwResult = NERR_Success;
 
    TRACE("NetrWkstaGetInfo level %lu\n", Level);
 
    dwComputerNameLength = MAX_COMPUTERNAME_LENGTH + 1;
    GetComputerNameW(szComputerName, &dwComputerNameLength);
    dwComputerNameLength++; /* include NULL terminator */
 
    ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
    NtStatus = LsaOpenPolicy(NULL,
                             &ObjectAttributes,
                             POLICY_VIEW_LOCAL_INFORMATION,
                             &PolicyHandle);
    if (NtStatus != STATUS_SUCCESS)
    {
        WARN("LsaOpenPolicy() failed (Status 0x%08lx)\n", NtStatus);
        return LsaNtStatusToWinError(NtStatus);
    }
 
    NtStatus = LsaQueryInformationPolicy(PolicyHandle,
                                         PolicyPrimaryDomainInformation,
                                         (PVOID*)&DomainInfo);
 
    LsaClose(PolicyHandle);
 
    if (NtStatus != STATUS_SUCCESS)
    {
        WARN("LsaQueryInformationPolicy() failed (Status 0x%08lx)\n", NtStatus);
        return LsaNtStatusToWinError(NtStatus);
    }
 
    if (Level == 102)
    {
        MSV1_0_ENUMUSERS_REQUEST EnumRequest;
        PMSV1_0_ENUMUSERS_RESPONSE EnumResponseBuffer = NULL;
        DWORD EnumResponseBufferSize = 0;
        NTSTATUS ProtocolStatus;
 
        /* enumerate all currently logged-on users */
        EnumRequest.MessageType = MsV1_0EnumerateUsers;
        NtStatus = LsaCallAuthenticationPackage(LsaHandle,
                                                LsaAuthenticationPackage,
                                                &EnumRequest,
                                                sizeof(EnumRequest),
                                                (PVOID*)&EnumResponseBuffer,
                                                &EnumResponseBufferSize,
                                                &ProtocolStatus);
        if (!NT_SUCCESS(NtStatus))
        {
            dwResult = RtlNtStatusToDosError(NtStatus);
            goto done;
        }
 
        LoggedOnUsers = EnumResponseBuffer->NumberOfLoggedOnUsers;
 
        LsaFreeReturnBuffer(EnumResponseBuffer);
    }
 
    switch (Level)
    {
        case 100:
            pWkstaInfo100 = midl_user_allocate(sizeof(WKSTA_INFO_100));
            if (pWkstaInfo100 == NULL)
            {
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            pWkstaInfo100->wki100_platform_id = PLATFORM_ID_NT;
 
            pWkstaInfo100->wki100_computername = midl_user_allocate(dwComputerNameLength * sizeof(WCHAR));
            if (pWkstaInfo100->wki100_computername != NULL)
                wcscpy(pWkstaInfo100->wki100_computername, szComputerName);
 
            pWkstaInfo100->wki100_langroup = midl_user_allocate((wcslen(DomainInfo->Name.Buffer) + 1) * sizeof(WCHAR));
            if (pWkstaInfo100->wki100_langroup != NULL)
                wcscpy(pWkstaInfo100->wki100_langroup, DomainInfo->Name.Buffer);
 
            pWkstaInfo100->wki100_ver_major = VersionInfo.dwMajorVersion;
            pWkstaInfo100->wki100_ver_minor = VersionInfo.dwMinorVersion;
 
            WkstaInfo->WkstaInfo100 = pWkstaInfo100;
            break;
 
        case 101:
            pWkstaInfo101 = midl_user_allocate(sizeof(WKSTA_INFO_101));
            if (pWkstaInfo101 == NULL)
            {
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            pWkstaInfo101->wki101_platform_id = PLATFORM_ID_NT;
 
            pWkstaInfo101->wki101_computername = midl_user_allocate(dwComputerNameLength * sizeof(WCHAR));
            if (pWkstaInfo101->wki101_computername != NULL)
                wcscpy(pWkstaInfo101->wki101_computername, szComputerName);
 
            pWkstaInfo101->wki101_langroup = midl_user_allocate((wcslen(DomainInfo->Name.Buffer) + 1) * sizeof(WCHAR));
            if (pWkstaInfo101->wki101_langroup != NULL)
                wcscpy(pWkstaInfo101->wki101_langroup, DomainInfo->Name.Buffer);
 
            pWkstaInfo101->wki101_ver_major = VersionInfo.dwMajorVersion;
            pWkstaInfo101->wki101_ver_minor = VersionInfo.dwMinorVersion;
 
            pWkstaInfo101->wki101_lanroot = midl_user_allocate((wcslen(pszLanRoot) + 1) * sizeof(WCHAR));
            if (pWkstaInfo101->wki101_lanroot != NULL)
                wcscpy(pWkstaInfo101->wki101_lanroot, pszLanRoot);
 
            WkstaInfo->WkstaInfo101 = pWkstaInfo101;
            break;
 
        case 102:
            pWkstaInfo102 = midl_user_allocate(sizeof(WKSTA_INFO_102));
            if (pWkstaInfo102 == NULL)
            {
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            pWkstaInfo102->wki102_platform_id = PLATFORM_ID_NT;
 
            pWkstaInfo102->wki102_computername = midl_user_allocate(dwComputerNameLength * sizeof(WCHAR));
            if (pWkstaInfo102->wki102_computername != NULL)
                wcscpy(pWkstaInfo102->wki102_computername, szComputerName);
 
            pWkstaInfo102->wki102_langroup = midl_user_allocate((wcslen(DomainInfo->Name.Buffer) + 1) * sizeof(WCHAR));
            if (pWkstaInfo102->wki102_langroup != NULL)
                wcscpy(pWkstaInfo102->wki102_langroup, DomainInfo->Name.Buffer);
 
            pWkstaInfo102->wki102_ver_major = VersionInfo.dwMajorVersion;
            pWkstaInfo102->wki102_ver_minor = VersionInfo.dwMinorVersion;
 
            pWkstaInfo102->wki102_lanroot = midl_user_allocate((wcslen(pszLanRoot) + 1) * sizeof(WCHAR));
            if (pWkstaInfo102->wki102_lanroot != NULL)
                wcscpy(pWkstaInfo102->wki102_lanroot, pszLanRoot);
 
            pWkstaInfo102->wki102_logged_on_users = LoggedOnUsers;
 
            WkstaInfo->WkstaInfo102 = pWkstaInfo102;
            break;
 
        case 502:
            pWkstaInfo502 = midl_user_allocate(sizeof(WKSTA_INFO_502));
            if (pWkstaInfo502 == NULL)
            {
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            CopyMemory(pWkstaInfo502, &WkstaInfo502, sizeof(WKSTA_INFO_502));
 
            WkstaInfo->WkstaInfo502 = pWkstaInfo502;
            break;
 
        default:
            FIXME("Level %lu unimplemented\n", Level);
            dwResult = ERROR_INVALID_LEVEL;
            break;
    }
 
done:
    if (DomainInfo != NULL)
        LsaFreeMemory(DomainInfo);
 
    return dwResult;
}
 
 
/* Function 1 */
unsigned long
__stdcall
NetrWkstaSetInfo(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    unsigned long Level,
    LPWKSTA_INFO WkstaInfo,
    unsigned long *ErrorParameter)
{
    DWORD dwErrParam = 0;
    DWORD dwResult = NERR_Success;
 
    TRACE("NetrWkstaSetInfo(%lu %p %p)\n",
          Level, WkstaInfo, ErrorParameter);
 
    switch (Level)
    {
        case 502:
            if (WkstaInfo->WkstaInfo502->wki502_keep_conn >= 1 && WkstaInfo->WkstaInfo502->wki502_keep_conn <= 65535)
            {
                WkstaInfo502.wki502_keep_conn = WkstaInfo->WkstaInfo502->wki502_keep_conn;
            }
            else
            {
                dwErrParam = WKSTA_KEEPCONN_PARMNUM;
                dwResult = ERROR_INVALID_PARAMETER;
            }
 
            if (dwResult == NERR_Success)
            {
                if (WkstaInfo->WkstaInfo502->wki502_max_cmds >= 50 && WkstaInfo->WkstaInfo502->wki502_max_cmds <= 65535)
                {
                    WkstaInfo502.wki502_max_cmds = WkstaInfo->WkstaInfo502->wki502_max_cmds;
                }
                else
                {
                    dwErrParam = WKSTA_MAXCMDS_PARMNUM;
                    dwResult = ERROR_INVALID_PARAMETER;
                }
            }
 
            if (dwResult == NERR_Success)
            {
                if (WkstaInfo->WkstaInfo502->wki502_sess_timeout >= 60 && WkstaInfo->WkstaInfo502->wki502_sess_timeout <= 65535)
                {
                    WkstaInfo502.wki502_sess_timeout = WkstaInfo->WkstaInfo502->wki502_sess_timeout;
                }
                else
                {
                    dwErrParam = WKSTA_SESSTIMEOUT_PARMNUM;
                    dwResult = ERROR_INVALID_PARAMETER;
                }
            }
 
            if (dwResult == NERR_Success)
            {
                if (WkstaInfo->WkstaInfo502->wki502_dormant_file_limit != 0)
                {
                    WkstaInfo502.wki502_dormant_file_limit = WkstaInfo->WkstaInfo502->wki502_dormant_file_limit;
                }
                else
                {
                    dwErrParam = WKSTA_DORMANTFILELIMIT_PARMNUM;
                    dwResult = ERROR_INVALID_PARAMETER;
                }
            }
            break;
 
        case 1013:
            if (WkstaInfo->WkstaInfo1013->wki1013_keep_conn >= 1 && WkstaInfo->WkstaInfo1013->wki1013_keep_conn <= 65535)
            {
                WkstaInfo502.wki502_keep_conn = WkstaInfo->WkstaInfo1013->wki1013_keep_conn;
            }
            else
            {
                dwErrParam = WKSTA_KEEPCONN_PARMNUM;
                dwResult = ERROR_INVALID_PARAMETER;
            }
            break;
 
        case 1018:
            if (WkstaInfo->WkstaInfo1018->wki1018_sess_timeout >= 60 && WkstaInfo->WkstaInfo1018->wki1018_sess_timeout <= 65535)
            {
                WkstaInfo502.wki502_sess_timeout = WkstaInfo->WkstaInfo1018->wki1018_sess_timeout;
            }
            else
            {
                dwErrParam = WKSTA_SESSTIMEOUT_PARMNUM;
                dwResult = ERROR_INVALID_PARAMETER;
            }
            break;
 
        case 1046:
            if (WkstaInfo->WkstaInfo1046->wki1046_dormant_file_limit != 0)
            {
                WkstaInfo502.wki502_dormant_file_limit = WkstaInfo->WkstaInfo1046->wki1046_dormant_file_limit;
            }
            else
            {
                dwErrParam = WKSTA_DORMANTFILELIMIT_PARMNUM;
                dwResult = ERROR_INVALID_PARAMETER;
            }
            break;
 
        default:
            ERR("Invalid Level %lu\n", Level);
            dwResult = ERROR_INVALID_LEVEL;
            break;
    }
 
    /* Save the workstation in the registry */
    if (dwResult == NERR_Success)
    {
        SaveWorkstationInfo(Level);
 
        /* FIXME: Notify the redirector */
    }
 
    if ((dwResult == ERROR_INVALID_PARAMETER) && (ErrorParameter != NULL))
        *ErrorParameter = dwErrParam;
 
    return dwResult;
}
 
 
/* Function 2 */
unsigned long
__stdcall
NetrWkstaUserEnum(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    LPWKSTA_USER_ENUM_STRUCT UserInfo,
    unsigned long PreferredMaximumLength,
    unsigned long *TotalEntries,
    unsigned long *ResumeHandle)
{
    MSV1_0_ENUMUSERS_REQUEST EnumRequest;
    PMSV1_0_ENUMUSERS_RESPONSE EnumResponseBuffer = NULL;
    MSV1_0_GETUSERINFO_REQUEST UserInfoRequest;
    PMSV1_0_GETUSERINFO_RESPONSE UserInfoResponseBuffer = NULL;
    PMSV1_0_GETUSERINFO_RESPONSE *UserInfoArray = NULL;
    DWORD EnumResponseBufferSize = 0;
    DWORD UserInfoResponseBufferSize = 0;
    NTSTATUS Status, ProtocolStatus;
    ULONG i, start, count;
    PLUID pLogonId;
    PULONG pEnumHandle;
    DWORD dwResult = NERR_Success;
 
    PWKSTA_USER_INFO_0 pUserInfo0 = NULL;
    PWKSTA_USER_INFO_1 pUserInfo1 = NULL;
 
    TRACE("NetrWkstaUserEnum(%p %p 0x%lx %p %p)\n",
          ServerName, UserInfo, PreferredMaximumLength, TotalEntries, ResumeHandle);
 
    if (UserInfo->Level > 1)
    {
        ERR("Invalid Level %lu\n", UserInfo->Level);
        return ERROR_INVALID_LEVEL;
    }
 
    /* Enumerate all currently logged-on users */
    EnumRequest.MessageType = MsV1_0EnumerateUsers;
    Status = LsaCallAuthenticationPackage(LsaHandle,
                                          LsaAuthenticationPackage,
                                          &EnumRequest,
                                          sizeof(EnumRequest),
                                          (PVOID*)&EnumResponseBuffer,
                                          &EnumResponseBufferSize,
                                          &ProtocolStatus);
 
    TRACE("LsaCallAuthenticationPackage Status 0x%08lx ResponseBufferSize %lu\n", Status, EnumResponseBufferSize);
    if (!NT_SUCCESS(Status))
    {
        dwResult = RtlNtStatusToDosError(Status);
        goto done;
    }
 
    TRACE("LoggedOnUsers: %lu\n", EnumResponseBuffer->NumberOfLoggedOnUsers);
    TRACE("ResponseBuffer: 0x%p\n", EnumResponseBuffer);
    TRACE("LogonIds: 0x%p\n", EnumResponseBuffer->LogonIds);
    TRACE("EnumHandles: 0x%p\n", EnumResponseBuffer->EnumHandles);
    if (EnumResponseBuffer->NumberOfLoggedOnUsers > 0)
    {
        pLogonId = EnumResponseBuffer->LogonIds;
        pEnumHandle = EnumResponseBuffer->EnumHandles;
        TRACE("pLogonId: 0x%p\n", pLogonId);
        TRACE("pEnumHandle: 0x%p\n", pEnumHandle);
 
        UserInfoArray = RtlAllocateHeap(RtlGetProcessHeap(),
                                        HEAP_ZERO_MEMORY,
                                        EnumResponseBuffer->NumberOfLoggedOnUsers * sizeof(PMSV1_0_GETUSERINFO_RESPONSE));
        if (UserInfoArray == NULL)
        {
            dwResult = ERROR_NOT_ENOUGH_MEMORY;
            goto done;
        }
 
        for (i = 0; i < EnumResponseBuffer->NumberOfLoggedOnUsers; i++)
        {
            TRACE("Logon %lu: 0x%08lx  %lu\n", i, pLogonId->LowPart, *pEnumHandle);
 
            UserInfoRequest.MessageType = MsV1_0GetUserInfo;
            UserInfoRequest.LogonId = *pLogonId;
            Status = LsaCallAuthenticationPackage(LsaHandle,
                                                  LsaAuthenticationPackage,
                                                  &UserInfoRequest,
                                                  sizeof(UserInfoRequest),
                                                  (PVOID*)&UserInfoResponseBuffer,
                                                  &UserInfoResponseBufferSize,
                                                  &ProtocolStatus);
            TRACE("LsaCallAuthenticationPackage:MsV1_0GetUserInfo Status 0x%08lx ResponseBufferSize %lu\n", Status, UserInfoResponseBufferSize);
            if (!NT_SUCCESS(Status))
            {
                dwResult = RtlNtStatusToDosError(Status);
                goto done;
            }
 
            UserInfoArray[i] = UserInfoResponseBuffer;
 
            TRACE("UserName: %wZ\n", &UserInfoArray[i]->UserName);
            TRACE("LogonDomain: %wZ\n", &UserInfoArray[i]->LogonDomainName);
            TRACE("LogonServer: %wZ\n", &UserInfoArray[i]->LogonServer);
 
            pLogonId++;
            pEnumHandle++;
        }
 
        if (PreferredMaximumLength == MAX_PREFERRED_LENGTH)
        {
            start = 0;
            count = EnumResponseBuffer->NumberOfLoggedOnUsers;
        }
        else
        {
            FIXME("Calculate the start index and the number of matching array entries!");
            dwResult = ERROR_CALL_NOT_IMPLEMENTED;
            goto done;
        }
 
        switch (UserInfo->Level)
        {
            case 0:
                pUserInfo0 = midl_user_allocate(count * sizeof(WKSTA_USER_INFO_0));
                if (pUserInfo0 == NULL)
                {
                    ERR("\n");
                    dwResult = ERROR_NOT_ENOUGH_MEMORY;
                    break;
                }
 
                ZeroMemory(pUserInfo0, count * sizeof(WKSTA_USER_INFO_0));
 
                for (i = 0; i < 0 + count; i++) 
                {
                    pUserInfo0[i].wkui0_username = midl_user_allocate(UserInfoArray[start + i]->UserName.Length + sizeof(WCHAR));
                    if (pUserInfo0[i].wkui0_username == NULL)
                    {
                        ERR("\n");
                        dwResult = ERROR_NOT_ENOUGH_MEMORY;
                        break;
                    }
 
                    ZeroMemory(pUserInfo0[i].wkui0_username, UserInfoArray[start + i]->UserName.Length + sizeof(WCHAR));
                    CopyMemory(pUserInfo0[i].wkui0_username, UserInfoArray[start + i]->UserName.Buffer, UserInfoArray[start + i]->UserName.Length);
                }
 
                UserInfo->WkstaUserInfo.Level0.EntriesRead = count;
                UserInfo->WkstaUserInfo.Level0.Buffer = pUserInfo0;
                *TotalEntries = EnumResponseBuffer->NumberOfLoggedOnUsers;
                *ResumeHandle = 0;
                break;
 
            case 1:
                pUserInfo1 = midl_user_allocate(count * sizeof(WKSTA_USER_INFO_1));
                if (pUserInfo1 == NULL)
                {
                    ERR("\n");
                    dwResult = ERROR_NOT_ENOUGH_MEMORY;
                    break;
                }
 
                ZeroMemory(pUserInfo1, count * sizeof(WKSTA_USER_INFO_1));
 
                for (i = 0; i < 0 + count; i++) 
                {
                    pUserInfo1[i].wkui1_username = midl_user_allocate(UserInfoArray[start + i]->UserName.Length + sizeof(WCHAR));
                    if (pUserInfo1[i].wkui1_username == NULL)
                    {
                        ERR("\n");
                        dwResult = ERROR_NOT_ENOUGH_MEMORY;
                        break;
                    }
 
                    ZeroMemory(pUserInfo1[i].wkui1_username, UserInfoArray[start + i]->UserName.Length + sizeof(WCHAR));
                    CopyMemory(pUserInfo1[i].wkui1_username, UserInfoArray[start + i]->UserName.Buffer, UserInfoArray[start + i]->UserName.Length);
 
                    pUserInfo1[i].wkui1_logon_domain = midl_user_allocate(UserInfoArray[start + i]->LogonDomainName.Length + sizeof(WCHAR));
                    if (pUserInfo1[i].wkui1_logon_domain == NULL)
                    {
                        ERR("\n");
                        dwResult = ERROR_NOT_ENOUGH_MEMORY;
                        break;
                    }
 
                    ZeroMemory(pUserInfo1[i].wkui1_logon_domain, UserInfoArray[start + i]->LogonDomainName.Length + sizeof(WCHAR));
                    CopyMemory(pUserInfo1[i].wkui1_logon_domain, UserInfoArray[start + i]->LogonDomainName.Buffer, UserInfoArray[start + i]->LogonDomainName.Length);
 
                    // FIXME: wkui1_oth_domains
 
                    pUserInfo1[i].wkui1_logon_server = midl_user_allocate(UserInfoArray[start + i]->LogonServer.Length + sizeof(WCHAR));
                    if (pUserInfo1[i].wkui1_logon_server == NULL)
                    {
                        ERR("\n");
                        dwResult = ERROR_NOT_ENOUGH_MEMORY;
                        break;
                    }
 
                    ZeroMemory(pUserInfo1[i].wkui1_logon_server, UserInfoArray[start + i]->LogonServer.Length + sizeof(WCHAR));
                    CopyMemory(pUserInfo1[i].wkui1_logon_server, UserInfoArray[start + i]->LogonServer.Buffer, UserInfoArray[start + i]->LogonServer.Length);
                }
 
                UserInfo->WkstaUserInfo.Level1.EntriesRead = count;
                UserInfo->WkstaUserInfo.Level1.Buffer = pUserInfo1;
                *TotalEntries = EnumResponseBuffer->NumberOfLoggedOnUsers;
                *ResumeHandle = 0;
                break;
 
                break;
        }
    }
    else
    {
        if (UserInfo->Level == 0)
        {
            UserInfo->WkstaUserInfo.Level0.Buffer = NULL;
            UserInfo->WkstaUserInfo.Level0.EntriesRead = 0;
        }
        else
        {
            UserInfo->WkstaUserInfo.Level1.Buffer = NULL;
            UserInfo->WkstaUserInfo.Level1.EntriesRead = 0;
        }
 
        *TotalEntries = 0;
        dwResult = NERR_Success;
    }
 
done:
    if (UserInfoArray !=NULL)
    {
 
        for (i = 0; i < EnumResponseBuffer->NumberOfLoggedOnUsers; i++)
        {
            if (UserInfoArray[i]->UserName.Buffer != NULL)
                LsaFreeReturnBuffer(UserInfoArray[i]->UserName.Buffer);
 
            if (UserInfoArray[i]->LogonDomainName.Buffer != NULL)
                LsaFreeReturnBuffer(UserInfoArray[i]->LogonDomainName.Buffer);
 
            if (UserInfoArray[i]->LogonServer.Buffer != NULL)
                LsaFreeReturnBuffer(UserInfoArray[i]->LogonServer.Buffer);
 
            LsaFreeReturnBuffer(UserInfoArray[i]);
        }
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, UserInfoArray);
    }
 
    if (EnumResponseBuffer != NULL)
        LsaFreeReturnBuffer(EnumResponseBuffer);
 
    return dwResult;
}
 
 
/* Function 3 */
unsigned long
__stdcall
NetrWkstaUserGetInfo(
    WKSSVC_IDENTIFY_HANDLE Unused,
    unsigned long Level,
    LPWKSTA_USER_INFO UserInfo)
{
    MSV1_0_GETUSERINFO_REQUEST UserInfoRequest;
    PMSV1_0_GETUSERINFO_RESPONSE UserInfoResponseBuffer = NULL;
    DWORD UserInfoResponseBufferSize = 0;
    NTSTATUS Status, ProtocolStatus;
    LUID LogonId;
    PWKSTA_USER_INFO_0 pUserInfo0 = NULL;
    PWKSTA_USER_INFO_1 pUserInfo1 = NULL;
    PWKSTA_USER_INFO_1101 pUserInfo1101 = NULL;
    DWORD dwResult = NERR_Success;
 
    TRACE("NetrWkstaUserGetInfo(%s, %d, %p)\n", debugstr_w(Unused), Level, UserInfo);
 
    if (Unused != NULL)
        return ERROR_INVALID_PARAMETER;
 
    if (Level > 1 && Level != 1101)
        return ERROR_INVALID_LEVEL;
 
    if (Level != 1101)
    {
        dwResult = NetpGetClientLogonId(&LogonId);
        if (dwResult != NERR_Success)
        {
            ERR("NetpGetClientLogonId() failed (%u)\n", dwResult);
            return dwResult;
        }
 
        TRACE("LogonId: 0x%08lx\n", LogonId.LowPart);
 
        UserInfoRequest.MessageType = MsV1_0GetUserInfo;
        UserInfoRequest.LogonId = LogonId;
        Status = LsaCallAuthenticationPackage(LsaHandle,
                                              LsaAuthenticationPackage,
                                              &UserInfoRequest,
                                              sizeof(UserInfoRequest),
                                              (PVOID*)&UserInfoResponseBuffer,
                                              &UserInfoResponseBufferSize,
                                              &ProtocolStatus);
        TRACE("LsaCallAuthenticationPackage:MsV1_0GetUserInfo Status 0x%08lx ResponseBufferSize %lu\n", Status, UserInfoResponseBufferSize);
        if (!NT_SUCCESS(Status))
        {
            ERR("\n");
            return RtlNtStatusToDosError(Status);
        }
 
        TRACE("UserName: %wZ\n", &UserInfoResponseBuffer->UserName);
        TRACE("LogonDomain: %wZ\n", &UserInfoResponseBuffer->LogonDomainName);
        TRACE("LogonServer: %wZ\n", &UserInfoResponseBuffer->LogonServer);
    }
 
    switch (Level)
    {
        case 0:
            pUserInfo0 = midl_user_allocate(sizeof(WKSTA_USER_INFO_0));
            if (pUserInfo0 == NULL)
            {
                ERR("\n");
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo0, sizeof(WKSTA_USER_INFO_0));
 
            /* User Name */
            pUserInfo0->wkui0_username =
                midl_user_allocate(UserInfoResponseBuffer->UserName.Length + sizeof(WCHAR));
            if (pUserInfo0->wkui0_username == NULL)
            {
                ERR("\n");
                midl_user_free(pUserInfo0);
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo0->wkui0_username,
                       UserInfoResponseBuffer->UserName.Length + sizeof(WCHAR));
            CopyMemory(pUserInfo0->wkui0_username,
                       UserInfoResponseBuffer->UserName.Buffer,
                       UserInfoResponseBuffer->UserName.Length);
 
            UserInfo->UserInfo0 = pUserInfo0;
            break;
 
        case 1:
            pUserInfo1 = midl_user_allocate(sizeof(WKSTA_USER_INFO_1));
            if (pUserInfo1 == NULL)
            {
                ERR("\n");
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo1, sizeof(WKSTA_USER_INFO_1));
 
            /* User Name */
            pUserInfo1->wkui1_username =
                midl_user_allocate(UserInfoResponseBuffer->UserName.Length + sizeof(WCHAR));
            if (pUserInfo1->wkui1_username == NULL)
            {
                ERR("\n");
                midl_user_free(pUserInfo1);
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo1->wkui1_username,
                       UserInfoResponseBuffer->UserName.Length + sizeof(WCHAR));
            CopyMemory(pUserInfo1->wkui1_username,
                       UserInfoResponseBuffer->UserName.Buffer,
                       UserInfoResponseBuffer->UserName.Length);
 
            /* Logon Domain Name */
            pUserInfo1->wkui1_logon_domain =
                midl_user_allocate(UserInfoResponseBuffer->LogonDomainName.Length + sizeof(WCHAR));
            if (pUserInfo1->wkui1_logon_domain == NULL)
            {
                ERR("\n");
                midl_user_free(pUserInfo1->wkui1_username);
                midl_user_free(pUserInfo1);
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo1->wkui1_logon_domain,
                       UserInfoResponseBuffer->LogonDomainName.Length + sizeof(WCHAR));
            CopyMemory(pUserInfo1->wkui1_logon_domain,
                       UserInfoResponseBuffer->LogonDomainName.Buffer,
                       UserInfoResponseBuffer->LogonDomainName.Length);
 
            /* FIXME: wkui1_oth_domains */
 
            /* Logon Server */
            pUserInfo1->wkui1_logon_server =
                midl_user_allocate(UserInfoResponseBuffer->LogonServer.Length + sizeof(WCHAR));
            if (pUserInfo1->wkui1_logon_server == NULL)
            {
                ERR("\n");
                midl_user_free(pUserInfo1->wkui1_username);
                midl_user_free(pUserInfo1->wkui1_logon_domain);
                midl_user_free(pUserInfo1);
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo1->wkui1_logon_server,
                       UserInfoResponseBuffer->LogonServer.Length + sizeof(WCHAR));
            CopyMemory(pUserInfo1->wkui1_logon_server,
                       UserInfoResponseBuffer->LogonServer.Buffer,
                       UserInfoResponseBuffer->LogonServer.Length);
 
            UserInfo->UserInfo1 = pUserInfo1;
            break;
 
        case 1101:
            pUserInfo1101 = midl_user_allocate(sizeof(WKSTA_USER_INFO_1101));
            if (pUserInfo1101 == NULL)
            {
                ERR("Failed to allocate WKSTA_USER_INFO_1101\n");
                dwResult = ERROR_NOT_ENOUGH_MEMORY;
                break;
            }
 
            ZeroMemory(pUserInfo1101, sizeof(WKSTA_USER_INFO_1101));
 
            /* FIXME: wkui1101_oth_domains */
 
            UserInfo->UserInfo1101 = pUserInfo1101;
            break;
 
        default:
            ERR("\n");
            dwResult = ERROR_INVALID_LEVEL;
            break;
    }
 
    if (UserInfoResponseBuffer)
        LsaFreeReturnBuffer(UserInfoResponseBuffer);
 
    return dwResult;
}
 
 
/* Function 4 */
unsigned long
__stdcall
NetrWkstaUserSetInfo(
    WKSSVC_IDENTIFY_HANDLE Unused,
    unsigned long Level,
    LPWKSTA_USER_INFO UserInfo,
    unsigned long *ErrorParameter)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 5 */
unsigned long
__stdcall
NetrWkstaTransportEnum(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    LPWKSTA_TRANSPORT_ENUM_STRUCT TransportInfo,
    unsigned long PreferredMaximumLength,
    unsigned long* TotalEntries,
    unsigned long *ResumeHandle)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 6 */
unsigned long
__stdcall
NetrWkstaTransportAdd(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    unsigned long Level,
    LPWKSTA_TRANSPORT_INFO_0 TransportInfo,
    unsigned long *ErrorParameter)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 7 */
unsigned long
__stdcall
NetrWkstaTransportDel(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    wchar_t *TransportName,
    unsigned long ForceLevel)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 8 */
unsigned long
__stdcall
NetrUseAdd(
    WKSSVC_IMPERSONATE_HANDLE ServerName,
    unsigned long Level,
    LPUSE_INFO InfoStruct,
    unsigned long *ErrorParameter)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 9 */
unsigned long
__stdcall
NetrUseGetInfo(
    WKSSVC_IMPERSONATE_HANDLE ServerName,
    wchar_t *UseName,
    unsigned long Level,
    LPUSE_INFO InfoStruct)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 10 */
unsigned long
__stdcall
NetrUseDel(
    WKSSVC_IMPERSONATE_HANDLE ServerName,
    wchar_t *UseName,
    unsigned long ForceLevel)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 11 */
unsigned long
__stdcall
NetrUseEnum(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    LPUSE_ENUM_STRUCT InfoStruct,
    unsigned long PreferredMaximumLength,
    unsigned long *TotalEntries,
    unsigned long *ResumeHandle)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 12 - Not used on wire */
unsigned long
__stdcall
NetrMessageBufferSend(void)
{
    TRACE("NetrMessageBufferSend()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 13 */
unsigned long
__stdcall
NetrWorkstationStatisticsGet(
    WKSSVC_IDENTIFY_HANDLE ServerName,
    wchar_t *ServiceName,
    unsigned long Level,
    unsigned long Options,
    LPSTAT_WORKSTATION_0 *Buffer)
{
    SYSTEM_TIMEOFDAY_INFORMATION TimeOfDayInfo;
    PSTAT_WORKSTATION_0 pStatBuffer = NULL;
    NTSTATUS Status;
 
    TRACE("NetrWorkstationStatisticsGet(%p %p %lu 0x%lx %p)\n",
          ServerName, ServiceName, Level, Options, Buffer);
 
    if (Level != 0)
        return ERROR_INVALID_LEVEL;
 
    if (Options != 0)
        return ERROR_INVALID_PARAMETER;
 
    pStatBuffer = midl_user_allocate(sizeof(STAT_WORKSTATION_0));
    if (pStatBuffer == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    ZeroMemory(pStatBuffer, sizeof(STAT_WORKSTATION_0));
 
    /* Query the boot time */
    Status = NtQuerySystemInformation(SystemTimeOfDayInformation,
                                      &TimeOfDayInfo,
                                      sizeof(TimeOfDayInfo),
                                      NULL);
    if (NT_SUCCESS(Status))
    {
        ULONG Seconds = 0;
        if (RtlTimeToSecondsSince1970(&TimeOfDayInfo.BootTime, &Seconds))
        {
            pStatBuffer->StatisticsStartTime.u.HighPart = 0;
            pStatBuffer->StatisticsStartTime.u.LowPart = Seconds;
        }
    }
 
    // FIXME: Return the actual statistcs data!
 
    *Buffer = pStatBuffer;
 
    return NERR_Success;
}
 
 
/* Function 14 - Not used on wire */
unsigned long
__stdcall
NetrLogonDomainNameAdd(
    WKSSVC_IDENTIFY_HANDLE DomainName)
{
    TRACE("NetrLogonDomainNameAdd(%s)\n",
          debugstr_w(DomainName));
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 15 - Not used on wire */
unsigned long
__stdcall
NetrLogonDomainNameDel(
    WKSSVC_IDENTIFY_HANDLE DomainName)
{
    TRACE("NetrLogonDomainNameDel(%s)\n",
          debugstr_w(DomainName));
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 16 - Not used on wire */
unsigned long
__stdcall
NetrJoinDomain(void)
{
    TRACE("NetrJoinDomain()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 17 - Not used on wire */
unsigned long
__stdcall
NetrUnjoinDomain(void)
{
    TRACE("NetrUnjoinDomain()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 18 - Not used on wire */
unsigned long
__stdcall
NetrValidateName(void)
{
    TRACE("NetrValidateName()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 19 - Not used on wire */
unsigned long
__stdcall
NetrRenameMachineInDomain(void)
{
    TRACE("NetrRenameMachineInDomain()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 20 */
unsigned long
__stdcall
NetrGetJoinInformation(
    WKSSVC_IMPERSONATE_HANDLE ServerName,
    wchar_t **NameBuffer,
    PNETSETUP_JOIN_STATUS BufferType)
{
    TRACE("NetrGetJoinInformation(%p %p %p)\n",
          ServerName, NameBuffer, BufferType);
 
    if (NameBuffer == NULL)
        return ERROR_INVALID_PARAMETER;
 
    return NetpGetJoinInformation(NameBuffer,
                                  BufferType);
}
 
 
/* Function 21 - Not used on wire */
unsigned long
__stdcall
NetrGetJoinableOUs(void)
{
    TRACE("NetrGetJoinableOUs()\n");
    return ERROR_NOT_SUPPORTED;
}
 
 
/* Function 22 */
unsigned long
__stdcall
NetrJoinDomain2(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *DomainNameParam,
    wchar_t *MachineAccountOU,
    wchar_t *AccountName,
    PJOINPR_ENCRYPTED_USER_PASSWORD Password,
    unsigned long Options)
{
    NET_API_STATUS status;
 
    FIXME("NetrJoinDomain2(%p %S %S %S %S %p 0x%lx)\n",
          RpcBindingHandle, ServerName, DomainNameParam, MachineAccountOU,
          AccountName, Password, Options);
 
    if (DomainNameParam == NULL)
        return ERROR_INVALID_PARAMETER;
 
    if (Options & NETSETUP_JOIN_DOMAIN)
    {
        FIXME("NetrJoinDomain2: NETSETUP_JOIN_DOMAIN is not supported yet!\n");
        status = ERROR_CALL_NOT_IMPLEMENTED;
    }
    else
    {
        status = NetpJoinWorkgroup(DomainNameParam);
    }
 
    return status;
}
 
 
/* Function 23 */
unsigned long
__stdcall
NetrUnjoinDomain2(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *AccountName,
    PJOINPR_ENCRYPTED_USER_PASSWORD Password,
    unsigned long Options)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 24 */
unsigned long
__stdcall
NetrRenameMachineInDomain2(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *MachineName,
    wchar_t *AccountName,
    PJOINPR_ENCRYPTED_USER_PASSWORD Password,
    unsigned long Options)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 25 */
unsigned long
__stdcall
NetrValidateName2(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *NameToValidate,
    wchar_t *AccountName,
    PJOINPR_ENCRYPTED_USER_PASSWORD Password,
    NETSETUP_NAME_TYPE NameType)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 26 */
unsigned long
__stdcall
NetrGetJoinableOUs2(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *DomainNameParam,
    wchar_t *AccountName,
    PJOINPR_ENCRYPTED_USER_PASSWORD Password,
    unsigned long* OUCount,
    wchar_t ***OUs)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 27 */
unsigned long
__stdcall
NetrAddAlternateComputerName(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *AlternateName,
    wchar_t *DomainAccount,
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword,
    unsigned long Reserved)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 28 */
unsigned long
__stdcall
NetrRemoveAlternateComputerName(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *AlternateName,
    wchar_t *DomainAccount,
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword,
    unsigned long Reserved)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 29 */
unsigned long
__stdcall
NetrSetPrimaryComputerName(
    handle_t RpcBindingHandle,
    wchar_t *ServerName,
    wchar_t *PrimaryName,
    wchar_t *DomainAccount,
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword,
    unsigned long Reserved)
{
    UNIMPLEMENTED;
    return 0;
}
 
 
/* Function 30 */
unsigned long
__stdcall
NetrEnumerateComputerNames(
    WKSSVC_IMPERSONATE_HANDLE ServerName,
    NET_COMPUTER_NAME_TYPE NameType,
    unsigned long Reserved,
    PNET_COMPUTER_NAME_ARRAY *ComputerNames)
{
    UNIMPLEMENTED;
    return 0;
}
 
/* EOF */