wksta_new.c File Reference

#include "netapi32.h"
#include "wkssvc_c.h"

Include dependency graph for wksta_new.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (netapi32)
void __RPC_FAR *__RPC_USER	midl_user_allocate (SIZE_T len)
void __RPC_USER	midl_user_free (void __RPC_FAR *ptr)
handle_t __RPC_USER	WKSSVC_IDENTIFY_HANDLE_bind (WKSSVC_IDENTIFY_HANDLE pszSystemName)
void __RPC_USER	WKSSVC_IDENTIFY_HANDLE_unbind (WKSSVC_IDENTIFY_HANDLE pszSystemName, handle_t hBinding)
handle_t __RPC_USER	WKSSVC_IMPERSONATE_HANDLE_bind (WKSSVC_IMPERSONATE_HANDLE pszSystemName)
void __RPC_USER	WKSSVC_IMPERSONATE_HANDLE_unbind (WKSSVC_IMPERSONATE_HANDLE pszSystemName, handle_t hBinding)
NET_API_STATUS	NetpBind (LPCWSTR pszServerName, handle_t *pBindingHandle)
NET_API_STATUS	NetpUnbind (handle_t BindingHandle)
NET_API_STATUS WINAPI	NetAddAlternateComputerName (_In_opt_ LPCWSTR Server, _In_ LPCWSTR AlternateName, _In_opt_ LPCWSTR DomainAccount, _In_opt_ LPCWSTR DomainAccountPassword, _In_ ULONG Reserved)
NET_API_STATUS WINAPI	NetEnumerateComputerNames (_In_opt_ LPCWSTR Server, _In_ NET_COMPUTER_NAME_TYPE NameType, _In_ ULONG Reserved, _Out_ PDWORD EntryCount, _Out_ LPWSTR **ComputerNames)
NET_API_STATUS WINAPI	NetGetJoinInformation (_In_ LPCWSTR lpServer, _Out_ LPWSTR *lpNameBuffer, _Out_ PNETSETUP_JOIN_STATUS BufferType)
NET_API_STATUS WINAPI	NetGetJoinableOUs (_In_opt_ LPCWSTR lpServer, _In_ LPCWSTR lpDomain, _In_opt_ LPCWSTR lpAccount, _In_opt_ LPCWSTR lpPassword, _Out_ DWORD *OUCount, _Out_ LPWSTR **OUs)
NET_API_STATUS WINAPI	NetJoinDomain (_In_opt_ LPCWSTR lpServer, _In_ LPCWSTR lpDomain, _In_opt_ LPCWSTR lpAccountOU, _In_opt_ LPCWSTR lpAccount, _In_opt_ LPCWSTR lpPassword, _In_ DWORD fJoinOptions)
NET_API_STATUS WINAPI	NetRemoveAlternateComputerName (_In_opt_ LPCWSTR Server, _In_ LPCWSTR AlternateName, _In_opt_ LPCWSTR DomainAccount, _In_opt_ LPCWSTR DomainAccountPassword, _In_ ULONG Reserved)
NET_API_STATUS WINAPI	NetRenameMachineInDomain (_In_opt_ LPCWSTR lpServer, _In_opt_ LPCWSTR lpNewMachineName, _In_opt_ LPCWSTR lpAccount, _In_opt_ LPCWSTR lpPassword, _In_ DWORD fRenameOptions)
NET_API_STATUS WINAPI	NetSetPrimaryComputerName (_In_opt_ LPCWSTR Server, _In_ LPCWSTR PrimaryName, _In_opt_ LPCWSTR DomainAccount, _In_opt_ LPCWSTR DomainAccountPassword, _In_ ULONG Reserved)
NET_API_STATUS WINAPI	NetUnjoinDomain (_In_opt_ LPCWSTR lpServer, _In_opt_ LPCWSTR lpAccount, _In_opt_ LPCWSTR lpPassword, _In_ DWORD fUnjoinOptions)
NET_API_STATUS WINAPI	NetUseAdd (_In_ LMSTR UncServerName, _In_ DWORD Level, _In_ LPBYTE Buf, _Out_ LPDWORD ParmError)
NET_API_STATUS WINAPI	NetUseDel (_In_ LMSTR UncServerName, _In_ LMSTR UseName, _In_ DWORD ForceCond)
NET_API_STATUS WINAPI	NetUseEnum (_In_ LMSTR UncServerName, _In_ DWORD Level, _Out_ LPBYTE *BufPtr, _In_ DWORD PreferedMaximumSize, _Out_ LPDWORD EntriesRead, _Out_ LPDWORD TotalEntries, _Inout_ LPDWORD ResumeHandle)
NET_API_STATUS WINAPI	NetUseGetInfo (_In_ LMSTR UncServerName, _In_ LMSTR UseName, _In_ DWORD Level, _Out_ LPBYTE *BufPtr)
NET_API_STATUS WINAPI	NetValidateName (_In_opt_ LPCWSTR lpServer, _In_ LPCWSTR lpName, _In_opt_ LPCWSTR lpAccount, _In_opt_ LPCWSTR lpPassword, _In_ NETSETUP_NAME_TYPE NameType)
NET_API_STATUS WINAPI	NetWkstaSetInfo (_In_ LPWSTR servername, _In_ DWORD level, _In_ LPBYTE buffer, _Out_ LPDWORD parm_err)
NET_API_STATUS WINAPI	NetWkstaTransportAdd (_In_opt_ LPWSTR servername, _In_ DWORD level, _In_ LPBYTE buf, _Out_ LPDWORD parm_err)
NET_API_STATUS WINAPI	NetWkstaTransportDel (_In_opt_ LPWSTR servername, _In_ LPWSTR transportname, _In_ DWORD ucond)
NET_API_STATUS WINAPI	NetWkstaUserSetInfo (LPWSTR reserved, _In_ DWORD level, _In_ LPBYTE buf, _Out_ LPDWORD parm_err)

