365 lines
11 KiB
C
365 lines
11 KiB
C
/*
|
|
* Copyright 2002 Andriy Palamarchuk
|
|
*
|
|
* netapi32 user functions
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "nb30.h"
|
|
#include "lmcons.h"
|
|
#include "lmapibuf.h"
|
|
#include "lmerr.h"
|
|
#include "lmwksta.h"
|
|
#include "iphlpapi.h"
|
|
#include "winerror.h"
|
|
#include "ntstatus.h"
|
|
#include "winreg.h"
|
|
#include "winternl.h"
|
|
#include "ntsecapi.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
|
|
|
|
/************************************************************
|
|
* NETAPI_IsLocalComputer
|
|
*
|
|
* Checks whether the server name indicates local machine.
|
|
*/
|
|
BOOL NETAPI_IsLocalComputer(LPCWSTR ServerName)
|
|
{
|
|
if (!ServerName)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
|
|
BOOL Result;
|
|
LPWSTR buf;
|
|
|
|
NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) &buf);
|
|
Result = GetComputerNameW(buf, &dwSize);
|
|
if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
|
|
ServerName += 2;
|
|
Result = Result && !lstrcmpW(ServerName, buf);
|
|
NetApiBufferFree(buf);
|
|
|
|
return Result;
|
|
}
|
|
}
|
|
|
|
static void wprint_mac(WCHAR* buffer, PIP_ADAPTER_INFO adapter)
|
|
{
|
|
if (adapter != NULL)
|
|
{
|
|
int i;
|
|
unsigned char val;
|
|
|
|
for (i = 0; i<max(adapter->AddressLength, 6); i++)
|
|
{
|
|
val = adapter->Address[i];
|
|
if ((val >>4) >9)
|
|
buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
|
|
else
|
|
buffer[2*i] = (WCHAR)((val >>4) + '0');
|
|
if ((val & 0xf ) >9)
|
|
buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
|
|
else
|
|
buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
|
|
}
|
|
buffer[12]=(WCHAR)0;
|
|
}
|
|
else
|
|
buffer[0] = 0;
|
|
}
|
|
|
|
#define TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
|
|
#define TRANSPORT_NAME_LEN \
|
|
(sizeof(TRANSPORT_NAME_HEADER) + MAX_ADAPTER_NAME_LENGTH)
|
|
|
|
static void wprint_name(WCHAR *buffer, int len, PIP_ADAPTER_INFO adapter)
|
|
{
|
|
WCHAR *ptr;
|
|
const char *name;
|
|
|
|
if (!buffer)
|
|
return;
|
|
if (!adapter)
|
|
return;
|
|
|
|
for (ptr = buffer, name = TRANSPORT_NAME_HEADER; *name && ptr < buffer + len;
|
|
ptr++, name++)
|
|
*ptr = *name;
|
|
for (name = adapter->AdapterName; name && *name && ptr < buffer + len;
|
|
ptr++, name++)
|
|
*ptr = *name;
|
|
*ptr = '\0';
|
|
}
|
|
|
|
NET_API_STATUS WINAPI
|
|
NetWkstaTransportEnum(LPCWSTR ServerName, DWORD level, LPBYTE* pbuf,
|
|
DWORD prefmaxlen, LPDWORD read_entries,
|
|
LPDWORD total_entries, LPDWORD hresume)
|
|
{
|
|
FIXME(":%s, 0x%08lx, %p, 0x%08lx, %p, %p, %p\n", debugstr_w(ServerName),
|
|
level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
|
|
if (!NETAPI_IsLocalComputer(ServerName))
|
|
{
|
|
FIXME(":not implemented for non-local computers\n");
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
else
|
|
{
|
|
if (hresume && *hresume)
|
|
{
|
|
FIXME(":resume handle not implemented\n");
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
|
|
switch (level)
|
|
{
|
|
case 0: /* transport info */
|
|
{
|
|
PWKSTA_TRANSPORT_INFO_0 ti;
|
|
int i,size_needed,n_adapt;
|
|
DWORD apiReturn, adaptInfoSize = 0;
|
|
PIP_ADAPTER_INFO info, ptr;
|
|
|
|
apiReturn = GetAdaptersInfo(NULL, &adaptInfoSize);
|
|
if (apiReturn == ERROR_NO_DATA)
|
|
return ERROR_NETWORK_UNREACHABLE;
|
|
if (!read_entries)
|
|
return STATUS_ACCESS_VIOLATION;
|
|
if (!total_entries || !pbuf)
|
|
return RPC_X_NULL_REF_POINTER;
|
|
|
|
info = (PIP_ADAPTER_INFO)malloc(adaptInfoSize);
|
|
apiReturn = GetAdaptersInfo(info, &adaptInfoSize);
|
|
if (apiReturn != NO_ERROR)
|
|
{
|
|
free(info);
|
|
return apiReturn;
|
|
}
|
|
|
|
for (n_adapt = 0, ptr = info; ptr; ptr = ptr->Next)
|
|
n_adapt++;
|
|
size_needed = n_adapt * sizeof(WKSTA_TRANSPORT_INFO_0)
|
|
+ n_adapt * TRANSPORT_NAME_LEN * sizeof (WCHAR)
|
|
+ n_adapt * 13 * sizeof (WCHAR);
|
|
if (prefmaxlen == MAX_PREFERRED_LENGTH)
|
|
NetApiBufferAllocate( size_needed, (LPVOID *) pbuf);
|
|
else
|
|
{
|
|
if (size_needed > prefmaxlen)
|
|
{
|
|
free(info);
|
|
return ERROR_MORE_DATA;
|
|
}
|
|
NetApiBufferAllocate(prefmaxlen,
|
|
(LPVOID *) pbuf);
|
|
}
|
|
for (i = 0, ptr = info; ptr; ptr = ptr->Next, i++)
|
|
{
|
|
ti = (PWKSTA_TRANSPORT_INFO_0)
|
|
((PBYTE) *pbuf + i * sizeof(WKSTA_TRANSPORT_INFO_0));
|
|
ti->wkti0_quality_of_service=0;
|
|
ti->wkti0_number_of_vcs=0;
|
|
ti->wkti0_transport_name= (LPWSTR)
|
|
((PBYTE )*pbuf +
|
|
n_adapt * sizeof(WKSTA_TRANSPORT_INFO_0)
|
|
+ i * TRANSPORT_NAME_LEN * sizeof (WCHAR));
|
|
wprint_name(ti->wkti0_transport_name,TRANSPORT_NAME_LEN, ptr);
|
|
ti->wkti0_transport_address= (LPWSTR)
|
|
((PBYTE )*pbuf +
|
|
n_adapt * sizeof(WKSTA_TRANSPORT_INFO_0) +
|
|
n_adapt * TRANSPORT_NAME_LEN * sizeof (WCHAR)
|
|
+ i * 13 * sizeof (WCHAR));
|
|
ti->wkti0_wan_ish=TRUE; /*TCPIP/NETBIOS Protocoll*/
|
|
wprint_mac(ti->wkti0_transport_address, ptr);
|
|
TRACE("%d of %d:ti at %p transport_address at %p %s\n",i,n_adapt,
|
|
ti, ti->wkti0_transport_address, debugstr_w(ti->wkti0_transport_address));
|
|
}
|
|
*read_entries = n_adapt;
|
|
*total_entries = n_adapt;
|
|
free(info);
|
|
if(hresume) *hresume= 0;
|
|
break;
|
|
}
|
|
default:
|
|
ERR("Invalid level %ld is specified\n", level);
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
return NERR_Success;
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************************
|
|
* NetWkstaUserGetInfo (NETAPI32.@)
|
|
*/
|
|
NET_API_STATUS WINAPI NetWkstaUserGetInfo(LPWSTR reserved, DWORD level,
|
|
PBYTE* bufptr)
|
|
{
|
|
TRACE("(%s, %ld, %p)\n", debugstr_w(reserved), level, bufptr);
|
|
switch (level)
|
|
{
|
|
case 0:
|
|
{
|
|
PWKSTA_USER_INFO_0 ui;
|
|
DWORD dwSize = UNLEN + 1;
|
|
|
|
/* set up buffer */
|
|
NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
|
|
(LPVOID *) bufptr);
|
|
|
|
ui = (PWKSTA_USER_INFO_0) *bufptr;
|
|
ui->wkui0_username = (LPWSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
|
|
|
|
/* get data */
|
|
if (!GetUserNameW(ui->wkui0_username, &dwSize))
|
|
{
|
|
NetApiBufferFree(ui);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
else
|
|
NetApiBufferReallocate(
|
|
*bufptr, sizeof(WKSTA_USER_INFO_0) +
|
|
(lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
|
|
(LPVOID *) bufptr);
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
PWKSTA_USER_INFO_1 ui;
|
|
PWKSTA_USER_INFO_0 ui0;
|
|
DWORD dwSize;
|
|
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
|
|
LSA_HANDLE PolicyHandle;
|
|
PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
|
|
NTSTATUS NtStatus;
|
|
|
|
/* sizes of the field buffers in WCHARS */
|
|
int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
|
|
|
|
FIXME("Level 1 processing is partially implemented\n");
|
|
oth_domains_sz = 1;
|
|
logon_server_sz = 1;
|
|
|
|
/* get some information first to estimate size of the buffer */
|
|
ui0 = NULL;
|
|
NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
|
|
username_sz = lstrlenW(ui0->wkui0_username) + 1;
|
|
|
|
ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
|
|
NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
|
|
POLICY_VIEW_LOCAL_INFORMATION,
|
|
&PolicyHandle);
|
|
if (NtStatus != STATUS_SUCCESS)
|
|
{
|
|
ERR("LsaOpenPolicyFailed with NT status %lx\n",
|
|
LsaNtStatusToWinError(NtStatus));
|
|
NetApiBufferFree(ui0);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
|
|
(PVOID*) &DomainInfo);
|
|
logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
|
|
LsaClose(PolicyHandle);
|
|
|
|
/* set up buffer */
|
|
NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
|
|
(username_sz + logon_domain_sz +
|
|
oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
|
|
(LPVOID *) bufptr);
|
|
ui = (WKSTA_USER_INFO_1 *) *bufptr;
|
|
ui->wkui1_username = (LPWSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
|
|
ui->wkui1_logon_domain = (LPWSTR) (
|
|
((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
|
|
ui->wkui1_oth_domains = (LPWSTR) (
|
|
((PBYTE) ui->wkui1_logon_domain) +
|
|
logon_domain_sz * sizeof(WCHAR));
|
|
ui->wkui1_logon_server = (LPWSTR) (
|
|
((PBYTE) ui->wkui1_oth_domains) +
|
|
oth_domains_sz * sizeof(WCHAR));
|
|
|
|
/* get data */
|
|
dwSize = username_sz;
|
|
lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
|
|
NetApiBufferFree(ui0);
|
|
|
|
lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
|
|
logon_domain_sz);
|
|
LsaFreeMemory(DomainInfo);
|
|
|
|
/* FIXME. Not implemented. Populated with empty strings */
|
|
ui->wkui1_oth_domains[0] = 0;
|
|
ui->wkui1_logon_server[0] = 0;
|
|
break;
|
|
}
|
|
case 1101:
|
|
{
|
|
PWKSTA_USER_INFO_1101 ui;
|
|
DWORD dwSize = 1;
|
|
|
|
FIXME("Stub. Level 1101 processing is not implemented\n");
|
|
/* FIXME see also wkui1_oth_domains for level 1 */
|
|
|
|
/* set up buffer */
|
|
NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
|
|
(LPVOID *) bufptr);
|
|
|
|
ui = (PWKSTA_USER_INFO_1101) *bufptr;
|
|
ui->wkui1101_oth_domains = (LPWSTR)(ui + 1);
|
|
|
|
/* get data */
|
|
ui->wkui1101_oth_domains[0] = 0;
|
|
break;
|
|
}
|
|
default:
|
|
ERR("Invalid level %ld is specified\n", level);
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
return NERR_Success;
|
|
}
|
|
|
|
/************************************************************
|
|
* NetpGetComputerName (NETAPI32.@)
|
|
*/
|
|
NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
|
|
{
|
|
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
|
|
|
|
TRACE("(%p)\n", Buffer);
|
|
NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
|
|
if (GetComputerNameW(*Buffer, &dwSize))
|
|
{
|
|
NetApiBufferReallocate(
|
|
*Buffer, dwSize * sizeof(WCHAR),
|
|
(LPVOID *) Buffer);
|
|
return NERR_Success;
|
|
}
|
|
else
|
|
{
|
|
NetApiBufferFree(*Buffer);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|