Sweden-Number/dlls/netapi32/wksta.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;
    }
}