Function Documentation

midl_user_allocate()

void __RPC_FAR* __RPC_USER midl_user_allocate

(

SIZE_T

len

)

Definition at line 19 of file wksta_new.c.

{
    return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
}

midl_user_free()

void __RPC_USER midl_user_free

(

void __RPC_FAR *

ptr

)

Definition at line 25 of file wksta_new.c.

{
    HeapFree(GetProcessHeap(), 0, ptr);
}

NetAddAlternateComputerName()

NET_API_STATUS WINAPI NetAddAlternateComputerName	(	_In_opt_ LPCWSTR	Server,
		_In_ LPCWSTR	AlternateName,
		_In_opt_ LPCWSTR	DomainAccount,
		_In_opt_ LPCWSTR	DomainAccountPassword,
		_In_ ULONG	Reserved
	)

Definition at line 207 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetAddAlternateComputerName(%s %s %s %s 0x%lx)\n",
          debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
          debugstr_w(DomainAccountPassword), Reserved);

    /* FIXME */

    status = NetpBind(Server,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrAddAlternateComputerName(BindingHandle,
                                              (PWSTR)Server,
                                              (PWSTR)AlternateName,
                                              (PWSTR)DomainAccount,
                                              EncryptedPassword,
                                              Reserved);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetEnumerateComputerNames()

NET_API_STATUS WINAPI NetEnumerateComputerNames	(	_In_opt_ LPCWSTR	Server,
		_In_ NET_COMPUTER_NAME_TYPE	NameType,
		_In_ ULONG	Reserved,
		_Out_ PDWORD	EntryCount,
		_Out_ LPWSTR **	ComputerNames
	)

Definition at line 255 of file wksta_new.c.

{
    PNET_COMPUTER_NAME_ARRAY ComputerNameArray = NULL;
    ULONG BufferSize, i;
    PWSTR *NameBuffer = NULL, Ptr;
    NET_API_STATUS status;

    TRACE("NetEnumerateComputerNames(%s %lu %lu %p %p)\n",
          debugstr_w(Server), NameType, Reserved, EntryCount, ComputerNames);

    RpcTryExcept
    {
        status = NetrEnumerateComputerNames((PWSTR)Server,
                                            NameType,
                                            Reserved,
                                            &ComputerNameArray);
        if (status == NERR_Success)
        {
            *EntryCount = ComputerNameArray->EntryCount;

            BufferSize = 0;
            for (i = 0; i < ComputerNameArray->EntryCount; i++)
            {
                BufferSize += ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR) + sizeof(PWSTR);
            }

            status = NetApiBufferAllocate(BufferSize, (PVOID*)&NameBuffer);
            if (status == NERR_Success)
            {
                ZeroMemory(NameBuffer, BufferSize);

                Ptr = (PWSTR)((ULONG_PTR)NameBuffer + ComputerNameArray->EntryCount * sizeof(PWSTR));
                for (i = 0; i < ComputerNameArray->EntryCount; i++)
                {
                    NameBuffer[i] = Ptr;
                    CopyMemory(Ptr,
                               ComputerNameArray->ComputerNames[i].Buffer,
                               ComputerNameArray->ComputerNames[i].Length);
                    Ptr = (PWSTR)((ULONG_PTR)Ptr + ComputerNameArray->ComputerNames[i].Length + sizeof(WCHAR));
                }

                *ComputerNames = NameBuffer;
            }
        }
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetGetJoinableOUs()

NET_API_STATUS WINAPI NetGetJoinableOUs	(	_In_opt_ LPCWSTR	lpServer,
		_In_ LPCWSTR	lpDomain,
		_In_opt_ LPCWSTR	lpAccount,
		_In_opt_ LPCWSTR	lpPassword,
		_Out_ DWORD *	OUCount,
		_Out_ LPWSTR **	OUs
	)

Definition at line 348 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetGetJoinableOUs(%s %s %s %s %p %p)\n",
          debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccount),
          debugstr_w(lpPassword), OUCount, OUs);

    /* FIXME */

    status = NetpBind(lpServer,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrGetJoinableOUs2(BindingHandle,
                                     (PWSTR)lpServer,
                                     (PWSTR)lpDomain,
                                     (PWSTR)lpAccount,
                                     EncryptedPassword,
                                     OUCount,
                                     OUs);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetGetJoinInformation()

NET_API_STATUS WINAPI NetGetJoinInformation	(	_In_ LPCWSTR	lpServer,
		_Out_ LPWSTR *	lpNameBuffer,
		_Out_ PNETSETUP_JOIN_STATUS	BufferType
	)

Definition at line 317 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetGetJoinInformation(%s %p %p)\n",
          debugstr_w(lpServer), lpNameBuffer, BufferType);

    if (lpNameBuffer == NULL || BufferType == NULL)
        return ERROR_INVALID_PARAMETER;

    RpcTryExcept
    {
        status = NetrGetJoinInformation((LPWSTR)lpServer,
                                        lpNameBuffer,
                                        BufferType);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

Referenced by AllSysInfo(), and GetComputerNames().

NetJoinDomain()

NET_API_STATUS WINAPI NetJoinDomain	(	_In_opt_ LPCWSTR	lpServer,
		_In_ LPCWSTR	lpDomain,
		_In_opt_ LPCWSTR	lpAccountOU,
		_In_opt_ LPCWSTR	lpAccount,
		_In_opt_ LPCWSTR	lpPassword,
		_In_ DWORD	fJoinOptions
	)

Definition at line 398 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    FIXME("NetJoinDomain(%s %s %s %s 0x%lx)\n",
          debugstr_w(lpServer), debugstr_w(lpDomain), debugstr_w(lpAccountOU),
          debugstr_w(lpAccount), debugstr_w(lpPassword), fJoinOptions);

    /* FIXME */

    status = NetpBind(lpServer,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrJoinDomain2(BindingHandle,
                                 (PWSTR)lpServer,
                                 (PWSTR)lpDomain,
                                 (PWSTR)lpAccountOU,
                                 (PWSTR)lpAccount,
                                 EncryptedPassword,
                                 fJoinOptions);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        RPC_STATUS rpcStatus = RpcExceptionCode();
        FIXME("Exception 0x%lx\n", rpcStatus);
        status = I_RpcMapWin32Status(rpcStatus);
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetpBind()

NET_API_STATUS NetpBind	(	LPCWSTR	pszServerName,
		handle_t *	pBindingHandle
	)

Definition at line 142 of file wksta_new.c.

{
    handle_t hBinding = NULL;
    LPWSTR pszStringBinding;
    RPC_STATUS status;

    FIXME("NetpBind(%S)\n", pszServerName);

    *pBindingHandle = NULL;

    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      (LPWSTR)pszServerName,
                                      L"\\pipe\\wkssvc",
                                      NULL,
                                      &pszStringBinding);
    if (status)
    {
        FIXME("RpcStringBindingCompose returned 0x%x\n", status);
        return NetpNtStatusToApiStatus(status);
    }

    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hBinding);
    if (status)
    {
        FIXME("RpcBindingFromStringBinding returned 0x%x\n", status);
    }

    status = RpcStringFreeW(&pszStringBinding);
    if (status)
    {
        FIXME("RpcStringFree returned 0x%x\n", status);
    }

    *pBindingHandle = hBinding;

    return NetpNtStatusToApiStatus(status);
}

