520 lines
13 KiB
C++
520 lines
13 KiB
C++
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CopyRight ( c ) 1999 Microsoft Corporation
|
|
//
|
|
// Module Name: dnszone.cpp
|
|
//
|
|
// Description:
|
|
// Implementation of CDnsZone class
|
|
//
|
|
// Author:
|
|
// Henry Wang ( henrywa ) March 8, 2000
|
|
//
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#include "DnsWmi.h"
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// create an instance of CDnsZone
|
|
//
|
|
// Arguments:
|
|
// wszName [IN] class name
|
|
// pNamespace [IN] wmi namespace
|
|
// szType [IN] child class name of resource record class
|
|
//
|
|
// Return Value:
|
|
// WBEM_S_NO_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
CDnsBase*
|
|
CDnsZone::CreateThis(
|
|
const WCHAR * wszName,
|
|
CWbemServices * pNamespace,
|
|
const char * szType
|
|
)
|
|
{
|
|
return new CDnsZone(wszName, pNamespace);
|
|
}
|
|
CDnsZone::CDnsZone()
|
|
{
|
|
|
|
}
|
|
|
|
CDnsZone::CDnsZone(
|
|
const WCHAR* wszName,
|
|
CWbemServices *pNamespace)
|
|
:CDnsBase(wszName, pNamespace)
|
|
{
|
|
|
|
}
|
|
|
|
CDnsZone::~CDnsZone()
|
|
{
|
|
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// enum instances of dns zone
|
|
//
|
|
// Arguments:
|
|
// lFlags [IN] WMI flag
|
|
// pCtx [IN] WMI context
|
|
// pHandler [IN] WMI sink pointer
|
|
//
|
|
// Return Value:
|
|
// WBEM_S_NO_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCODE
|
|
CDnsZone::EnumInstance(
|
|
long lFlags,
|
|
IWbemContext * pCtx,
|
|
IWbemObjectSink * pHandler)
|
|
{
|
|
list<CDomainNode> opList;
|
|
list<CDomainNode>::iterator i;
|
|
SCODE sc;
|
|
CDnsWrap& dns = CDnsWrap::DnsObject();
|
|
sc = dns.dnsEnumDomainForServer(&opList);
|
|
if (FAILED(sc))
|
|
{
|
|
return sc;
|
|
}
|
|
|
|
|
|
for(i=opList.begin(); i!=opList.end(); ++i)
|
|
{
|
|
if(_wcsicmp(i->wstrZoneName.data(), PVD_DNS_CACHE) &&
|
|
_wcsicmp(i->wstrZoneName.data(), PVD_DNS_ROOTHINTS) )
|
|
{
|
|
CWbemClassObject Inst;
|
|
m_pClass->SpawnInstance(0, &Inst);
|
|
sc = dns.dnsGetZone(
|
|
dns.GetServerName().data(),
|
|
i->wstrZoneName.data(),
|
|
Inst,
|
|
pHandler);
|
|
if ( SUCCEEDED ( sc ) )
|
|
{
|
|
pHandler->Indicate(1, &Inst);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// retrieve record object pointed by the given object path
|
|
//
|
|
// Arguments:
|
|
// ObjectPath [IN] object path to object
|
|
// lFlags [IN] WMI flag
|
|
// pCtx [IN] WMI context
|
|
// pHandler [IN] WMI sink pointer
|
|
//
|
|
// Return Value:
|
|
// WBEM_S_NO_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCODE
|
|
CDnsZone::GetObject(
|
|
CObjPath & ObjectPath,
|
|
long lFlags,
|
|
IWbemContext * pCtx,
|
|
IWbemObjectSink * pHandler)
|
|
{
|
|
DBG_FN( "CDnsZone::GetObject" )
|
|
|
|
wstring wstrZone = ObjectPath.GetStringValueForProperty(
|
|
PVD_DOMAIN_CONTAINER_NAME);
|
|
wstring wstrNode = ObjectPath.GetStringValueForProperty(
|
|
PVD_DOMAIN_FQDN);
|
|
|
|
DNS_DEBUG( INSTPROV, (
|
|
"%s: zone %S\n", fn, wstrNode.c_str() ));
|
|
|
|
// incase of zone, container name and fqdn are same
|
|
// roothints and cache are managed by roothints and cache class
|
|
if( (_wcsicmp(wstrZone.data(), wstrNode.data()) != 0 ) ||
|
|
_wcsicmp(wstrZone.data(), PVD_DNS_CACHE) == 0 ||
|
|
_wcsicmp(wstrZone.data(), PVD_DNS_ROOTHINTS) ==0 )
|
|
{
|
|
return WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
CWbemClassObject Inst;
|
|
m_pClass->SpawnInstance(0, &Inst);
|
|
|
|
CDnsWrap& dns = CDnsWrap::DnsObject();
|
|
SCODE sc = dns.dnsGetZone(
|
|
PVD_DNS_LOCAL_SERVER,
|
|
ObjectPath.GetStringValueForProperty(PVD_DOMAIN_CONTAINER_NAME).data(),
|
|
Inst,
|
|
pHandler);
|
|
if( SUCCEEDED ( sc ) )
|
|
{
|
|
pHandler->Indicate(1, &Inst);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// save this instance
|
|
//
|
|
// Arguments:
|
|
// InstToPut [IN] WMI object to be saved
|
|
// lFlags [IN] WMI flag
|
|
// pCtx [IN] WMI context
|
|
// pHandler [IN] WMI sink pointer
|
|
//
|
|
// Return Value:
|
|
//
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCODE
|
|
CDnsZone::PutInstance(
|
|
IWbemClassObject * pInst ,
|
|
long lFlags,
|
|
IWbemContext* pCtx ,
|
|
IWbemObjectSink * pHandler)
|
|
{
|
|
DBG_FN( "CDnsZone::PutInstance" )
|
|
|
|
DNS_DEBUG( INSTPROV, (
|
|
"%s: pInst=%p\n", fn, pInst ));
|
|
|
|
CDnsWrap& dns = CDnsWrap::DnsObject();
|
|
CWbemClassObject Inst(pInst);
|
|
return dns.dnsZonePut(Inst);
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// delete the object specified in ObjectPath
|
|
//
|
|
// Arguments:
|
|
// ObjectPath [IN] ObjPath for the instance to be deleted
|
|
// lFlags [IN] WMI flag
|
|
// pCtx [IN] WMI context
|
|
// pHandler [IN] WMI sink pointer
|
|
//
|
|
// Return Value:
|
|
// WBEM_S_NO_ERROR
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
SCODE
|
|
CDnsZone::DeleteInstance(
|
|
CObjPath & ObjectPath,
|
|
long lFlags,
|
|
IWbemContext * pCtx,
|
|
IWbemObjectSink * pHandler)
|
|
{
|
|
CDnsWrap& dns = CDnsWrap::DnsObject();
|
|
SCODE sc = dns.dnsDeleteZone(ObjectPath);
|
|
pHandler->SetStatus(
|
|
0,
|
|
sc,
|
|
NULL,
|
|
NULL);
|
|
return sc;
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// Description:
|
|
// execute methods defined in the mof
|
|
//
|
|
// Arguments:
|
|
// ObjPath [IN] pointing to the object that the
|
|
// method should be performed on
|
|
// wzMethodName [IN] name of the method to be invoked
|
|
// lFlags [IN] WMI flag
|
|
// pInParams [IN] Input parameters for the method
|
|
// pHandler [IN] WMI sink pointer
|
|
//
|
|
// Return Value:
|
|
// WBEM_S_NO_ERROR
|
|
// WBEM_E_INVALID_PARAMETER
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
SCODE
|
|
CDnsZone::ExecuteMethod(
|
|
CObjPath & ObjPath,
|
|
WCHAR * wzMethodName,
|
|
long lFlag,
|
|
IWbemClassObject * pInArgs,
|
|
IWbemObjectSink * pHandler)
|
|
{
|
|
DBG_FN( "CDnsZone::ExecuteMethod" )
|
|
|
|
CDnsWrap& dns = CDnsWrap::DnsObject();
|
|
wstring wstrZoneName = ObjPath.GetStringValueForProperty(
|
|
PVD_DOMAIN_CONTAINER_NAME);
|
|
string strZoneName;
|
|
WcharToString(wstrZoneName.data(), strZoneName);
|
|
SCODE sc;
|
|
if(_wcsicmp(wzMethodName, PVD_MTH_ZONE_PAUSEZONE) == 0)
|
|
{
|
|
//sc = dns.dnsPauseZone(strZoneName.data());
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_PAUSE_ZONE);
|
|
}
|
|
else if(_wcsicmp(wzMethodName, PVD_MTH_ZONE_RESUMEZONE) == 0)
|
|
{
|
|
//sc = dns.dnsResumeZone(strZoneName.data());
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_RESUME_ZONE);
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_RELOADZONE ) == 0)
|
|
{
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_RELOAD_ZONE);
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_FORCEREFRESH ) == 0)
|
|
{
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_REFRESH_SECONDARY);
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_UPDATEFROMDS ) == 0)
|
|
{
|
|
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_DS_UPDATE );
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_WRITEBACKZONETOFILE ) == 0)
|
|
{
|
|
sc = dns.dnsOperation(
|
|
strZoneName,
|
|
CDnsWrap::DNS_WRAP_WRITE_BACK_ZONE);
|
|
}
|
|
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_CHANGEZONETYPE) == 0)
|
|
{
|
|
CWbemClassObject Inst(pInArgs);
|
|
string strDataFile, strAdmin;
|
|
DWORD *pIp=NULL, cIp=0, dwZoneType=-1;
|
|
|
|
Inst.GetProperty(
|
|
strDataFile,
|
|
PVD_MTH_ZONE_ARG_DATAFILENAME);
|
|
|
|
Inst.GetProperty(
|
|
strAdmin,
|
|
PVD_MTH_ZONE_ARG_ADMINEMAILNAME);
|
|
|
|
Inst.GetProperty(
|
|
&pIp,
|
|
&cIp,
|
|
PVD_MTH_ZONE_ARG_IPADDRARRAY);
|
|
Inst.GetProperty(
|
|
&dwZoneType,
|
|
PVD_MTH_ZONE_ARG_ZONETYPE);
|
|
|
|
sc = dns.dnsZoneChangeType(
|
|
strZoneName,
|
|
dwZoneType,
|
|
strDataFile,
|
|
strAdmin,
|
|
pIp,
|
|
cIp);
|
|
delete [] pIp;
|
|
}
|
|
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_CREATEZONE) == 0)
|
|
{
|
|
CWbemClassObject Inst(pInArgs);
|
|
CWbemClassObject wcoOutArgs;
|
|
CWbemClassObject wcoOutArgsClass;
|
|
string strDataFile, strAdmin, strNewZoneName;
|
|
strAdmin = "Admin";
|
|
DWORD *pIp=NULL, cIp=0, dwZoneType=-1;
|
|
|
|
sc = m_pClass->GetMethod(wzMethodName, 0, NULL, &wcoOutArgsClass );
|
|
if( FAILED ( sc ) )
|
|
{
|
|
return sc;
|
|
}
|
|
|
|
wcoOutArgsClass.SpawnInstance(0, & wcoOutArgs);
|
|
|
|
Inst.GetProperty(
|
|
strDataFile,
|
|
PVD_MTH_ZONE_ARG_DATAFILENAME);
|
|
|
|
Inst.GetProperty(
|
|
strAdmin,
|
|
PVD_MTH_ZONE_ARG_ADMINEMAILNAME);
|
|
|
|
Inst.GetProperty(
|
|
&pIp,
|
|
&cIp,
|
|
PVD_MTH_ZONE_ARG_IPADDRARRAY);
|
|
Inst.GetProperty(
|
|
&dwZoneType,
|
|
PVD_MTH_ZONE_ARG_ZONETYPE);
|
|
Inst.GetProperty(
|
|
strNewZoneName,
|
|
PVD_MTH_ZONE_ARG_ZONENAME);
|
|
|
|
sc = dns.dnsZoneCreate(
|
|
strNewZoneName,
|
|
dwZoneType,
|
|
strDataFile,
|
|
strAdmin,
|
|
pIp,
|
|
cIp);
|
|
if ( SUCCEEDED ( sc ) )
|
|
{
|
|
CWbemClassObject wco;
|
|
wstring wstrObjPath;
|
|
m_pClass->SpawnInstance( 0 , & wco );
|
|
|
|
|
|
wco.SetProperty(
|
|
PVD_DNS_LOCAL_SERVER,
|
|
PVD_DOMAIN_SERVER_NAME );
|
|
wco.SetProperty(
|
|
strNewZoneName.data(),
|
|
PVD_DOMAIN_CONTAINER_NAME );
|
|
wco.SetProperty(
|
|
strNewZoneName.data(),
|
|
PVD_DOMAIN_FQDN );
|
|
wco.GetProperty(
|
|
wstrObjPath,
|
|
L"__RelPath");
|
|
wcoOutArgs.SetProperty(
|
|
wstrObjPath,
|
|
L"RR" );
|
|
pHandler->Indicate( 1, & wcoOutArgs );
|
|
}
|
|
delete [] pIp;
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_RESETSECONDARYIPARRAY) == 0)
|
|
{
|
|
DNS_DEBUG( INSTPROV, (
|
|
"%s: executing %S\n", fn, PVD_MTH_ZONE_RESETSECONDARYIPARRAY ));
|
|
|
|
CWbemClassObject Inst(pInArgs);
|
|
DWORD *pSecondaryIp=NULL, cSecondaryIp=0, dwSecurity=-1;
|
|
DWORD *pNotifyIp=NULL, cNotifyIp=0, dwNotify=-1;
|
|
|
|
Inst.GetProperty(
|
|
&pSecondaryIp,
|
|
&cSecondaryIp,
|
|
PVD_MTH_ZONE_ARG_SECONDARYIPARRAY);
|
|
Inst.GetProperty(
|
|
&pNotifyIp,
|
|
&cNotifyIp,
|
|
PVD_MTH_ZONE_ARG_NOTIFYIPARRAY);
|
|
|
|
Inst.GetProperty(
|
|
&dwSecurity,
|
|
PVD_MTH_ZONE_ARG_SECURITY);
|
|
Inst.GetProperty(
|
|
&dwNotify,
|
|
PVD_MTH_ZONE_ARG_NOTIFY);
|
|
|
|
sc = dns.dnsZoneResetSecondary(
|
|
strZoneName,
|
|
dwSecurity,
|
|
pSecondaryIp,
|
|
cSecondaryIp,
|
|
dwNotify,
|
|
pNotifyIp,
|
|
cNotifyIp);
|
|
|
|
DNS_DEBUG( INSTPROV, (
|
|
"%s: dnsZoneResetSecondary returned 0x%08X\n", fn, sc ));
|
|
|
|
delete [] pSecondaryIp;
|
|
delete [] pNotifyIp;
|
|
}
|
|
else if(_wcsicmp(
|
|
wzMethodName,
|
|
PVD_MTH_ZONE_GETDISTINGUISHEDNAME) == 0)
|
|
{
|
|
wstring wstrName;
|
|
CWbemClassObject OutParams, OutClass, Class ;
|
|
HRESULT hr;
|
|
|
|
dns.dnsDsZoneName(wstrName, wstrZoneName);
|
|
|
|
|
|
BSTR ClassName=NULL;
|
|
ClassName = AllocBstr(PVD_CLASS_ZONE);
|
|
hr = m_pNamespace->GetObject(ClassName, 0, 0, &Class, NULL);
|
|
SysFreeString(ClassName);
|
|
if ( SUCCEEDED ( hr ) )
|
|
{
|
|
Class.GetMethod(wzMethodName, 0, NULL, &OutClass);
|
|
OutClass.SpawnInstance(0, &OutParams);
|
|
OutParams.SetProperty(wstrName, PVD_DNS_RETURN_VALUE);
|
|
hr = pHandler->Indicate(1, &OutParams);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
else
|
|
|
|
{
|
|
return WBEM_E_NOT_SUPPORTED;
|
|
}
|
|
return sc;
|
|
}
|