1496 lines
43 KiB
C++
1496 lines
43 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: ncident.cpp
|
|
//
|
|
// Contents: Implementation of CNetCfgIdentification.
|
|
//
|
|
// Notes:
|
|
//
|
|
// History: 21 Mar 1997 danielwe Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include <nceh.h>
|
|
#include "ncfgval.h"
|
|
#include "ncident.h"
|
|
#include "ncmisc.h"
|
|
#include "ncreg.h"
|
|
#include "nsbase.h"
|
|
#include "nccom.h"
|
|
#include "ncerror.h"
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DeleteStringAndSetNull
|
|
//
|
|
// Purpose: Frees the given string with delete, and sets it to
|
|
// NULL before exiting.
|
|
//
|
|
// Arguments:
|
|
// pszw [in, out] Pointer to string to be freed. The pointer is set to
|
|
// NULL before the function exits.
|
|
//
|
|
// Returns: Nothing.
|
|
//
|
|
// Author: danielwe 1 Apr 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
inline VOID DeleteStringAndSetNull(PWSTR *pszw)
|
|
{
|
|
AssertSz(pszw, "Param is NULL!");
|
|
|
|
delete *pszw;
|
|
*pszw = NULL;
|
|
}
|
|
|
|
inline HRESULT HrNetValidateName(IN PCWSTR lpMachine,
|
|
IN PCWSTR lpName,
|
|
IN PCWSTR lpAccount,
|
|
IN PCWSTR lpPassword,
|
|
IN NETSETUP_NAME_TYPE NameType)
|
|
{
|
|
NET_API_STATUS nerr;
|
|
|
|
nerr = NetValidateName(const_cast<PWSTR>(lpMachine),
|
|
const_cast<PWSTR>(lpName),
|
|
const_cast<PWSTR>(lpAccount),
|
|
const_cast<PWSTR>(lpPassword),
|
|
NameType);
|
|
|
|
TraceError("NetValidateName", HRESULT_FROM_WIN32(nerr));
|
|
return HrFromNerr(nerr);
|
|
}
|
|
|
|
|
|
inline HRESULT HrNetJoinDomain(IN PWSTR lpMachine,
|
|
IN PWSTR lpMachineObjectOU,
|
|
IN PWSTR lpDomain,
|
|
IN PWSTR lpAccount,
|
|
IN PWSTR lpPassword,
|
|
IN DWORD fJoinOptions)
|
|
{
|
|
NET_API_STATUS nerr;
|
|
HRESULT hr;
|
|
|
|
if ( fJoinOptions & NETSETUP_JOIN_DOMAIN )
|
|
{
|
|
hr = HrNetValidateName( lpMachine, lpDomain, lpAccount,
|
|
lpPassword, NetSetupDomain );
|
|
}
|
|
else
|
|
{
|
|
hr = HrNetValidateName( lpMachine, lpDomain, lpAccount,
|
|
lpPassword, NetSetupWorkgroup );
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
nerr = NetJoinDomain(lpMachine, lpDomain, lpMachineObjectOU,
|
|
lpAccount, lpPassword, fJoinOptions);
|
|
|
|
TraceError("NetJoinDomain", HRESULT_FROM_WIN32(nerr));
|
|
|
|
hr = HrFromNerr(nerr);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
inline HRESULT HrNetRenameInDomain(IN PWSTR lpMachine,
|
|
IN PWSTR lpNewMachine,
|
|
IN PWSTR lpAccount,
|
|
IN PWSTR lpPassword,
|
|
IN DWORD fJoinOptions)
|
|
{
|
|
NET_API_STATUS nerr;
|
|
|
|
nerr = NetRenameMachineInDomain(lpMachine, lpNewMachine, lpAccount,
|
|
lpPassword, fJoinOptions);
|
|
TraceError("NetRenameMachineInDomain", HRESULT_FROM_WIN32(nerr));
|
|
return HrFromNerr(nerr);
|
|
}
|
|
|
|
inline HRESULT HrNetUnjoinDomain(IN PWSTR lpAccount,
|
|
IN PWSTR lpPassword,
|
|
IN DWORD fJoinOptions)
|
|
{
|
|
NET_API_STATUS nerr;
|
|
|
|
nerr = NetUnjoinDomain(NULL,lpAccount, lpPassword, fJoinOptions);
|
|
|
|
TraceError("NetUnjoinDomain", HRESULT_FROM_WIN32(nerr));
|
|
return HrFromNerr(nerr);
|
|
}
|
|
|
|
inline HRESULT HrNetGetJoinInformation(IN PWSTR lpNameBuffer,
|
|
OUT LPDWORD lpNameBufferSize,
|
|
OUT PNETSETUP_JOIN_STATUS BufferType)
|
|
{
|
|
NET_API_STATUS nerr;
|
|
PWSTR JoinBuff = NULL;
|
|
|
|
nerr = NetGetJoinInformation(NULL, &JoinBuff, BufferType);
|
|
|
|
if ( nerr == NERR_Success ) {
|
|
|
|
if ( *BufferType == NetSetupUnjoined ) {
|
|
|
|
*lpNameBufferSize = 0;
|
|
*lpNameBuffer = UNICODE_NULL;
|
|
|
|
} else {
|
|
|
|
if ( *lpNameBufferSize >= ( wcslen( JoinBuff ) +1 ) * sizeof( WCHAR ) ) {
|
|
|
|
wcscpy( lpNameBuffer, JoinBuff );
|
|
|
|
}
|
|
|
|
*lpNameBufferSize = wcslen( JoinBuff ) +1;
|
|
|
|
NetApiBufferFree( JoinBuff );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
TraceError("NetGetJoinInformation", HRESULT_FROM_WIN32(nerr));
|
|
return HrFromNerr(nerr);
|
|
}
|
|
|
|
#ifdef DBG
|
|
BOOL CNetCfgIdentification::FIsJoinedToDomain()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
NETSETUP_JOIN_STATUS js;
|
|
WCHAR wszBuffer[256];
|
|
DWORD cchBuffer = celems(wszBuffer);
|
|
|
|
hr = HrNetGetJoinInformation(wszBuffer, &cchBuffer, &js);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (js == NetSetupUnjoined)
|
|
{
|
|
// If we're as yet unjoined, only make sure that we marked our
|
|
// internal state as being joined to a workgroup called "WORKGROUP"
|
|
AssertSz(m_jsCur == NetSetupWorkgroupName, "We're unjoined but not "
|
|
"joined to a workgroup!");
|
|
AssertSz(m_szwCurDWName, "No current domain or "
|
|
"workgroup name?");
|
|
AssertSz(!lstrcmpiW(m_szwCurDWName,
|
|
SzLoadIds(IDS_WORKGROUP)),
|
|
"Workgroup name is not generic!");
|
|
}
|
|
else
|
|
{
|
|
AssertSz(js == m_jsCur, "Join status is not what we think it is!!");
|
|
}
|
|
}
|
|
|
|
TraceError("CNetCfgIdentification::FIsJoinedToDomain - "
|
|
"HrNetGetJoinInformation", hr);
|
|
|
|
return (m_jsCur == NetSetupDomainName);
|
|
}
|
|
#endif
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: HrFromNerr
|
|
//
|
|
// Purpose: Converts a NET_API_STATUS code into a NETCFG_E_* HRESULT
|
|
// value.
|
|
//
|
|
// Arguments:
|
|
// nerr [in] Status code to convert.
|
|
//
|
|
// Returns: HRESULT, Converted HRESULT value.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT HrFromNerr(NET_API_STATUS nerr)
|
|
{
|
|
HRESULT hr;
|
|
|
|
switch (nerr)
|
|
{
|
|
case NERR_Success:
|
|
hr = S_OK;
|
|
break;
|
|
case NERR_SetupAlreadyJoined:
|
|
hr = NETCFG_E_ALREADY_JOINED;
|
|
break;
|
|
case ERROR_DUP_NAME:
|
|
hr = NETCFG_E_NAME_IN_USE;
|
|
break;
|
|
case NERR_SetupNotJoined:
|
|
hr = NETCFG_E_NOT_JOINED;
|
|
break;
|
|
// case NERR_SetupIsDC:
|
|
// hr = NETCFG_E_MACHINE_IS_DC;
|
|
// break;
|
|
// case NERR_SetupNotAServer:
|
|
// hr = NETCFG_E_NOT_A_SERVER;
|
|
// break;
|
|
// case NERR_SetupImproperRole:
|
|
// hr = NETCFG_E_INVALID_ROLE;
|
|
// break;
|
|
case ERROR_INVALID_PARAMETER:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
case ERROR_ACCESS_DENIED:
|
|
hr = E_ACCESSDENIED;
|
|
break;
|
|
case NERR_InvalidComputer:
|
|
case ERROR_NO_SUCH_DOMAIN:
|
|
hr = NETCFG_E_INVALID_DOMAIN;
|
|
break;
|
|
default:
|
|
// Generic INetCfgIdentification error
|
|
//$ REVIEW (danielwe) 24 Jun 1997: What if this isn't a Win32 error?
|
|
hr = HRESULT_FROM_WIN32(nerr);
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//
|
|
// INetCfgIdentification implementation
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrEnsureCurrentComputerName
|
|
//
|
|
// Purpose: Ensures that the current computer name exists to act on.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes: Sets the m_szwCurComputerName variable.
|
|
//
|
|
HRESULT CNetCfgIdentification::HrEnsureCurrentComputerName()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!m_szwCurComputerName)
|
|
{
|
|
PWSTR pszwComputer;
|
|
|
|
// Go get the current computer name because we don't know it yet.
|
|
hr = HrGetCurrentComputerName(&pszwComputer);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// m_szwCurComputerName is now set as a side effect
|
|
|
|
CoTaskMemFree(pszwComputer);
|
|
}
|
|
}
|
|
|
|
AssertSz(FImplies(SUCCEEDED(hr), m_szwCurComputerName),
|
|
"I MUST have a name here!");
|
|
|
|
TraceError("CNetCfgIdentification::HrEnsureCurrentComputerName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrGetNewestComputerName
|
|
//
|
|
// Purpose: Places the most recently referenced computer name into the
|
|
// output parameter.
|
|
//
|
|
// Arguments:
|
|
// pwszName [out] Most recently referenced computer name.
|
|
//
|
|
// Returns: Possible Win32 error code.
|
|
//
|
|
// Author: danielwe 24 Mar 1997
|
|
//
|
|
// Notes: If the SetComputerName() method was never called, this sets
|
|
// the m_szwCurComputerName variable and returns a pointer to it.
|
|
// Otherwise, it will return a pointer to the computer name
|
|
// given in the SetComputerName() call.
|
|
//
|
|
HRESULT CNetCfgIdentification::HrGetNewestComputerName(PCWSTR *pwszName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
AssertSz(pwszName, "NULL out param!");
|
|
|
|
*pwszName = NULL;
|
|
|
|
// New computer name is absent, use current computer name.
|
|
hr = HrEnsureCurrentComputerName();
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
*pwszName = m_szwCurComputerName;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrGetNewestComputerName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrValidateMachineName
|
|
//
|
|
// Purpose: Validates the given machine name.
|
|
//
|
|
// Arguments:
|
|
// szwName [in] Machine name to validate.
|
|
//
|
|
// Returns: S_OK if machine name is valid, NETCFG_E_NAME_IN_USE if machine
|
|
// name is in use.
|
|
//
|
|
// Author: danielwe 24 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrValidateMachineName(PCWSTR szwName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Only validate if networking is installed
|
|
hr = HrIsNetworkingInstalled();
|
|
if (hr == S_OK)
|
|
{
|
|
// Current computer name is unused for validation of machine name.
|
|
hr = HrNetValidateName(NULL,
|
|
szwName,
|
|
NULL, NULL,
|
|
NetSetupMachine);
|
|
if (FAILED(hr))
|
|
{
|
|
//$REVIEW(danielwe): What error code to return here?
|
|
TraceError("NetValidateName - Machine Name", hr);
|
|
}
|
|
}
|
|
else if (hr == S_FALSE)
|
|
{
|
|
// no networking installed. We're fine.
|
|
hr = S_OK;
|
|
}
|
|
|
|
TraceError("CNetCfgIdentification::HrValidateMachineName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrValidateWorkgroupName
|
|
//
|
|
// Purpose: Validates the given workgroup name.
|
|
//
|
|
// Arguments:
|
|
// szwName [in] Workgroup name to validate.
|
|
//
|
|
// Returns: S_OK if machine name is valid, NETCFG_E_NAME_IN_USE if machine
|
|
// name is in use.
|
|
//
|
|
// Author: danielwe 24 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrValidateWorkgroupName(PCWSTR szwName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PCWSTR wszComputerName = NULL;
|
|
|
|
// If the user has changed the computer name, use it, otherwise get the
|
|
// current computer name and use that.
|
|
hr = HrGetNewestComputerName(&wszComputerName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
AssertSz(wszComputerName, "We don't have a computer name!");
|
|
|
|
hr = HrNetValidateName(const_cast<PWSTR>(wszComputerName),
|
|
szwName, NULL, NULL, NetSetupWorkgroup);
|
|
if (FAILED(hr))
|
|
{
|
|
//$REVIEW(danielwe): What error code to return here?
|
|
TraceError("NetValidateName - Workgroup Name", hr);
|
|
goto err;
|
|
}
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrValidateWorkgroupName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrValidateDomainName
|
|
//
|
|
// Purpose: Validates the given domain name.
|
|
//
|
|
// Arguments:
|
|
// szwName [in] Name of domain to validate.
|
|
// szwUserName [in] Username for authorization purposes.
|
|
// szwPassword [in] Password for authorization purposes.
|
|
//
|
|
// Returns: S_OK if machine name is valid, NETCFG_E_INVALID_DOMAIN if
|
|
// domain name is invalid (or non-existent).
|
|
//
|
|
// Author: danielwe 24 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrValidateDomainName(PCWSTR szwName,
|
|
PCWSTR szwUserName,
|
|
PCWSTR szwPassword)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// NetValidateName does not use the machine name in validating the
|
|
// domain name. So it is NULL here.
|
|
hr = HrNetValidateName(NULL, szwName,
|
|
szwUserName,
|
|
szwPassword,
|
|
NetSetupDomain);
|
|
if (FAILED(hr))
|
|
{
|
|
//$REVIEW(danielwe): What error code to return here?
|
|
TraceError("NetValidateName - Domain Name", hr);
|
|
goto err;
|
|
}
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrValidateDomainName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::Validate
|
|
//
|
|
// Purpose: Implements COM function to validate current set of values
|
|
// used during the lifetime of this object.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::Validate()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Validate_INetCfgIdentification_Validate();
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
if (m_szwNewDWName)
|
|
{
|
|
if (GetNewJoinStatus() == NetSetupWorkgroupName)
|
|
{
|
|
// Validate workgroup name
|
|
hr = HrValidateWorkgroupName(m_szwNewDWName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
}
|
|
else if (GetNewJoinStatus() == NetSetupDomainName)
|
|
{
|
|
// Validate domain name
|
|
hr = HrValidateDomainName(m_szwNewDWName, m_szwUserName,
|
|
m_szwPassword);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
}
|
|
#ifdef DBG
|
|
else
|
|
{
|
|
AssertSz(FALSE, "Invalid join status!");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
err:
|
|
// Translate all errors to S_FALSE.
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_fValid = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// spew out trace *before* the assignment so we know what the *real*
|
|
// error code was.
|
|
TraceError("CNetCfgIdentification::Validate (before S_FALSE)", hr);
|
|
hr = S_FALSE;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::Cancel
|
|
//
|
|
// Purpose: Cancels any changes made during the lifetime of the object.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns:
|
|
//
|
|
// Author: danielwe 25 Mar 1997
|
|
//
|
|
// Notes: Resets state information and frees any memory previously
|
|
// allocted.
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::Cancel()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Validate_INetCfgIdentification_Cancel();
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
DeleteStringAndSetNull(&m_szwNewDWName);
|
|
DeleteStringAndSetNull(&m_szwPassword);
|
|
DeleteStringAndSetNull(&m_szwUserName);
|
|
DeleteStringAndSetNull(&m_szwCurComputerName);
|
|
DeleteStringAndSetNull(&m_szwCurDWName);
|
|
|
|
m_dwJoinFlags = 0;
|
|
m_dwCreateFlags = 0;
|
|
m_fValid = FALSE;
|
|
m_jsNew = NetSetupUnjoined;
|
|
}
|
|
|
|
COM_PROTECT_CATCH;
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::Apply
|
|
//
|
|
// Purpose: Implements COM function to apply changes that were made
|
|
// during the lifetime of this object.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::Apply()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Validate_INetCfgIdentification_Apply();
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
// Has data been validated?
|
|
if (!m_fValid)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
goto err;
|
|
}
|
|
|
|
if (m_szwNewDWName)
|
|
{
|
|
if (GetNewJoinStatus() == NetSetupWorkgroupName)
|
|
{
|
|
// The user specified a workgroup name. This means they want
|
|
// to join a workgroup.
|
|
hr = HrJoinWorkgroup();
|
|
if (FAILED(hr))
|
|
goto err;
|
|
}
|
|
else if (GetNewJoinStatus() == NetSetupDomainName)
|
|
{
|
|
// The user specified a domain name. This means they want to
|
|
// join a domain.
|
|
hr = HrJoinDomain();
|
|
if (FAILED(hr))
|
|
goto err;
|
|
}
|
|
#ifdef DBG
|
|
else
|
|
{
|
|
AssertSz(FALSE, "Invalid join status!");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
err:
|
|
// Regardless of result, set valid flag to false again to require
|
|
// Validate() to be called again before calling Apply().
|
|
// $REVIEW (danielwe): Is this how we want to do it?
|
|
m_fValid = FALSE;
|
|
|
|
TraceError("CNetCfgIdentification::Apply", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrGetCurrentComputerName
|
|
//
|
|
// Purpose: Calls the Win32 GetComputerName API to get the current
|
|
// computer name.
|
|
//
|
|
// Arguments:
|
|
// ppszwComputer [out] Returned computer name.
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes: Makes a private copy of the computer name if obtained from the
|
|
// system (for further use).
|
|
//
|
|
HRESULT CNetCfgIdentification::HrGetCurrentComputerName(PWSTR* ppszwComputer)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR szBuffer[MAX_COMPUTERNAME_LENGTH + 1];
|
|
DWORD cchBuffer = celems(szBuffer);
|
|
|
|
if (::GetComputerName(szBuffer, &cchBuffer))
|
|
{
|
|
// Make a copy for the out param.
|
|
hr = HrCoTaskMemAllocAndDupSz (
|
|
szBuffer, ppszwComputer);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Make another copy for our own use.
|
|
DeleteStringAndSetNull(&m_szwCurComputerName);
|
|
m_szwCurComputerName = SzDupSz(szBuffer);
|
|
|
|
AssertSz((DWORD)lstrlenW(*ppszwComputer) == cchBuffer,
|
|
"This is not how big the string is!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TraceLastWin32Error("::GetComputerName");
|
|
hr = HrFromLastWin32Error();
|
|
}
|
|
|
|
TraceError("CNetCfgIdentification::HrGetCurrentComputerName", hr);
|
|
return hr;
|
|
}
|
|
|
|
static const WCHAR c_szRegKeyComputerName[] = L"System\\CurrentControlSet\\Control\\ComputerName\\ComputerName";
|
|
static const WCHAR c_szRegValueComputerName[] = L"ComputerName";
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrGetNewComputerName
|
|
//
|
|
// Purpose: Helper function to retreive the new computer name from the
|
|
// registry. This will be the same as the active computer name
|
|
// unless the user has changed the computer name since booting.
|
|
//
|
|
// Arguments:
|
|
// ppszwComputer [out] Returns new computer name.
|
|
//
|
|
// Returns: S_OK if successful, Win32 error code otherwise.
|
|
//
|
|
// Author: danielwe 21 May 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrGetNewComputerName(PWSTR* ppszwComputer)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR szBuffer[MAX_COMPUTERNAME_LENGTH + 1];
|
|
DWORD cbBuffer = sizeof(szBuffer);
|
|
HKEY hkeyComputerName;
|
|
|
|
hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyComputerName,
|
|
KEY_READ, &hkeyComputerName);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HrRegQuerySzBuffer(hkeyComputerName, c_szRegValueComputerName,
|
|
szBuffer, &cbBuffer);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Make a copy for the out param.
|
|
hr = HrCoTaskMemAllocAndDupSz (
|
|
szBuffer, ppszwComputer);
|
|
|
|
AssertSz(FImplies(SUCCEEDED(hr),
|
|
(lstrlenW(*ppszwComputer) + 1) * sizeof(WCHAR) == cbBuffer),
|
|
"This is not how big the string is!");
|
|
}
|
|
|
|
RegCloseKey(hkeyComputerName);
|
|
}
|
|
|
|
TraceError("CNetCfgIdentification::HrGetCurrentComputerName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrEnsureCurrentDomainOrWorkgroupName
|
|
//
|
|
// Purpose: Obtains the current domain or workgroup to which this machine
|
|
// belongs.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: S_OK if success, error code otherwise.
|
|
//
|
|
// Author: danielwe 26 Mar 1997
|
|
//
|
|
// Notes: A machine can be joined to either or workgroup or a domain. It
|
|
// must be joined to one or the other. If it is not, we'll use a
|
|
// more or less hardcoded string and "fake it" as if the machine
|
|
// was joined to a workgroup. The member variables:
|
|
// m_jsCur and m_szwCurDWName are set by this function.
|
|
//
|
|
// This call only does work once. Subsequent calls do nothing.
|
|
//
|
|
HRESULT CNetCfgIdentification::HrEnsureCurrentDomainOrWorkgroupName()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!m_szwCurDWName)
|
|
{
|
|
NETSETUP_JOIN_STATUS js;
|
|
WCHAR wszBuffer[256];
|
|
PCWSTR wszName;
|
|
DWORD cchBuffer = celems(wszBuffer);
|
|
|
|
hr = HrNetGetJoinInformation(wszBuffer, &cchBuffer, &js);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
AssertSz(FIff(*wszBuffer, cchBuffer), "Buffer size inconsistency!");
|
|
|
|
if (js == NetSetupUnjoined)
|
|
{
|
|
// Uh oh. Machine is not joined to workgroup OR domain. Set
|
|
// default workgroup name and proceed as if joined to a workgroup.
|
|
js = NetSetupWorkgroupName;
|
|
|
|
// Use default name since HrNetGetJoinInformation() will return
|
|
// an empty string which is useless.
|
|
wszName = SzLoadIds(IDS_WORKGROUP);
|
|
}
|
|
else
|
|
{
|
|
// Use string returned from HrNetGetJoinInformation().
|
|
wszName = wszBuffer;
|
|
}
|
|
|
|
m_szwCurDWName = SzDupSz(wszName);
|
|
|
|
m_jsCur = js;
|
|
|
|
AssertSz(GetCurrentJoinStatus() == NetSetupWorkgroupName ||
|
|
GetCurrentJoinStatus() == NetSetupDomainName,
|
|
"Invalid join status flag!");
|
|
}
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrEnsureCurrentDomainOrWorkgroupName",
|
|
hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrGetNewestDomainOrWorkgroupName
|
|
//
|
|
// Purpose: Returns the domain or workgroup name that was most recently
|
|
// referenced.
|
|
//
|
|
// Arguments:
|
|
// js [in] Tells whether the domain or workgroup name is wanted.
|
|
// pwszName [out] Domain or workgroup name.
|
|
//
|
|
// Returns: S_OK if success, E_OUTOFMEMORY if no memory.
|
|
//
|
|
// Author: danielwe 26 Mar 1997
|
|
//
|
|
// Notes: If the requested name has not been set by the user in a prior
|
|
// call, the current name is returned. Otherwise the name the
|
|
// user chose previously is returned.
|
|
//
|
|
HRESULT CNetCfgIdentification::HrGetNewestDomainOrWorkgroupName(
|
|
NETSETUP_JOIN_STATUS js,
|
|
PCWSTR *pwszName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PWSTR szwOut = NULL;
|
|
|
|
Assert(pwszName);
|
|
|
|
if (m_szwNewDWName && (GetNewJoinStatus() == js))
|
|
{
|
|
// Give them back a copy of the domain or workgroup name they
|
|
// previously gave us.
|
|
szwOut = m_szwNewDWName;
|
|
}
|
|
else
|
|
{
|
|
// Get the current workgroup or domain for this machine. It has
|
|
// to be in one or the other.
|
|
hr = HrEnsureCurrentDomainOrWorkgroupName();
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
if (GetCurrentJoinStatus() == js)
|
|
{
|
|
// Use the current name.
|
|
szwOut = m_szwCurDWName;
|
|
}
|
|
}
|
|
|
|
Assert(SUCCEEDED(hr));
|
|
|
|
*pwszName = szwOut;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrGetNewestDomainOrWorkgroupName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::GetWorkgroupName
|
|
//
|
|
// Purpose: Implements COM function to get the current workgroup name.
|
|
//
|
|
// Arguments:
|
|
// ppszwWorkgroup [out] Returns name of current workgroup.
|
|
//
|
|
// Returns: S_OK if succeeded, S_FALSE if machine is not joined to a
|
|
// workgroup, error code otherwise.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::GetWorkgroupName(PWSTR* ppszwWorkgroup)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PCWSTR szwWorkgroup = NULL;
|
|
|
|
Validate_INetCfgIdentification_GetWorkgroupName(ppszwWorkgroup);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
*ppszwWorkgroup = NULL;
|
|
|
|
hr = HrGetNewestDomainOrWorkgroupName(NetSetupWorkgroupName,
|
|
&szwWorkgroup);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
if (szwWorkgroup)
|
|
{
|
|
hr = HrCoTaskMemAllocAndDupSz (
|
|
szwWorkgroup, ppszwWorkgroup);
|
|
|
|
AssertSz(FImplies(SUCCEEDED(hr), lstrlenW(*ppszwWorkgroup) > 0),
|
|
"Why is *ppszwWorkgroup empty?");
|
|
}
|
|
else
|
|
{
|
|
// Not joined to a workgroup
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::GetWorkgroupName",
|
|
(hr == S_FALSE) ? S_OK : hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::GetDomainName
|
|
//
|
|
// Purpose: Implements COM function to get the current domain name.
|
|
//
|
|
// Arguments:
|
|
// ppszwDomain [out] Returns name of domain to which this computer
|
|
// currently belongs.
|
|
//
|
|
// Returns: S_OK if succeeded, S_FALSE if machine is not joined to a
|
|
// domain, error code otherwise.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::GetDomainName(PWSTR* ppszwDomain)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PCWSTR szwDomain = NULL;
|
|
|
|
Validate_INetCfgIdentification_GetDomainName(ppszwDomain);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
*ppszwDomain = NULL;
|
|
|
|
hr = HrGetNewestDomainOrWorkgroupName(NetSetupDomainName,
|
|
&szwDomain);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
if (szwDomain)
|
|
{
|
|
hr = HrCoTaskMemAllocAndDupSz (
|
|
szwDomain, ppszwDomain);
|
|
|
|
AssertSz(FImplies(SUCCEEDED(hr), lstrlenW(*ppszwDomain) > 0),
|
|
"Why is *ppszwDomain empty?");
|
|
}
|
|
else
|
|
{
|
|
// Not joined to a domain
|
|
hr = S_FALSE;
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::GetDomainName",
|
|
(hr == S_FALSE) ? S_OK : hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrJoinWorkgroup
|
|
//
|
|
// Purpose: Actually performs the JoinWorkgroup function.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrJoinWorkgroup()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PCWSTR wszComputerName = NULL;
|
|
|
|
AssertSz(m_szwNewDWName &&
|
|
GetNewJoinStatus() == NetSetupWorkgroupName,
|
|
"If there was no workgroup name, why'd you call me?!");
|
|
|
|
// If the user has changed the computer name, use it, otherwise get the
|
|
// current computer name and use that.
|
|
hr = HrGetNewestComputerName(&wszComputerName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
AssertSz(wszComputerName, "We don't have a computer name!");
|
|
|
|
hr = HrEnsureCurrentDomainOrWorkgroupName();
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
if (FIsJoinedToDomain())
|
|
{
|
|
// Must unjoin from domain if currently joined.
|
|
// If currently joined to a workgroup, this is not necessary.
|
|
hr = HrNetUnjoinDomain(m_szwUserName, m_szwPassword, 0);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
// Free username and password
|
|
DeleteStringAndSetNull(&m_szwPassword);
|
|
DeleteStringAndSetNull(&m_szwUserName);
|
|
}
|
|
|
|
// Go ahead and join the workgroup
|
|
hr = HrNetJoinDomain(const_cast<PWSTR>(wszComputerName),
|
|
m_szMachineObjectOU,
|
|
m_szwNewDWName, NULL, NULL, 0);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
// Make the current workgroup name the new one since the join on the
|
|
// new workgroup has succeeded
|
|
hr = HrEstablishNewDomainOrWorkgroupName(NetSetupWorkgroupName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::HrJoinWorkgroup", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::JoinWorkgroup
|
|
//
|
|
// Purpose: Implements COM interface to join this computer to a new
|
|
// workgroup.
|
|
//
|
|
// Arguments:
|
|
// szwWorkgroup [in] Name of new workgroup to join.
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes: Validates, but does not actually join the workgroup. Only holds
|
|
// onto the information until Apply() is called.
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::JoinWorkgroup(PCWSTR szwWorkgroup)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Validate_INetCfgIdentification_JoinWorkgroup(szwWorkgroup);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
hr = HrValidateWorkgroupName(szwWorkgroup);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
// Free domain and password given if JoinDomain was called previously
|
|
DeleteStringAndSetNull(&m_szwPassword);
|
|
DeleteStringAndSetNull(&m_szwUserName);
|
|
|
|
// Assign in new workgroup name.
|
|
m_szwNewDWName = SzDupSz(szwWorkgroup);
|
|
|
|
m_jsNew = NetSetupWorkgroupName;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
err:
|
|
TraceError("CNetCfgIdentification::JoinWorkgroup", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrEstablishNewDomainOrWorkgroupName
|
|
//
|
|
// Purpose: When the computer is joined to a new domain or workgroup, this
|
|
// function is called to set the correct member variables and
|
|
// free the old ones.
|
|
//
|
|
// Arguments:
|
|
// js [in] Indicates whether the computer is joined to a domain or
|
|
// workgroup.
|
|
//
|
|
// Returns: S_OK, or E_OUTOFMEMORY.
|
|
//
|
|
// Author: danielwe 1 Apr 1997
|
|
//
|
|
// Notes: Replaces the m_szwCurDWName variable with the new one
|
|
// (m_szwNewDWName).
|
|
//
|
|
HRESULT CNetCfgIdentification::HrEstablishNewDomainOrWorkgroupName(
|
|
NETSETUP_JOIN_STATUS js)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Make the current domain or workgroup name the new one.
|
|
DeleteStringAndSetNull(&m_szwCurDWName);
|
|
m_szwCurDWName = SzDupSz(m_szwNewDWName);
|
|
|
|
m_jsCur = js;
|
|
|
|
AssertSz(GetCurrentJoinStatus() == NetSetupWorkgroupName ||
|
|
GetCurrentJoinStatus() == NetSetupDomainName,
|
|
"Invalid join status flag!");
|
|
|
|
// Free "new" name
|
|
DeleteStringAndSetNull(&m_szwNewDWName);
|
|
|
|
// Also make sure that we don't have a "new" join status either
|
|
m_jsNew = NetSetupUnjoined;
|
|
|
|
TraceError("CNetCfgIdentification::HrEstablishNewDomainOrWorkgroupName",
|
|
hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::HrJoinDomain
|
|
//
|
|
// Purpose: Actually performs the JoinDomain function.
|
|
//
|
|
// Arguments:
|
|
// (none)
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CNetCfgIdentification::HrJoinDomain()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PCWSTR wszComputerName = NULL;
|
|
DWORD dwJoinOption = 0;
|
|
BOOL fIsRename = FALSE;
|
|
BOOL fUseNulls = FALSE;
|
|
|
|
AssertSz(m_szwNewDWName && m_jsNew == NetSetupDomainName,
|
|
"If there was no domain name, why'd you call me?!");
|
|
AssertSz(FImplies(m_szwPassword,
|
|
m_szwUserName),
|
|
"Password without username!!");
|
|
|
|
// If the user has changed the computer name, use it, otherwise get the
|
|
// current computer name and use that.
|
|
hr = HrGetNewestComputerName(&wszComputerName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
{
|
|
AssertSz(wszComputerName == m_szwCurComputerName, "If I don't have a "
|
|
"new computer name, this better be the original one!");
|
|
dwJoinOption |= NETSETUP_JOIN_DOMAIN;
|
|
}
|
|
|
|
AssertSz(wszComputerName, "We don't have a computer name!");
|
|
AssertSz(dwJoinOption, "No option was set??");
|
|
|
|
AssertSz(FImplies(m_szwPassword,
|
|
m_szwUserName),
|
|
"Password without username!");
|
|
|
|
// Create a machine account if so asked.
|
|
if (m_dwJoinFlags & JDF_CREATE_ACCOUNT)
|
|
{
|
|
dwJoinOption |= NETSETUP_ACCT_CREATE;
|
|
}
|
|
|
|
if (m_dwJoinFlags & JDF_WIN9x_UPGRADE)
|
|
{
|
|
dwJoinOption |= NETSETUP_WIN9X_UPGRADE;
|
|
}
|
|
|
|
if (m_dwJoinFlags & JDF_JOIN_UNSECURE)
|
|
{
|
|
dwJoinOption |= NETSETUP_JOIN_UNSECURE;
|
|
}
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
// TEMP: On a remote boot machine, prevent machine password change
|
|
if (HrIsRemoteBootMachine() == S_OK)
|
|
{
|
|
TraceTag (ttidNetcfgBase,
|
|
"Machine is remote boot, specifying WIN9X_UPGRADE flag to JoinDomain.");
|
|
dwJoinOption |= NETSETUP_WIN9X_UPGRADE;
|
|
}
|
|
#endif // defined(REMOTE_BOOT)
|
|
|
|
//$ REVIEW (danielwe) 2 Apr 1997: If new domain is same as old, unjoin
|
|
// then rejoin??
|
|
|
|
if (!(fIsRename) && FIsJoinedToDomain())
|
|
{
|
|
// Must unjoin from domain if currently joined.
|
|
// If currently joined to a workgroup, this is not necessary.
|
|
// Also we don't unjoin if we are renaming the machine in the domain.
|
|
hr = HrNetUnjoinDomain(m_szwUserName,
|
|
m_szwPassword, 0);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
}
|
|
|
|
if (FInSystemSetup())
|
|
{
|
|
// During system setup, need to pass special flag that tells join code
|
|
// to not do certain operations because SAM is not initialized yet.
|
|
dwJoinOption |= NETSETUP_INSTALL_INVOCATION;
|
|
}
|
|
|
|
// If the supplied username has astring length of zero, then the join
|
|
// API's should be called with NULL's.
|
|
//
|
|
if ((NULL == m_szwUserName) || (0 == wcslen(m_szwUserName)))
|
|
{
|
|
fUseNulls = TRUE;
|
|
}
|
|
|
|
// Go ahead and join the domain
|
|
if( fIsRename) {
|
|
|
|
hr = HrNetRenameInDomain(const_cast<PWSTR>(wszComputerName),
|
|
m_szwNewDWName,
|
|
(fUseNulls ? NULL : m_szwUserName),
|
|
(fUseNulls ? NULL : m_szwPassword),
|
|
dwJoinOption);
|
|
|
|
} else {
|
|
|
|
hr = HrNetJoinDomain(const_cast<PWSTR>(wszComputerName),
|
|
m_szMachineObjectOU,
|
|
m_szwNewDWName,
|
|
(fUseNulls ? NULL : m_szwUserName),
|
|
(fUseNulls ? NULL : m_szwPassword),
|
|
dwJoinOption);
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
// Note: (danielwe) Making assumption that failure to join a domain puts us in
|
|
// a workgroup. MacM owns the code responsible for this.
|
|
m_jsCur = NetSetupWorkgroupName;
|
|
goto err;
|
|
}
|
|
|
|
// Make the current domain name the new one since the join on the
|
|
// new domain has succeeded
|
|
hr = HrEstablishNewDomainOrWorkgroupName(NetSetupDomainName);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
err:
|
|
// Free username and password
|
|
DeleteStringAndSetNull(&m_szwPassword);
|
|
DeleteStringAndSetNull(&m_szwUserName);
|
|
|
|
TraceError("CNetCfgIdentification::HrJoinDomain", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::JoinDomain
|
|
//
|
|
// Purpose: Implements COM interface to join this computer to a new
|
|
// domain.
|
|
//
|
|
// Arguments:
|
|
// szwDomain [in] New domain name.
|
|
// szMachineObjectOU [in] Machine object OU (optional)
|
|
// szwUserName [in] User name to use in validation.
|
|
// szwPassword [in] Password to use in validation.
|
|
// dwJoinFlags [in] Currently can be 0 or JDF_CREATE_ACCOUNT.
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: danielwe 21 Mar 1997
|
|
//
|
|
// Notes: Validates, but does not actually join the domain. Only holds
|
|
// onto the information until Apply() is called.
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::JoinDomain(PCWSTR szwDomain,
|
|
PCWSTR szMachineObjectOU,
|
|
PCWSTR szwUserName,
|
|
PCWSTR szwPassword,
|
|
DWORD dwJoinFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
static const WCHAR c_wszBackslash[] = L"\\";
|
|
static const WCHAR c_wszAt[] = L"@";
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
Validate_INetCfgIdentification_JoinDomain(szwDomain, szwUserName,
|
|
szwPassword);
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
if (HrIsRemoteBootMachine() == S_FALSE)
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
// look for non-empty password and empty username or username
|
|
// consisting of only the backslash character
|
|
if (!FIsStrEmpty(szwPassword) && FIsStrEmpty(szwUserName) ||
|
|
!lstrcmpW(szwUserName, c_wszBackslash))
|
|
{
|
|
// Password without username is invalid.
|
|
hr = E_INVALIDARG;
|
|
goto err;
|
|
}
|
|
|
|
PWSTR wszNewUserName;
|
|
INT cchNewUserName;
|
|
|
|
// Check if username that was passed in has a backslash in it or
|
|
// an '@', or if it is empty.
|
|
if (FIsStrEmpty(szwUserName) ||
|
|
wcschr(szwUserName, c_wszBackslash[0]) ||
|
|
wcschr(szwUserName, c_wszAt[0]))
|
|
{
|
|
// if so, don't do anything extra
|
|
wszNewUserName = NULL;
|
|
}
|
|
else
|
|
{
|
|
// if not, we have to append the domain name to the username
|
|
|
|
cchNewUserName = lstrlenW(szwUserName) + // original username
|
|
lstrlenW(szwDomain) + // domain name
|
|
1 + // backslash character
|
|
1; // terminating NULL
|
|
|
|
wszNewUserName = new WCHAR[cchNewUserName];
|
|
|
|
if(wszNewUserName)
|
|
{
|
|
// Turn username into domain\username format
|
|
lstrcpyW(wszNewUserName, szwDomain);
|
|
lstrcatW(wszNewUserName, c_wszBackslash);
|
|
lstrcatW(wszNewUserName, szwUserName);
|
|
|
|
AssertSz(lstrlenW(wszNewUserName) + 1 == cchNewUserName,
|
|
"Possible memory overwrite in username!");
|
|
}
|
|
}
|
|
|
|
// Use wszNewUserName if non-NULL, otherwise use szwUserName
|
|
|
|
PCWSTR szwUserNameToCopy;
|
|
|
|
szwUserNameToCopy = wszNewUserName ? wszNewUserName : szwUserName;
|
|
m_szwUserName = SzDupSz(szwUserNameToCopy);
|
|
m_szwPassword = SzDupSz(szwPassword);
|
|
|
|
delete [] wszNewUserName;
|
|
}
|
|
|
|
AssertSz(FImplies(m_szwPassword,
|
|
m_szwUserName),
|
|
"Password without username!");
|
|
|
|
hr = HrValidateDomainName(szwDomain, m_szwUserName, m_szwPassword);
|
|
if (FAILED(hr))
|
|
goto err;
|
|
|
|
// Assign in new strings
|
|
m_szwNewDWName = SzDupSz(szwDomain);
|
|
if (szMachineObjectOU)
|
|
{
|
|
m_szMachineObjectOU = SzDupSz(szMachineObjectOU);
|
|
}
|
|
|
|
m_dwJoinFlags = dwJoinFlags;
|
|
m_jsNew = NetSetupDomainName;
|
|
err:
|
|
// suppress compiler error
|
|
;
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
TraceError("CNetCfgIdentification::JoinDomain", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CNetCfgIdentification::GetComputerRole
|
|
//
|
|
// Purpose: Returns the current role of the computer.
|
|
//
|
|
// Arguments:
|
|
// pdwRoleFlags [out] Returns value which determines the role of this
|
|
// computer.
|
|
//
|
|
// Returns: S_OK if success, error code otherwise.
|
|
//
|
|
// Author: danielwe 26 Mar 1997
|
|
//
|
|
// Notes: Returned role can be one of:
|
|
// SERVER_STANDALONE - The machine is part of a workgroup.
|
|
// SERVER_MEMBER - The machine is joined to the domain.
|
|
// SERVER_PDC - The machine is a primary domain controller.
|
|
// SERVER_BDC - The machine is a backup domain controller.
|
|
//
|
|
STDMETHODIMP CNetCfgIdentification::GetComputerRole(DWORD* pdwRoleFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
Validate_INetCfgIdentification_GetComputerRole(pdwRoleFlags);
|
|
|
|
COM_PROTECT_TRY
|
|
{
|
|
*pdwRoleFlags = 0;
|
|
|
|
hr = HrEnsureCurrentDomainOrWorkgroupName();
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (m_jsNew == NetSetupUnjoined)
|
|
{
|
|
// The workgroup or domain has not been changed since this
|
|
// object was instantiated
|
|
|
|
if (GetCurrentJoinStatus() == NetSetupDomainName)
|
|
{
|
|
*pdwRoleFlags = GCR_MEMBER;
|
|
}
|
|
else if (GetCurrentJoinStatus() == NetSetupWorkgroupName)
|
|
{
|
|
*pdwRoleFlags = GCR_STANDALONE;
|
|
}
|
|
#ifdef DBG
|
|
else
|
|
{
|
|
AssertSz(FALSE, "Invalid join status flag!");
|
|
}
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
// This means the workgroup or domain name has been changed
|
|
// since this object was instantiated
|
|
|
|
if (GetNewJoinStatus() == NetSetupDomainName)
|
|
{
|
|
*pdwRoleFlags = GCR_MEMBER;
|
|
}
|
|
else if (GetNewJoinStatus() == NetSetupWorkgroupName)
|
|
{
|
|
*pdwRoleFlags = GCR_STANDALONE;
|
|
}
|
|
#ifdef DBG
|
|
else
|
|
{
|
|
AssertSz(FALSE, "Invalid join status flag!");
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
COM_PROTECT_CATCH;
|
|
|
|
TraceError("CNetCfgIdentification::GetComputerRole", hr);
|
|
return hr;
|
|
}
|
|
|