Referenced by NetAddAlternateComputerName(), NetGetJoinableOUs(), NetJoinDomain(), NetRemoveAlternateComputerName(), NetRenameMachineInDomain(), NetSetPrimaryComputerName(), NetUnjoinDomain(), and NetValidateName().

NetpUnbind()

NET_API_STATUS NetpUnbind

(

handle_t

BindingHandle

)

Definition at line 187 of file wksta_new.c.

{
    RPC_STATUS status;

    FIXME("NetpUnbind(%p)\n", BindingHandle);

    status = RpcBindingFree(&hBinding);
    if (status)
    {
        TRACE("RpcBindingFree returned 0x%x\n", status);
        return NetpNtStatusToApiStatus(status);
    }

    return NERR_Success;
}

Referenced by NetAddAlternateComputerName(), NetGetJoinableOUs(), NetJoinDomain(), NetRemoveAlternateComputerName(), NetRenameMachineInDomain(), NetSetPrimaryComputerName(), NetUnjoinDomain(), and NetValidateName().

NetRemoveAlternateComputerName()

NET_API_STATUS WINAPI NetRemoveAlternateComputerName	(	_In_opt_ LPCWSTR	Server,
		_In_ LPCWSTR	AlternateName,
		_In_opt_ LPCWSTR	DomainAccount,
		_In_opt_ LPCWSTR	DomainAccountPassword,
		_In_ ULONG	Reserved
	)

Definition at line 450 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetRemoveAlternateComputerName(%s %s %s %s 0x%lx)\n",
          debugstr_w(Server), debugstr_w(AlternateName), debugstr_w(DomainAccount),
          debugstr_w(DomainAccountPassword), Reserved);

    /* FIXME */

    status = NetpBind(Server,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrRemoveAlternateComputerName(BindingHandle,
                                                 (PWSTR)Server,
                                                 (PWSTR)AlternateName,
                                                 (PWSTR)DomainAccount,
                                                 EncryptedPassword,
                                                 Reserved);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetRenameMachineInDomain()

NET_API_STATUS WINAPI NetRenameMachineInDomain	(	_In_opt_ LPCWSTR	lpServer,
		_In_opt_ LPCWSTR	lpNewMachineName,
		_In_opt_ LPCWSTR	lpAccount,
		_In_opt_ LPCWSTR	lpPassword,
		_In_ DWORD	fRenameOptions
	)

Definition at line 498 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetRenameMachineInDomain(%s %s %s %s 0x%lx)\n",
          debugstr_w(lpServer), debugstr_w(lpNewMachineName), debugstr_w(lpAccount),
          debugstr_w(lpPassword), fRenameOptions);

    /* FIXME */

    status = NetpBind(lpServer,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrRenameMachineInDomain2(BindingHandle,
                                            (PWSTR)lpServer,
                                            (PWSTR)lpNewMachineName,
                                            (PWSTR)lpAccount,
                                            EncryptedPassword,
                                            fRenameOptions);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetSetPrimaryComputerName()

NET_API_STATUS WINAPI NetSetPrimaryComputerName	(	_In_opt_ LPCWSTR	Server,
		_In_ LPCWSTR	PrimaryName,
		_In_opt_ LPCWSTR	DomainAccount,
		_In_opt_ LPCWSTR	DomainAccountPassword,
		_In_ ULONG	Reserved
	)

Definition at line 546 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetSetPrimaryComputerName(%s %s %s %s %lu)\n",
          debugstr_w(Server), debugstr_w(PrimaryName), debugstr_w(DomainAccount),
          debugstr_w(DomainAccountPassword), Reserved);

    /* FIXME */

    status = NetpBind(Server,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrSetPrimaryComputerName(BindingHandle,
                                            (PWSTR)Server,
                                            (PWSTR)PrimaryName,
                                            (PWSTR)DomainAccount,
                                            EncryptedPassword,
                                            Reserved);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetUnjoinDomain()

NET_API_STATUS WINAPI NetUnjoinDomain	(	_In_opt_ LPCWSTR	lpServer,
		_In_opt_ LPCWSTR	lpAccount,
		_In_opt_ LPCWSTR	lpPassword,
		_In_ DWORD	fUnjoinOptions
	)

Definition at line 594 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetUnjoinDomain(%s %s %s %s 0x%lx)\n",
          debugstr_w(lpServer), debugstr_w(lpAccount),
          debugstr_w(lpPassword), fUnjoinOptions);

    /* FIXME */

    status = NetpBind(lpServer,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrUnjoinDomain2(BindingHandle,
                                   (PWSTR)lpServer,
                                   (PWSTR)lpAccount,
                                   EncryptedPassword,
                                   fUnjoinOptions);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetUseAdd()

NET_API_STATUS WINAPI NetUseAdd	(	_In_ LMSTR	UncServerName,
		_In_ DWORD	Level,
		_In_ LPBYTE	Buf,
		_Out_ LPDWORD	ParmError
	)

Definition at line 640 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetUseAdd(%s %d %p %p)\n", debugstr_w(UncServerName),
          Level, Buf, ParmError);

    RpcTryExcept
    {
        status = NetrUseAdd(UncServerName,
                            Level,
                            (LPUSE_INFO)Buf,
                            ParmError);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetUseDel()

NET_API_STATUS WINAPI NetUseDel	(	_In_ LMSTR	UncServerName,
		_In_ LMSTR	UseName,
		_In_ DWORD	ForceCond
	)

Definition at line 670 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetUseDel(%s %s %d)\n", debugstr_w(UncServerName),
          debugstr_w(UseName), ForceCond);

    RpcTryExcept
    {
        status = NetrUseDel(UncServerName,
                            UseName,
                            ForceCond);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetUseEnum()

NET_API_STATUS WINAPI NetUseEnum	(	_In_ LMSTR	UncServerName,
		_In_ DWORD	Level,
		_Out_ LPBYTE *	BufPtr,
		_In_ DWORD	PreferedMaximumSize,
		_Out_ LPDWORD	EntriesRead,
		_Out_ LPDWORD	TotalEntries,
		_Inout_ LPDWORD	ResumeHandle
	)

Definition at line 698 of file wksta_new.c.

{
    USE_ENUM_STRUCT UseEnumInfo;
    USE_INFO_0_CONTAINER Container0;
    USE_INFO_1_CONTAINER Container1;
    USE_INFO_2_CONTAINER Container2;
    NET_API_STATUS status;

    TRACE("NetUseEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(UncServerName),
          Level, BufPtr, PreferedMaximumSize, EntriesRead, TotalEntries, ResumeHandle);

    UseEnumInfo.Level = Level;
    switch (Level)
    {
        case 0:
            UseEnumInfo.UseInfo.Level0 = &Container0;
            Container0.EntriesRead = 0;
            Container0.Buffer = NULL;
            break;

        case 1:
            UseEnumInfo.UseInfo.Level1 = &Container1;
            Container1.EntriesRead = 0;
            Container1.Buffer = NULL;
            break;

        case 2:
            UseEnumInfo.UseInfo.Level2 = &Container2;
            Container2.EntriesRead = 0;
            Container2.Buffer = NULL;
            break;

        default:
            return ERROR_INVALID_PARAMETER;
    }

    RpcTryExcept
    {
        status = NetrUseEnum(UncServerName,
                             &UseEnumInfo,
                             PreferedMaximumSize,
                             TotalEntries,
                             ResumeHandle);
        if (status == NERR_Success || status == ERROR_MORE_DATA)
        {
            switch (Level)
            {
                case 0:
                    *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level0->Buffer;
                    *EntriesRead = UseEnumInfo.UseInfo.Level0->EntriesRead;
                    break;

                case 1:
                    *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level1->Buffer;
                    *EntriesRead = UseEnumInfo.UseInfo.Level1->EntriesRead;
                    break;

                case 2:
                    *BufPtr = (LPBYTE)UseEnumInfo.UseInfo.Level2->Buffer;
                    *EntriesRead = UseEnumInfo.UseInfo.Level2->EntriesRead;
                    break;
            }
        }
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetUseGetInfo()

NET_API_STATUS WINAPI NetUseGetInfo	(	_In_ LMSTR	UncServerName,
		_In_ LMSTR	UseName,
		_In_ DWORD	Level,
		_Out_ LPBYTE *	BufPtr
	)

Definition at line 781 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetUseGetInfo(%s, %s, %d, %p)\n", debugstr_w(UncServerName),
          debugstr_w(UseName), Level, BufPtr);

    *BufPtr = NULL;

    RpcTryExcept
    {
        status = NetrUseGetInfo(UncServerName,
                                UseName,
                                Level,
                                (LPUSE_INFO)BufPtr);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetValidateName()

NET_API_STATUS WINAPI NetValidateName	(	_In_opt_ LPCWSTR	lpServer,
		_In_ LPCWSTR	lpName,
		_In_opt_ LPCWSTR	lpAccount,
		_In_opt_ LPCWSTR	lpPassword,
		_In_ NETSETUP_NAME_TYPE	NameType
	)

Definition at line 813 of file wksta_new.c.

{
    PJOINPR_ENCRYPTED_USER_PASSWORD EncryptedPassword = NULL;
    handle_t BindingHandle = NULL;
    NET_API_STATUS status;

    TRACE("NetValidateName(%s %s %s %s %u)\n",
          debugstr_w(lpServer), debugstr_w(lpName), debugstr_w(lpAccount),
          debugstr_w(lpPassword), NameType);

    /* FIXME */

    status = NetpBind(lpServer,
                      &BindingHandle);
    if (status != NERR_Success)
    {
        ERR("NetpBind() failed (status 0x%lx)\n", status);
        return status;
    }

    RpcTryExcept
    {
        status = NetrValidateName2(BindingHandle,
                                   (PWSTR)lpServer,
                                   (PWSTR)lpName,
                                   (PWSTR)lpAccount,
                                   EncryptedPassword,
                                   NameType);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    NetpUnbind(BindingHandle);

    return status;
}

NetWkstaSetInfo()

NET_API_STATUS WINAPI NetWkstaSetInfo	(	_In_ LPWSTR	servername,
		_In_ DWORD	level,
		_In_ LPBYTE	buffer,
		_Out_ LPDWORD	parm_err
	)

Definition at line 896 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
          debugstr_w(servername), level, buffer, parm_err);

    RpcTryExcept
    {
        status = NetrWkstaSetInfo(servername,
                                  level,
                                  (LPWKSTA_INFO)buffer,
                                  parm_err);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetWkstaTransportAdd()

NET_API_STATUS WINAPI NetWkstaTransportAdd	(	_In_opt_ LPWSTR	servername,
		_In_ DWORD	level,
		_In_ LPBYTE	buf,
		_Out_ LPDWORD	parm_err
	)

Definition at line 926 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetWkstaTransportAdd(%s, %d, %p, %p)\n", debugstr_w(servername),
          level, buf, parm_err);

    RpcTryExcept
    {
        status = NetrWkstaTransportAdd(servername,
                                       level,
                                       (LPWKSTA_TRANSPORT_INFO_0)buf,
                                       parm_err);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetWkstaTransportDel()

NET_API_STATUS WINAPI NetWkstaTransportDel	(	_In_opt_ LPWSTR	servername,
		_In_ LPWSTR	transportname,
		_In_ DWORD	ucond
	)

Definition at line 956 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetWkstaTransportDel(%s, %s, %d)\n", debugstr_w(servername),
          debugstr_w(transportname), ucond);

    RpcTryExcept
    {
        status = NetrWkstaTransportDel(servername,
                                       transportname,
                                       ucond);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

NetWkstaUserSetInfo()

NET_API_STATUS WINAPI NetWkstaUserSetInfo	(	LPWSTR	reserved,
		_In_ DWORD	level,
		_In_ LPBYTE	buf,
		_Out_ LPDWORD	parm_err
	)

Definition at line 1149 of file wksta_new.c.

{
    NET_API_STATUS status;

    TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n",
          debugstr_w(reserved), level, buf, parm_err);

    if (reserved != NULL)
        return ERROR_INVALID_PARAMETER;

    RpcTryExcept
    {
       status = NetrWkstaUserSetInfo(NULL,
                                     level,
                                     (LPWKSTA_USER_INFO)&buf,
                                     parm_err);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;

    return status;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

netapi32

)

WKSSVC_IDENTIFY_HANDLE_bind()

handle_t __RPC_USER WKSSVC_IDENTIFY_HANDLE_bind

(

WKSSVC_IDENTIFY_HANDLE

pszSystemName

)

Definition at line 32 of file wksta_new.c.

{
    handle_t hBinding = NULL;
    LPWSTR pszStringBinding;
    RPC_STATUS status;

    TRACE("WKSSVC_IDENTIFY_HANDLE_bind() called\n");

    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      pszSystemName,
                                      L"\\pipe\\wkssvc",
                                      NULL,
                                      &pszStringBinding);
    if (status)
    {
        TRACE("RpcStringBindingCompose returned 0x%x\n", status);
        return NULL;
    }

    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hBinding);
    if (status)
    {
        TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
    }

    status = RpcStringFreeW(&pszStringBinding);
    if (status)
    {
//        TRACE("RpcStringFree returned 0x%x\n", status);
    }

    return hBinding;
}

WKSSVC_IDENTIFY_HANDLE_unbind()

void __RPC_USER WKSSVC_IDENTIFY_HANDLE_unbind	(	WKSSVC_IDENTIFY_HANDLE	pszSystemName,
		handle_t	hBinding
	)

Definition at line 71 of file wksta_new.c.

{
    RPC_STATUS status;

    TRACE("WKSSVC_IDENTIFY_HANDLE_unbind() called\n");

    status = RpcBindingFree(&hBinding);
    if (status)
    {
        TRACE("RpcBindingFree returned 0x%x\n", status);
    }
}

WKSSVC_IMPERSONATE_HANDLE_bind()

handle_t __RPC_USER WKSSVC_IMPERSONATE_HANDLE_bind

(

WKSSVC_IMPERSONATE_HANDLE

pszSystemName

)

Definition at line 87 of file wksta_new.c.

{
    handle_t hBinding = NULL;
    LPWSTR pszStringBinding;
    RPC_STATUS status;

    TRACE("WKSSVC_IMPERSONATE_HANDLE_bind() called\n");

    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      pszSystemName,
                                      L"\\pipe\\wkssvc",
                                      NULL,
                                      &pszStringBinding);
    if (status)
    {
        TRACE("RpcStringBindingCompose returned 0x%x\n", status);
        return NULL;
    }

    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hBinding);
    if (status)
    {
        TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
    }

    status = RpcStringFreeW(&pszStringBinding);
    if (status)
    {
//        TRACE("RpcStringFree returned 0x%x\n", status);
    }

    return hBinding;
}

WKSSVC_IMPERSONATE_HANDLE_unbind()

void __RPC_USER WKSSVC_IMPERSONATE_HANDLE_unbind	(	WKSSVC_IMPERSONATE_HANDLE	pszSystemName,
		handle_t	hBinding
	)

Definition at line 126 of file wksta_new.c.

{
    RPC_STATUS status;

    TRACE("WKSSVC_IMPERSONATE_HANDLE_unbind() called\n");

    status = RpcBindingFree(&hBinding);
    if (status)
    {
        TRACE("RpcBindingFree returned 0x%x\n", status);
    }
}