//
// Copyright (C) 1997, Microsoft Corporation
//
// File: ftsup.cxx
//
// Contents: This module contains the functions which deal with ftdfs removal
//
// History: 07-Dec-1998 JHarper Created.
//
//--------------------------------------------------------------------------
#include "headers.hxx"
#pragma hdrstop
#include "marshal.hxx"
#include "winldap.h"
#include "dsgetdc.h"
#include "setup.hxx"
#include "ftsup.hxx"
#include "dfsmwml.h"
#if DBG
void
DumpBuf(
PCHAR cp,
ULONG len);
#endif // DBG
extern PLDAP pLdapConnection;
//+------------------------------------------------------------------------
//
// Function: DfsGetDsBlob
//
// Synopsis: Reads a Dfs BLOB from the DS
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsGetDsBlob(
LPWSTR wszFtDfsName,
LPWSTR wszDcName,
ULONG *pcbBlob,
BYTE **ppBlob)
{
DWORD dwErr;
LDAP *pldap = NULL;
PLDAPMessage pMsg = NULL;
PLDAP_BERVAL *rgldapPktBlob = NULL;
PLDAP_BERVAL pldapPktBlob;
LDAPMessage *pmsgServers;
DWORD i;
WCHAR *wszConfigurationDN = NULL;
WCHAR wszDfsConfigDN[MAX_PATH+1];
LPWSTR rgAttrs[5];
BYTE *pBlob = NULL;
ULONG cLen = 0;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetDsBlob(%ws,%ws)\n", wszFtDfsName, wszDcName);
#endif
dwErr = DfspLdapOpen(wszDcName, &pldap, &wszConfigurationDN);
if (dwErr != ERROR_SUCCESS)
goto Cleanup;
//
// Build the entry name we want to search in
//
cLen = wcslen(L"CN=") +
wcslen(wszFtDfsName) +
wcslen(L",") +
wcslen(wszConfigurationDN) +
1;
if (cLen > MAX_PATH) {
dwErr = ERROR_DS_NAME_TOO_LONG;
goto Cleanup;
}
wcscpy(wszDfsConfigDN,L"CN=");
wcscat(wszDfsConfigDN,wszFtDfsName);
wcscat(wszDfsConfigDN,L",");
wcscat(wszDfsConfigDN,wszConfigurationDN);
#if DBG
if (DfsSvcVerbose)
DbgPrint("wszDfsConfigDN=[%ws]\n", wszDfsConfigDN);
#endif
rgAttrs[0] = L"pKT";
rgAttrs[1] = NULL;
if (DfsSvcLdap)
DbgPrint("DfsGetDsBlob:ldap_search_s(%ws)\n", rgAttrs[0]);
dwErr = ldap_search_sW(
pldap,
wszDfsConfigDN,
LDAP_SCOPE_BASE,
L"(objectClass=*)",
rgAttrs,
0,
&pMsg);
DFSM_TRACE_ERROR_HIGH(dwErr, ALL_ERROR,
DfsGetDsBlob_Error_ldap_search_sW,
LOGULONG(dwErr));
if (dwErr != LDAP_SUCCESS) {
dwErr = LdapMapErrorToWin32(dwErr);
goto Cleanup;
}
pmsgServers = ldap_first_entry(pldap, pMsg);
if (pmsgServers == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
rgldapPktBlob = ldap_get_values_lenW(
pldap,
pMsg,
L"pKT");
if (rgldapPktBlob == NULL || *rgldapPktBlob == NULL) {
dwErr = ERROR_INTERNAL_DB_CORRUPTION;
goto Cleanup;
}
pldapPktBlob = rgldapPktBlob[0];
pBlob = (BYTE *)malloc(pldapPktBlob->bv_len);
if (pBlob == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
RtlCopyMemory(pBlob, pldapPktBlob->bv_val, pldapPktBlob->bv_len);
*ppBlob = pBlob;
*pcbBlob = pldapPktBlob->bv_len;
Cleanup:
if (rgldapPktBlob != NULL)
ldap_value_free_len(rgldapPktBlob);
if (pMsg != NULL)
ldap_msgfree( pMsg );
if (pldap != NULL && pldap != pLdapConnection) {
if (DfsSvcLdap)
DbgPrint("DfsGetDsBlob:ldap_unbind()\n");
ldap_unbind( pldap );
}
if (wszConfigurationDN != NULL)
free(wszConfigurationDN);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetDsBlob returning %d\n", dwErr);
#endif
return (dwErr);
}
//+------------------------------------------------------------------------
//
// Function: DfsPutDsBlob
//
// Synopsis: Updates a Dfs BLOB in the DS
//
// History: 12/8/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsPutDsBlob(
LPWSTR wszFtDfsName,
LPWSTR wszDcName,
ULONG cbBlob,
BYTE *pBlob)
{
DWORD dwErr;
LDAP *pldap = NULL;
GUID idNewPkt;
LDAP_BERVAL ldapVal;
PLDAP_BERVAL rgldapVals[2];
LDAPModW ldapMod;
LDAP_BERVAL ldapIdVal;
PLDAP_BERVAL rgldapIdVals[2];
LDAPModW ldapIdMod;
PLDAPModW rgldapMods[3];
WCHAR *wszConfigurationDN = NULL;
WCHAR wszDfsConfigDN[MAX_PATH+1];
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsPutDsBlob(%ws,%ws)\n", wszFtDfsName, wszDcName);
#endif
dwErr = DfspLdapOpen(wszDcName, &pldap, &wszConfigurationDN);
if (dwErr != ERROR_SUCCESS)
goto Cleanup;
//
// Build the entry name
//
wcscpy(wszDfsConfigDN,L"CN=");
wcscat(wszDfsConfigDN,wszFtDfsName);
wcscat(wszDfsConfigDN,L",");
wcscat(wszDfsConfigDN,wszConfigurationDN);
#if DBG
if (DfsSvcVerbose)
DbgPrint("wszDfsConfigDN=[%ws]\n", wszDfsConfigDN);
#endif
UuidCreate( &idNewPkt );
ldapIdVal.bv_len = sizeof(GUID);
ldapIdVal.bv_val = (PCHAR) &idNewPkt;
rgldapIdVals[0] = &ldapIdVal;
rgldapIdVals[1] = NULL;
ldapIdMod.mod_op = LDAP_MOD_REPLACE | LDAP_MOD_BVALUES;
ldapIdMod.mod_type = L"pKTGuid";
ldapIdMod.mod_vals.modv_bvals = rgldapIdVals;
ldapVal.bv_len = cbBlob;
ldapVal.bv_val = (PCHAR) pBlob;
rgldapVals[0] = &ldapVal;
rgldapVals[1] = NULL;
ldapMod.mod_op = LDAP_MOD_REPLACE | LDAP_MOD_BVALUES;
ldapMod.mod_type = L"pKT";
ldapMod.mod_vals.modv_bvals = rgldapVals;
rgldapMods[0] = &ldapMod;
rgldapMods[1] = &ldapIdMod;
rgldapMods[2] = NULL;
#if DBG
if (DfsSvcVerbose)
DbgPrint("Writing BLOB of %d bytes\n", cbBlob);
#endif
if (DfsSvcLdap)
DbgPrint("DfsPutDsBlob:ldap_modify(%ws)\n", L"pKTGuid and pKT");
dwErr = ldap_modify_sW(
pldap,
wszDfsConfigDN,
rgldapMods);
DFSM_TRACE_ERROR_HIGH(dwErr, ALL_ERROR,
DfsPutDsBlob_Error_ldap_modify_sW,
LOGULONG(dwErr));
#if DBG
if (DfsSvcVerbose) {
DbgPrint("ldap_modify_sW returned %d\n", dwErr);
}
#endif
if (pldap != pLdapConnection) {
if (DfsSvcLdap)
DbgPrint("DfsPutDsBlob(1):ldap_unbind()\n");
ldap_unbind(pldap);
pldap = NULL;
}
if (dwErr != LDAP_SUCCESS) {
dwErr = LdapMapErrorToWin32(dwErr);
} else {
dwErr = ERROR_SUCCESS;
}
Cleanup:
if (pldap != NULL && pldap != pLdapConnection) {
if (DfsSvcLdap)
DbgPrint("DfsPutDsBlob(2):ldap_unbind()\n");
ldap_unbind( pldap );
}
if (wszConfigurationDN != NULL)
free(wszConfigurationDN);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsPutDsBlob returning %d\n", dwErr);
#endif
return (dwErr);
}
//+------------------------------------------------------------------------
//
// Function: DfsGetVolList
//
// Synopsis: Unserializes an FtDfs BLOB and creates
// a volume list representing an FtDfs.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsGetVolList(
ULONG cbBlob,
BYTE *pBlob,
PDFS_VOLUME_LIST pDfsVolList)
{
DWORD dwErr;
DWORD cObj;
DWORD cVol;
LDAP_PKT LdapPkt;
MARSHAL_BUFFER marshalBuffer;
NTSTATUS NtStatus;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetVolList()\n");
#endif
RtlZeroMemory(&LdapPkt, sizeof(LDAP_PKT));
if (cbBlob > sizeof(DWORD)) {
_GetULong(pBlob, pDfsVolList->Version);
#if DBG
if (DfsSvcVerbose) {
DbgPrint("Blob Version = %d\n", pDfsVolList->Version);
DbgPrint("BLOB is %d bytes:\n", cbBlob);
}
#endif
MarshalBufferInitialize(
&marshalBuffer,
cbBlob - sizeof(DWORD),
pBlob + sizeof(DWORD));
NtStatus = DfsRtlGet(&marshalBuffer, &MiLdapPkt, &LdapPkt);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
#if DBG
if (DfsSvcVerbose) {
DbgPrint(" %d objects found\n", LdapPkt.cLdapObjects);
for (cObj = 0; cObj < LdapPkt.cLdapObjects; cObj++) {
DbgPrint("%d:name=%ws size=%d p=0x%x\n",
cObj,
LdapPkt.rgldapObjects[cObj].wszObjectName,
LdapPkt.rgldapObjects[cObj].cbObjectData,
LdapPkt.rgldapObjects[cObj].pObjectData);
// DumpBuf(
// LdapPkt.rgldapObjects[cObj].pObjectData,
// LdapPkt.rgldapObjects[cObj].cbObjectData);
}
}
#endif
for (cObj = 0; cObj < LdapPkt.cLdapObjects; cObj++) {
if (wcscmp(LdapPkt.rgldapObjects[cObj].wszObjectName, L"\\siteroot") != 0) {
pDfsVolList->VolCount++;
}
}
pDfsVolList->Volumes = (PDFS_VOLUME) malloc(pDfsVolList->VolCount * sizeof(DFS_VOLUME));
if (pDfsVolList->Volumes == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
RtlZeroMemory(pDfsVolList->Volumes, pDfsVolList->VolCount * sizeof(DFS_VOLUME));
//
// Save the true/allocated size so to optimize deletions/additions
//
pDfsVolList->AllocatedVolCount = pDfsVolList->VolCount;
#if DBG
if (DfsSvcVerbose)
DbgPrint("===============================\n");
#endif
for (cVol = cObj = 0; cObj < LdapPkt.cLdapObjects; cObj++) {
if (wcscmp(LdapPkt.rgldapObjects[cObj].wszObjectName, L"\\siteroot") == 0) {
dwErr = DfsGetSiteTable(
pDfsVolList,
&LdapPkt.rgldapObjects[cObj]);
} else {
dwErr = DfsGetVolume(
&pDfsVolList->Volumes[cVol],
&LdapPkt.rgldapObjects[cObj]);
}
if (dwErr != ERROR_SUCCESS)
goto Cleanup;
cVol++;
}
} else if (cbBlob == sizeof(DWORD)) {
#if DBG
if (DfsSvcVerbose)
DbgPrint("pKT BLOB is simply one DWORD\n");
#endif
dwErr = ERROR_INTERNAL_DB_CORRUPTION;
} else {
#if DBG
if (DfsSvcVerbose)
DbgPrint("pKT BLOB is corrupt!\n");
#endif
dwErr = ERROR_INTERNAL_DB_CORRUPTION;
}
Cleanup:
FreeLdapPkt(&LdapPkt);
//
// Do any recovery needed
//
if(pDfsVolList && pDfsVolList->Volumes) {
DWORD dwErr2 = DfsRecoverVolList(pDfsVolList);
if(dwErr == ERROR_SUCCESS) {
// this is to prevent masking the previous error.
dwErr = dwErr2;
}
}
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetVolList returning %d\n", dwErr);
#endif
return( dwErr );
}
//+------------------------------------------------------------------------
//
// Function: DfsGetVolume
//
// Synopsis: Unserializes the data in a buffer/blob to a volume
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsGetVolume(
PDFS_VOLUME pVolume,
PLDAP_OBJECT pLdapObject)
{
DFS_VOLUME_PROPERTIES VolProps;
DWORD dwErr = ERROR_SUCCESS;
MARSHAL_BUFFER marshalBuffer;
NTSTATUS NtStatus;
PBYTE pBuffer = NULL;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetVolume(%ws,%d)\n",
pLdapObject->wszObjectName,
pLdapObject->cbObjectData);
#endif
RtlZeroMemory(&VolProps, sizeof(DFS_VOLUME_PROPERTIES));
pVolume->wszObjectName = (WCHAR *) malloc(
(wcslen(pLdapObject->wszObjectName)+1) * sizeof(WCHAR));
if (pVolume->wszObjectName == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
wcscpy(
pVolume->wszObjectName,
pLdapObject->wszObjectName);
MarshalBufferInitialize(
&marshalBuffer,
pLdapObject->cbObjectData,
pLdapObject->pObjectData);
NtStatus = DfsRtlGet(
&marshalBuffer,
&MiVolumeProperties,
&VolProps);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
VolProps.dwTimeout = 300;
if (
(marshalBuffer.Current < marshalBuffer.Last)
&&
(marshalBuffer.Last - marshalBuffer.Current) == sizeof(ULONG)
) {
DfsRtlGetUlong(&marshalBuffer, &VolProps.dwTimeout);
}
pVolume->idVolume = VolProps.idVolume;
pVolume->wszPrefix = VolProps.wszPrefix;
pVolume->wszShortPrefix = VolProps.wszShortPrefix;
pVolume->dwType = VolProps.dwType;
pVolume->dwState = VolProps.dwState;
pVolume->wszComment = VolProps.wszComment;
pVolume->dwTimeout = VolProps.dwTimeout;
pVolume->ftPrefix = VolProps.ftPrefix;
pVolume->ftState = VolProps.ftState;
pVolume->ftComment = VolProps.ftComment;
pVolume->dwVersion = VolProps.dwVersion;
pVolume->cbRecovery = VolProps.cbRecovery;
pVolume->pRecovery = VolProps.pRecovery;
pBuffer = VolProps.pSvc;
#if DBG
if (DfsSvcVerbose)
DbgPrint("VolProps.cbSvc = %d\n", VolProps.cbSvc);
#endif
dwErr = UnSerializeReplicaList(
&pVolume->ReplCount,
&pVolume->AllocatedReplCount,
&pVolume->ReplicaInfo,
&pVolume->FtModification,
&pBuffer);
if (dwErr != ERROR_SUCCESS) {
goto Cleanup;
}
//
// Get deleted replicas
//
if (pBuffer < (pBuffer + VolProps.cbSvc)) {
dwErr = UnSerializeReplicaList(
&pVolume->DelReplCount,
&pVolume->AllocatedDelReplCount,
&pVolume->DelReplicaInfo,
&pVolume->DelFtModification,
&pBuffer);
if (dwErr != ERROR_SUCCESS) {
goto Cleanup;
}
}
Cleanup:
if (VolProps.pSvc != NULL)
MarshalBufferFree(VolProps.pSvc);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetVolume returning %d\n", dwErr);
#endif
return dwErr;
}
//+------------------------------------------------------------------------
//
// Function: DfsFreeVolList
//
// Synopsis: Frees the volume list and associated substructures representing
// an FtDfs.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
VOID
DfsFreeVolList(
PDFS_VOLUME_LIST pDfsVolList)
{
ULONG cVol;
ULONG cSite;
ULONG i;
PLIST_ENTRY pListHead;
PDFSM_SITE_ENTRY pSiteEntry;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsFreeVolList()\n");
#endif
if (pDfsVolList->VolCount > 0 && pDfsVolList->Volumes) {
for (cVol = 0; cVol < pDfsVolList->VolCount; cVol++) {
DfsFreeVol(&pDfsVolList->Volumes[cVol]);
}
}
if (pDfsVolList->Volumes != NULL)
free(pDfsVolList->Volumes);
pListHead = &pDfsVolList->SiteList;
if (pListHead->Flink != NULL) {
while (pListHead->Flink != pListHead) {
pSiteEntry = CONTAINING_RECORD(pListHead->Flink, DFSM_SITE_ENTRY, Link);
RemoveEntryList(pListHead->Flink);
for (i = 0; i < pSiteEntry->Info.cSites; i++) {
if (pSiteEntry->Info.Site[i].SiteName != NULL)
MarshalBufferFree(pSiteEntry->Info.Site[i].SiteName);
}
if (pSiteEntry->ServerName != NULL)
MarshalBufferFree(pSiteEntry->ServerName);
free(pSiteEntry);
}
}
RtlZeroMemory(pDfsVolList, sizeof(DFS_VOLUME_LIST));
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsFreeVolList exit\n");
#endif
}
//+------------------------------------------------------------------------
//
// Function: DfsFreeVol
//
// Synopsis: Frees the volume and associated substructures representing
// an FtDfs volume
//
// History: 12/16/98 JHarper Created
//
//-------------------------------------------------------------------------
VOID
DfsFreeVol(
PDFS_VOLUME pVol)
{
ULONG cRepl;
#if DBG
if (DfsSvcVerbose & 0x80000000)
DbgPrint("DfsFreeVol()\n");
#endif
if (pVol->ReplCount > 0 && pVol->ReplicaInfo != NULL) {
for (cRepl = 0; cRepl < pVol->ReplCount; cRepl++) {
DfsFreeRepl(&pVol->ReplicaInfo[cRepl]);
}
}
if (pVol->DelReplCount > 0 && pVol->DelReplicaInfo != NULL) {
for (cRepl = 0; cRepl < pVol->DelReplCount; cRepl++) {
DfsFreeRepl(&pVol->DelReplicaInfo[cRepl]);
}
}
if (pVol->wszPrefix != NULL)
MarshalBufferFree(pVol->wszPrefix);
if (pVol->wszShortPrefix != NULL)
MarshalBufferFree(pVol->wszShortPrefix);
if (pVol->wszComment != NULL)
MarshalBufferFree(pVol->wszComment);
if (pVol->pRecovery != NULL)
MarshalBufferFree(pVol->pRecovery);
if (pVol->ReplicaInfo != NULL)
free(pVol->ReplicaInfo);
if (pVol->DelReplicaInfo != NULL)
free(pVol->DelReplicaInfo);
if (pVol->FtModification != NULL)
free(pVol->FtModification);
if (pVol->DelFtModification != NULL)
free(pVol->DelFtModification);
if (pVol->wszObjectName != NULL)
free(pVol->wszObjectName);
RtlZeroMemory(pVol, sizeof(DFS_VOLUME));
#if DBG
if (DfsSvcVerbose & 0x80000000)
DbgPrint("DfsFreeVol exit\n");
#endif
}
//+------------------------------------------------------------------------
//
// Function: DfsFreeRepl
//
// Synopsis: Frees the Replica and associated substructures representing
// an FtDfs replica
//
// History: 12/16/98 JHarper Created
//
//-------------------------------------------------------------------------
VOID
DfsFreeRepl(
PDFS_REPLICA_INFO pRepl)
{
#if DBG
if (DfsSvcVerbose & 0x80000000)
DbgPrint("DfsFreeRepl()\n");
#endif
if (pRepl->pwszServerName != NULL)
MarshalBufferFree(pRepl->pwszServerName);
if (pRepl->pwszShareName != NULL)
MarshalBufferFree(pRepl->pwszShareName);
RtlZeroMemory(pRepl, sizeof(DFS_REPLICA_INFO));
#if DBG
if (DfsSvcVerbose & 0x80000000)
DbgPrint("DfsFreeRepl exit\n");
#endif
}
//+------------------------------------------------------------------------
//
// Function: DfsPutVolList
//
// Synopsis: Serializes the structs representing a Dfs volume and
// creates a BLOB.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsPutVolList(
ULONG *pcbBlob,
BYTE **ppBlob,
PDFS_VOLUME_LIST pDfsVolList)
{
ULONG cVol;
ULONG cRepl;
ULONG cObj;
ULONG cBuffer;
ULONG cSite;
DWORD dwErr = ERROR_SUCCESS;
PBYTE Buffer = NULL;
MARSHAL_BUFFER marshalBuffer;
NTSTATUS NtStatus;
DFS_VOLUME_PROPERTIES VolProps;
LDAP_PKT LdapPkt;
PLIST_ENTRY pListHead;
PLIST_ENTRY pLink;
PDFSM_SITE_ENTRY pSiteEntry;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsPutVolList()\n");
#endif
LdapPkt.cLdapObjects = pDfsVolList->VolCount + 1;
LdapPkt.rgldapObjects = (PLDAP_OBJECT) malloc(LdapPkt.cLdapObjects * sizeof(LDAP_OBJECT));
if (LdapPkt.rgldapObjects == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
RtlZeroMemory(LdapPkt.rgldapObjects, LdapPkt.cLdapObjects * sizeof(LDAP_OBJECT));
//
// For each volume, serialize the replicas, then the volume
//
for (cVol = 0; cVol < pDfsVolList->VolCount; cVol++) {
RtlZeroMemory(&VolProps, sizeof(DFS_VOLUME_PROPERTIES));
LdapPkt.rgldapObjects[cVol].wszObjectName = (WCHAR *) MarshalBufferAllocate(
(wcslen(pDfsVolList->Volumes[cVol].wszObjectName)+1) * sizeof(WCHAR));
if (LdapPkt.rgldapObjects[cVol].wszObjectName == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
wcscpy(LdapPkt.rgldapObjects[cVol].wszObjectName, pDfsVolList->Volumes[cVol].wszObjectName);
//
// Serialize the replicas
//
dwErr = SerializeReplicaList(
pDfsVolList->Volumes[cVol].ReplCount,
pDfsVolList->Volumes[cVol].ReplicaInfo,
pDfsVolList->Volumes[cVol].FtModification,
pDfsVolList->Volumes[cVol].DelReplCount,
pDfsVolList->Volumes[cVol].DelReplicaInfo,
pDfsVolList->Volumes[cVol].DelFtModification,
&VolProps.cbSvc,
&VolProps.pSvc);
if (dwErr != ERROR_SUCCESS) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
#if DBG
if (DfsSvcVerbose)
DbgPrint(" cbSvc = %d\n", VolProps.cbSvc);
#endif
VolProps.idVolume = pDfsVolList->Volumes[cVol].idVolume;
VolProps.wszPrefix = pDfsVolList->Volumes[cVol].wszPrefix;
VolProps.wszShortPrefix = pDfsVolList->Volumes[cVol].wszShortPrefix;
VolProps.dwType = pDfsVolList->Volumes[cVol].dwType;
VolProps.dwState = pDfsVolList->Volumes[cVol].dwState;
VolProps.wszComment = pDfsVolList->Volumes[cVol].wszComment;
VolProps.dwTimeout = pDfsVolList->Volumes[cVol].dwTimeout;
VolProps.ftPrefix = pDfsVolList->Volumes[cVol].ftPrefix;
VolProps.ftState = pDfsVolList->Volumes[cVol].ftState;
VolProps.ftComment = pDfsVolList->Volumes[cVol].ftComment;
VolProps.dwVersion = pDfsVolList->Volumes[cVol].dwVersion;
VolProps.cbRecovery = pDfsVolList->Volumes[cVol].cbRecovery;
VolProps.pRecovery = pDfsVolList->Volumes[cVol].pRecovery;
//
// Now serialize the volume
cBuffer = 0;
NtStatus = DfsRtlSize(&MiVolumeProperties, &VolProps, &cBuffer);
if (!NT_SUCCESS(NtStatus)) {
MarshalBufferFree(VolProps.pSvc);
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
cBuffer += sizeof(ULONG);
#if DBG
if (DfsSvcVerbose)
DbgPrint("VolProps marshaled size = %d\n", cBuffer);
#endif
Buffer = (PBYTE) MarshalBufferAllocate(cBuffer);
if (Buffer == NULL) {
MarshalBufferFree(VolProps.pSvc);
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
LdapPkt.rgldapObjects[cVol].pObjectData = (PCHAR) Buffer;
LdapPkt.rgldapObjects[cVol].cbObjectData = cBuffer;
MarshalBufferInitialize(
&marshalBuffer,
cBuffer,
Buffer);
NtStatus = DfsRtlPut(&marshalBuffer, &MiVolumeProperties, &VolProps);
if (!NT_SUCCESS(NtStatus)) {
MarshalBufferFree(VolProps.pSvc);
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
NtStatus = DfsRtlPutUlong(&marshalBuffer, &VolProps.dwTimeout);
if (!NT_SUCCESS(NtStatus)) {
MarshalBufferFree(VolProps.pSvc);
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
MarshalBufferFree(VolProps.pSvc);
}
//
// Serialize the site table
//
cBuffer = sizeof(ULONG) + sizeof(GUID);
//
// Add the size of all the entries
//
pListHead = &pDfsVolList->SiteList;
for (pLink = pListHead->Flink; pLink != pListHead; pLink = pLink->Flink) {
pSiteEntry = CONTAINING_RECORD(pLink, DFSM_SITE_ENTRY, Link);
#if DBG
if (DfsSvcVerbose)
DbgPrint("pSiteEntry for %ws\n", pSiteEntry->ServerName);
#endif
NtStatus = DfsRtlSize(&MiDfsmSiteEntry, pSiteEntry, &cBuffer);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
}
//
// Get a buffer big enough
//
Buffer = (BYTE *) MarshalBufferAllocate(cBuffer);
if (Buffer == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
LdapPkt.rgldapObjects[pDfsVolList->VolCount].wszObjectName =
(WCHAR *)MarshalBufferAllocate(sizeof(L"\\siteroot"));
if (LdapPkt.rgldapObjects[pDfsVolList->VolCount].wszObjectName == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
wcscpy(LdapPkt.rgldapObjects[pDfsVolList->VolCount].wszObjectName, L"\\siteroot");
LdapPkt.rgldapObjects[pDfsVolList->VolCount].pObjectData = (PCHAR) Buffer;
LdapPkt.rgldapObjects[pDfsVolList->VolCount].cbObjectData = cBuffer;
MarshalBufferInitialize(
&marshalBuffer,
cBuffer,
Buffer);
//
// Put the guid, then the object count in the beginning of the buffer
//
DfsRtlPutGuid(&marshalBuffer, &pDfsVolList->SiteGuid);
DfsRtlPutUlong(&marshalBuffer, &pDfsVolList->SiteCount);
for (pLink = pListHead->Flink; pLink != pListHead; pLink = pLink->Flink) {
pSiteEntry = CONTAINING_RECORD(pLink, DFSM_SITE_ENTRY, Link);
DfsRtlPut(&marshalBuffer,&MiDfsmSiteEntry, pSiteEntry);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
}
#if DBG
if (DfsSvcVerbose) {
DbgPrint("After reserialization, %d objects found\n", LdapPkt.cLdapObjects);
for (cObj = 0; cObj < LdapPkt.cLdapObjects; cObj++) {
DbgPrint("%d:name=%ws size=%d p=0x%x\n",
cObj,
LdapPkt.rgldapObjects[cObj].wszObjectName,
LdapPkt.rgldapObjects[cObj].cbObjectData,
LdapPkt.rgldapObjects[cObj].pObjectData);
// DumpBuf(
// LdapPkt.rgldapObjects[cObj].pObjectData,
// LdapPkt.rgldapObjects[cObj].cbObjectData);
}
}
#endif
//
// Finally, serialize all the volumes and the site table into a blob
//
cBuffer = 0;
NtStatus = DfsRtlSize(&MiLdapPkt, &LdapPkt, &cBuffer);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(dwErr);
goto Cleanup;
}
cBuffer += sizeof(DWORD);
#if DBG
if (DfsSvcVerbose)
DbgPrint("New ldap size = %d\n", cBuffer);
#endif
Buffer = (PBYTE) malloc(cBuffer);
if (Buffer == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
// 447486. Fix prefix bug. use memory after checking for null
*((PDWORD) Buffer) = 2; // Version #
MarshalBufferInitialize(
&marshalBuffer,
cBuffer,
Buffer + sizeof(DWORD));
NtStatus = DfsRtlPut(&marshalBuffer, &MiLdapPkt, &LdapPkt);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(dwErr);
goto Cleanup;
}
#if DBG
if (DfsSvcVerbose)
DbgPrint("Remarshal succeeded cBuffer = %d\n", cBuffer);
#endif
*pcbBlob = cBuffer;
*ppBlob = Buffer;
Buffer = NULL;
Cleanup:
FreeLdapPkt(&LdapPkt);
if (dwErr != ERROR_SUCCESS && Buffer != NULL)
free(Buffer);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsPutVolList exit %d\n", dwErr);
#endif
return dwErr;
}
//+------------------------------------------------------------------------
//
// Function: FreeLdapPkt
//
// Synopsis: Frees an LDAP_PKT structure and all substructures.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
VOID
FreeLdapPkt(
LDAP_PKT *pLdapPkt)
{
ULONG cObj;
if (pLdapPkt->rgldapObjects != NULL) {
for (cObj = 0; cObj < pLdapPkt->cLdapObjects; cObj++) {
if (pLdapPkt->rgldapObjects[cObj].wszObjectName != NULL)
MarshalBufferFree(pLdapPkt->rgldapObjects[cObj].wszObjectName);
if (pLdapPkt->rgldapObjects[cObj].pObjectData != NULL)
MarshalBufferFree(pLdapPkt->rgldapObjects[cObj].pObjectData);
}
MarshalBufferFree(pLdapPkt->rgldapObjects);
}
}
//+------------------------------------------------------------------------
//
// Function: SerializeReplicaList
//
// Synopsis: This method serializes the replica info list and the
// deleted replica info list into a buffer.
//
// Returns: [ERROR_SUCCESS] -- If all went well.
//
// [ERROR_OUTOFMEMORY] - If unable to allocate the target buffer.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
SerializeReplicaList(
ULONG ReplCount,
DFS_REPLICA_INFO *pReplicaInfo,
FILETIME *pFtModification,
ULONG DelReplCount,
DFS_REPLICA_INFO *pDelReplicaInfo,
FILETIME *pDelFtModification,
ULONG *cBuffer,
PBYTE *ppBuffer)
{
DWORD dwErr = ERROR_SUCCESS;
ULONG TotalSize;
ULONG i;
ULONG *pSize;
BYTE *Buffer = NULL;
ULONG *SizeBuffer = NULL;
#if DBG
if (DfsSvcVerbose)
DbgPrint("SerializeReplicaList(%d,%d)\n", ReplCount, DelReplCount);
#endif
pSize = SizeBuffer = (PULONG) malloc(sizeof(ULONG) * (ReplCount + DelReplCount));
if (SizeBuffer == NULL) {
return ERROR_OUTOFMEMORY;
}
//
// Need all the size values now and later for marshalling stuff.
// So we collect them here into an array.
//
TotalSize = 0;
pSize = SizeBuffer;
for (i = 0; i < ReplCount; i++) {
*pSize = GetReplicaMarshalSize(&pReplicaInfo[i], &pFtModification[i]);
TotalSize += *pSize;
pSize++;
}
for (i = 0; i < DelReplCount; i++) {
*pSize = GetReplicaMarshalSize(&pDelReplicaInfo[i], &pDelFtModification[i]);
TotalSize += *pSize;
pSize++;
}
//
// Allocate the byte Buffer we need to pass back
//
// TotalSize is the size required just to marshal all the replicas and
// their last-modification-timestamps.
//
// In addition, we need:
//
// 1 ULONG for storing the count of replicas
// ReplCount ULONGs for storing the marshal size of each replica.
// 1 ULONG for count of deleted replicas
// DelReplCount ULONGS for storing the marshal size of each deleted Repl
//
//
// First calc the size of the Buffer.
//
TotalSize += sizeof(ULONG) * (1 + ReplCount + 1 + DelReplCount);
*ppBuffer = Buffer = (PBYTE) malloc(TotalSize);
if (Buffer == NULL) {
free(SizeBuffer);
return ERROR_OUTOFMEMORY;
}
//
// Set the number of entries to follow in the Buffer at the start.
//
_PutULong(Buffer, ReplCount);
Buffer += sizeof(ULONG);
pSize = SizeBuffer;
for (i = 0; i < ReplCount; i++) {
//
// Marshall each replica Entry into the Buffer.
// Remember we first need to put the size of the marshalled
// replica entry to follow, then the FILETIME for the replica,
// and finally, the marshalled replica entry structure.
//
_PutULong(Buffer, *pSize);
Buffer += sizeof(ULONG);
dwErr = SerializeReplica(&pReplicaInfo[i], &pFtModification[i], Buffer, *pSize);
if (dwErr != ERROR_SUCCESS) {
free(*ppBuffer);
return dwErr;
}
Buffer += *pSize;
pSize++;
}
//
// Now marshal the deleted Repl list.
//
_PutULong(Buffer, DelReplCount);
Buffer += sizeof(ULONG);
for (i = 0; i < DelReplCount; i++) {
_PutULong(Buffer, *pSize);
Buffer += sizeof(ULONG);
dwErr = SerializeReplica(&pDelReplicaInfo[i], &pDelFtModification[i], Buffer, *pSize);
if (dwErr != ERROR_SUCCESS) {
free(*ppBuffer);
return dwErr;
}
Buffer += *pSize;
pSize++;
}
*cBuffer = TotalSize;
#if DBG
if (DfsSvcVerbose)
DbgPrint("SerializeReplicaList exit %d\n", dwErr);
#endif
return( dwErr );
}
//+------------------------------------------------------------------------
//
// Member: SerializeReplica
//
// Synopsis: Serializes a replica info structure
//
// Notes: The size of the buffer should have been calculated using
// the function GetReplicaMarshalSize()
//
// History: 13-May-93 SudK Created.
// 19-Nov-98 Jharper Modified.
//
//-------------------------------------------------------------------------
DWORD
SerializeReplica(
DFS_REPLICA_INFO *pDfsReplicaInfo,
FILETIME *pFtModification,
PBYTE Buffer,
ULONG Size)
{
DWORD dwErr;
MARSHAL_BUFFER MarshalBuffer;
NTSTATUS NtStatus;
MarshalBufferInitialize(&MarshalBuffer, Size, Buffer);
NtStatus = DfsRtlPut(&MarshalBuffer, &MiFileTime, pFtModification);
if (NT_SUCCESS(NtStatus))
NtStatus = DfsRtlPut(&MarshalBuffer, &MiDfsReplicaInfo, pDfsReplicaInfo);
dwErr = RtlNtStatusToDosError(NtStatus);
return dwErr;
}
//+----------------------------------------------------------------------
//
// Member: GetReplicaMarshalSize, public
//
// Synopsis: Returns the size of a buffer required to marshal this
// replica.
//
// History: 12-May-93 SudK Created.
// 19-Nov-98 Jharper Modified.
//
//-----------------------------------------------------------------------
ULONG
GetReplicaMarshalSize(
DFS_REPLICA_INFO *pDfsReplicaInfo,
FILETIME *pFtModification)
{
ULONG Size = 0;
NTSTATUS NtStatus;
NtStatus = DfsRtlSize(&MiFileTime, pFtModification, &Size);
if (NT_SUCCESS(NtStatus))
NtStatus = DfsRtlSize(&MiDfsReplicaInfo, pDfsReplicaInfo, &Size);
return(Size);
}
//+------------------------------------------------------------------------
//
// Member: UnSerializeReplicaList
//
// Synopsis: Unserializes a buffer into a relica list.
//
// History: 20-Nov-98 Jharper created
//
//-------------------------------------------------------------------------
DWORD
UnSerializeReplicaList(
ULONG *pReplCount,
ULONG *pAllocatedReplCount,
DFS_REPLICA_INFO **ppReplicaInfo,
FILETIME **ppFtModification,
BYTE **ppBuffer)
{
DFS_REPLICA_INFO *pReplicaInfo = NULL;
FILETIME *pFtModification = NULL;
ULONG ReplCount;
BYTE *pBuffer = *ppBuffer;
ULONG cRepl;
ULONG Size;
DWORD dwErr = ERROR_SUCCESS;
MARSHAL_BUFFER marshalBuffer;
NTSTATUS NtStatus;
//
// Get # replicas
//
_GetULong(pBuffer, ReplCount);
pBuffer += sizeof(ULONG);
pReplicaInfo = (DFS_REPLICA_INFO *) malloc(sizeof(DFS_REPLICA_INFO) * ReplCount);
pFtModification = (FILETIME *) malloc(sizeof(FILETIME) * ReplCount);
if(pReplicaInfo == NULL || pFtModification == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
//
// Now get each replica
//
for (cRepl = 0; cRepl < ReplCount; cRepl++) {
_GetULong(pBuffer, Size);
pBuffer += sizeof(ULONG);
MarshalBufferInitialize(
&marshalBuffer,
Size,
pBuffer);
NtStatus = DfsRtlGet(
&marshalBuffer,
&MiFileTime,
&pFtModification[cRepl]);
if (NT_SUCCESS(NtStatus)) {
NtStatus = DfsRtlGet(
&marshalBuffer,
&MiDfsReplicaInfo,
&pReplicaInfo[cRepl]);
}
if (NT_SUCCESS(NtStatus)) {
pBuffer += Size;
}
}
*ppReplicaInfo = pReplicaInfo;
*ppFtModification = pFtModification;
*ppBuffer = pBuffer;
*pAllocatedReplCount = *pReplCount = ReplCount;
Cleanup:
if (dwErr != ERROR_SUCCESS) {
if (pReplicaInfo != NULL)
free(pReplicaInfo);
if (pFtModification != NULL)
free(pFtModification);
}
return dwErr;
}
//+------------------------------------------------------------------------
//
// Function: DfsGetSiteTable
//
// Synopsis: Unserializes the buffer passed in into a dfs site table.
//
// Returns: [ERROR_SUCCESS] -- If all went well.
//
// [ERROR_OUTOFMEMORY] - If unable to allocate the target buffer.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsGetSiteTable(
PDFS_VOLUME_LIST pDfsVolList,
PLDAP_OBJECT pLdapObject)
{
DWORD dwErr = ERROR_SUCCESS;
NTSTATUS NtStatus;
ULONG cSite;
PDFSM_SITE_ENTRY pSiteEntry;
PDFSM_SITE_ENTRY pTmpSiteEntry;
MARSHAL_BUFFER marshalBuffer;
BYTE *pBuffer = NULL;
ULONG Size;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetSiteTable(%d)\n", pLdapObject->cbObjectData);
#endif
InitializeListHead(&pDfsVolList->SiteList);
MarshalBufferInitialize(
&marshalBuffer,
pLdapObject->cbObjectData,
pLdapObject->pObjectData);
NtStatus = DfsRtlGetGuid(&marshalBuffer, &pDfsVolList->SiteGuid);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
NtStatus = DfsRtlGetUlong(&marshalBuffer, &pDfsVolList->SiteCount);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
pBuffer = (BYTE *)malloc(pLdapObject->cbObjectData);
if (pBuffer == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
pTmpSiteEntry = (PDFSM_SITE_ENTRY)pBuffer;
for (cSite = 0; cSite < pDfsVolList->SiteCount; cSite++) {
RtlZeroMemory(pBuffer, pLdapObject->cbObjectData);
NtStatus = DfsRtlGet(
&marshalBuffer,
&MiDfsmSiteEntry,
pBuffer);
if (!NT_SUCCESS(NtStatus)) {
dwErr = RtlNtStatusToDosError(NtStatus);
goto Cleanup;
}
Size = sizeof(DFSM_SITE_ENTRY) + (pTmpSiteEntry->Info.cSites * sizeof(DFS_SITENAME_INFO));
pSiteEntry = (PDFSM_SITE_ENTRY) malloc(Size);
if (pSiteEntry == NULL) {
dwErr = ERROR_OUTOFMEMORY;
goto Cleanup;
}
RtlCopyMemory(pSiteEntry, pBuffer, Size);
InsertHeadList(&pDfsVolList->SiteList, &pSiteEntry->Link);
}
Cleanup:
if (pBuffer != NULL)
free(pBuffer);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsGetSiteTable exit dwErr=%d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: GetNetInfoEx
//
// Synopsis: Gets information about the volume.
//
// Arguments: [Level] -- Level of Information desired.
//
// [pDfsVol] - Pointer to DFS_VOLUME to use to fill the info
//
// [pInfo] -- Pointer to info struct to be filled. Pointer
// members will be allocated using MIDL_user_allocate.
// The type of this variable is LPDFS_INFO_3, but one
// can pass in pointers to lower levels, and only the
// fields appropriate for the level will be touched.
//
// [pcbInfo] -- On successful return, contains the size in
// bytes of the returned info. The returned size does
// not include the size of the DFS_INFO_3 struct itself.
//
// Returns: ERROR_SUCCESS -- Successfully returning info
//
// ERROR_OUTOFMEMORY -- Out of memory
//
//-----------------------------------------------------------------------------
DWORD
GetNetInfoEx(
PDFS_VOLUME pDfsVol,
DWORD Level,
LPDFS_INFO_3 pInfo,
LPDWORD pcbInfo)
{
DWORD dwErr = ERROR_SUCCESS;
DWORD cbInfo = 0;
DWORD cbItem;
ULONG i;
#if DBG
if (DfsSvcVerbose)
DbgPrint("GetNetInfoEx(%ws,%d)\n", pDfsVol->wszPrefix, Level);
#endif
//
// See if this is a Level 100 or 101. If so, we handle them right away
// and return
if (Level == 100) {
LPDFS_INFO_100 pInfo100 = (LPDFS_INFO_100) pInfo;
if (pDfsVol->wszComment != NULL) {
cbItem = (wcslen(pDfsVol->wszComment) + 1) * sizeof(WCHAR);
pInfo100->Comment = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo100->Comment != NULL) {
wcscpy(pInfo100->Comment, pDfsVol->wszComment);
cbInfo += cbItem;
goto AllDone;
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
} else {
pInfo100->Comment = (LPWSTR) MIDL_user_allocate(sizeof(WCHAR));
if (pInfo100->Comment != NULL) {
pInfo100->Comment[0] = UNICODE_NULL;
cbInfo += sizeof(WCHAR);
goto AllDone;
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
}
}
if (Level == 101) {
LPDFS_INFO_101 pInfo101 = (LPDFS_INFO_101) pInfo;
pInfo->State = pDfsVol->dwState;
goto AllDone;
}
//
// level 4 isn't just an extension of 3, so handle it seperately
//
if (Level == 4) {
LPDFS_INFO_4 pInfo4 = (LPDFS_INFO_4) pInfo;
cbItem = sizeof(UNICODE_PATH_SEP) + (wcslen(pDfsVol->wszPrefix) + 1) * sizeof(WCHAR);
pInfo4->EntryPath = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo4->EntryPath != NULL) {
pInfo4->EntryPath[0] = UNICODE_PATH_SEP;
wcscpy(&pInfo4->EntryPath[1], pDfsVol->wszPrefix);
cbInfo += cbItem;
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
if (pDfsVol->wszComment != NULL) {
cbItem = (wcslen(pDfsVol->wszComment)+1) * sizeof(WCHAR);
pInfo4->Comment = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo4->Comment != NULL) {
wcscpy( pInfo4->Comment, pDfsVol->wszComment );
cbInfo += cbItem;
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
} else {
pInfo4->Comment = (LPWSTR) MIDL_user_allocate(sizeof(WCHAR));
if (pInfo4->Comment != NULL) {
pInfo4->Comment[0] = UNICODE_NULL;
cbInfo += sizeof(WCHAR);
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
}
pInfo4->State = pDfsVol->dwState;
pInfo4->Timeout = pDfsVol->dwTimeout;
pInfo4->Guid = pDfsVol->idVolume;
pInfo4->NumberOfStorages = pDfsVol->ReplCount;
cbItem = pInfo4->NumberOfStorages * sizeof(DFS_STORAGE_INFO);
pInfo4->Storage = (LPDFS_STORAGE_INFO) MIDL_user_allocate(cbItem);
if (pInfo4->Storage != NULL) {
RtlZeroMemory(pInfo4->Storage, cbItem);
cbInfo += cbItem;
for (i = 0; i < pDfsVol->ReplCount; i++) {
dwErr = GetNetStorageInfo(&pDfsVol->ReplicaInfo[i],&pInfo4->Storage[i],&cbItem);
cbInfo += cbItem;
}
if (dwErr != ERROR_SUCCESS) {
for (; i > 0; i--) {
MIDL_user_free(pInfo4->Storage[i-1].ServerName);
MIDL_user_free(pInfo4->Storage[i-1].ShareName);
}
}
} else {
dwErr = ERROR_OUTOFMEMORY;
}
//
// See if we need to clean up...
//
if (dwErr != ERROR_SUCCESS) {
if (pInfo4->EntryPath != NULL) {
MIDL_user_free(pInfo4->EntryPath);
}
if (pInfo4->Storage != NULL) {
MIDL_user_free(pInfo4->Storage);
}
goto AllDone;
} else {
*pcbInfo = cbInfo;
}
goto AllDone;
}
//
// Level is 1,2 or 3
//
//
// Fill in the Level 1 stuff
//
cbItem = sizeof(UNICODE_PATH_SEP) + (wcslen(pDfsVol->wszPrefix)+1) * sizeof(WCHAR);
pInfo->EntryPath = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo->EntryPath != NULL) {
pInfo->EntryPath[0] = UNICODE_PATH_SEP;
wcscpy(&pInfo->EntryPath[1], pDfsVol->wszPrefix);
cbInfo += cbItem;
} else {
dwErr = ERROR_OUTOFMEMORY;
goto AllDone;
}
//
// Fill in the Level 2 stuff if needed
//
if (Level > 1) {
pInfo->State = pDfsVol->dwState;
pInfo->NumberOfStorages = pDfsVol->ReplCount;
if (pDfsVol->wszComment != NULL) {
cbItem = (wcslen(pDfsVol->wszComment)+1) * sizeof(WCHAR);
pInfo->Comment = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo->Comment != NULL) {
wcscpy( pInfo->Comment, pDfsVol->wszComment );
cbInfo += cbItem;
} else {
dwErr = ERROR_OUTOFMEMORY;
}
} else {
pInfo->Comment = (LPWSTR) MIDL_user_allocate(sizeof(WCHAR));
if (pInfo->Comment != NULL) {
pInfo->Comment[0] = UNICODE_NULL;
cbInfo += sizeof(WCHAR);
} else {
dwErr = ERROR_OUTOFMEMORY;
}
}
}
//
// Fill in the Level 3 stuff if needed
//
if (dwErr == ERROR_SUCCESS && Level > 2) {
cbItem = pInfo->NumberOfStorages * sizeof(DFS_STORAGE_INFO);
pInfo->Storage = (LPDFS_STORAGE_INFO) MIDL_user_allocate(cbItem);
if (pInfo->Storage != NULL) {
RtlZeroMemory(pInfo->Storage, cbItem);
cbInfo += cbItem;
for (i = 0; i < pDfsVol->ReplCount; i++) {
dwErr = GetNetStorageInfo(&pDfsVol->ReplicaInfo[i], &pInfo->Storage[i], &cbItem);
cbInfo += cbItem;
}
if (dwErr != ERROR_SUCCESS) {
for (; i > 0; i--) {
MIDL_user_free(pInfo->Storage[i-1].ServerName);
MIDL_user_free(pInfo->Storage[i-1].ShareName);
}
}
} else {
dwErr = ERROR_OUTOFMEMORY;
}
}
//
// See if we need to clean up...
//
if (dwErr != ERROR_SUCCESS) {
if (Level > 1) {
if (pInfo->EntryPath != NULL) {
MIDL_user_free(pInfo->EntryPath);
}
}
if (Level > 2) {
if (pInfo->Storage != NULL) {
MIDL_user_free(pInfo->Storage);
}
}
}
AllDone:
//
// Finally, we are done
//
if (dwErr == ERROR_SUCCESS)
*pcbInfo = cbInfo;
#if DBG
if (DfsSvcVerbose)
DbgPrint("GetNetInfoEx returning %d\n", dwErr);
#endif
return(dwErr);
}
//+----------------------------------------------------------------------------
//
// Function: GetNetStorageInfo, public
//
// Synopsis: Returns the replica info in a DFS_STORAGE_INFO struct.
// Useful for NetDfsXXX APIs.
//
// Arguments: [pInfo] -- Pointer to DFS_STORAGE_INFO to fill. Pointer
// members will be allocated using MIDL_user_allocate.
//
// [pcbInfo] -- On successful return, set to size in bytes of
// returned info. The size does not include the size
// of the DFS_STORAGE_INFO struct itself.
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
GetNetStorageInfo(
PDFS_REPLICA_INFO pRepl,
LPDFS_STORAGE_INFO pInfo,
LPDWORD pcbInfo)
{
DWORD dwErr = ERROR_SUCCESS;
LPWSTR wszShare;
DWORD cbInfo = 0, cbItem;
#if DBG
if (DfsSvcVerbose)
DbgPrint("GetNetStorageInfo(\\\\%ws\\%ws)\n",
pRepl->pwszServerName,
pRepl->pwszShareName);
#endif
pInfo->State = pRepl->ulReplicaState;
cbItem = (wcslen(pRepl->pwszServerName) + 1) * sizeof(WCHAR);
pInfo->ServerName = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo->ServerName != NULL) {
wcscpy(pInfo->ServerName, pRepl->pwszServerName);
cbInfo += cbItem;
} else {
dwErr = ERROR_OUTOFMEMORY;
}
if (dwErr == ERROR_SUCCESS) {
cbItem = (wcslen(pRepl->pwszShareName) + 1) * sizeof(WCHAR);
pInfo->ShareName = (LPWSTR) MIDL_user_allocate(cbItem);
if (pInfo->ShareName != NULL) {
wcscpy( pInfo->ShareName, pRepl->pwszShareName );
cbInfo += cbItem;
} else {
MIDL_user_free( pInfo->ServerName );
pInfo->ServerName = NULL;
dwErr = ERROR_OUTOFMEMORY;
}
}
if (dwErr == ERROR_SUCCESS)
*pcbInfo = cbInfo;
#if DBG
if (DfsSvcVerbose)
DbgPrint("GetStorageInfo returning %d\n", dwErr);
#endif
return( dwErr );
}
//+------------------------------------------------------------------------
//
// Function: DfsRemoveRootReplica
//
// Synopsis: Removes a Dfs root replica from the dfs root replica list
//
// History: 12/16/98 JHarper Created
//
//-------------------------------------------------------------------------
DWORD
DfsRemoveRootReplica(
PDFS_VOLUME_LIST pDfsVolList,
LPWSTR RootName)
{
ULONG cVol;
ULONG cRepl;
DWORD dwErr = ERROR_SUCCESS;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsRemoveRootReplica(%ws)\n", RootName);
#endif
for (cVol = 0; cVol < pDfsVolList->VolCount; cVol++) {
if (wcscmp(pDfsVolList->Volumes[cVol].wszObjectName,L"\\domainroot") != 0)
continue;
ScanReplicas:
for (cRepl = 0; cRepl < pDfsVolList->Volumes[cVol].ReplCount; cRepl++) {
if (
_wcsicmp(
pDfsVolList->Volumes[cVol].ReplicaInfo[cRepl].pwszServerName,
RootName) == 0
) {
DfsReplDeleteByIndex(&pDfsVolList->Volumes[cVol], cRepl);
goto ScanReplicas;
}
}
break;
}
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsRemoveRootReplica exit %d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: DfsRecoverVolList, public
//
// Synopsis: Walks the dfs_volume list, checking the recovery params, and
// applying any recovery needed. Also applies the deleted replica
// list to the volume's replica list.
//
// Arguments: [pDfsVolList] -- Pointer to DFS_VOLUME_LIST work on.
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
DfsRecoverVolList(
PDFS_VOLUME_LIST pDfsVolList)
{
DWORD dwErr = ERROR_SUCCESS;
ULONG iVol;
ULONG iRepl;
ULONG iDelRepl;
PDFS_VOLUME pVol;
ULONG RecoveryState;
ULONG Operation;
ULONG OperState;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsRecoverVolList(%d volumes)\n", pDfsVolList->VolCount);
#endif
ReStart:
for (iVol = 0; dwErr == ERROR_SUCCESS && iVol < pDfsVolList->VolCount; iVol++) {
pVol = &pDfsVolList->Volumes[iVol];
if (pVol->cbRecovery >= sizeof(ULONG)) {
_GetULong(pVol->pRecovery, RecoveryState);
#if DBG
if (DfsSvcVerbose)
DbgPrint("RecoveryState[%d]=0x%x\n", iVol, RecoveryState);
#endif
if (DFS_GET_RECOVERY_STATE(RecoveryState) != DFS_RECOVERY_STATE_NONE) {
Operation = DFS_GET_RECOVERY_STATE(RecoveryState);
OperState = DFS_GET_OPER_STAGE(RecoveryState);
switch (Operation) {
case DFS_RECOVERY_STATE_CREATING:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DFS_RECOVERY_STATE_CREATING\n");
#endif
dwErr = DfsVolDelete(pDfsVolList, iVol);
goto ReStart;
case DFS_RECOVERY_STATE_ADD_SERVICE:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DFS_RECOVERY_STATE_ADD_SERVICE\n");
#endif
// dwErr = RecoverFromAddService(OperState);
ASSERT(L"DFS_RECOVERY_STATE_ADD_SERVICE - WHY?\n");
break;
case DFS_RECOVERY_STATE_REMOVE_SERVICE:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DFS_RECOVERY_STATE_REMOVE_SERVICE\n");
#endif
// dwErr = RecoverFromRemoveService(OperState);
ASSERT(L"DFS_RECOVERY_STATE_REMOVE_SERVICE - WHY?\n");
break;
case DFS_RECOVERY_STATE_DELETE:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DFS_RECOVERY_STATE_DELETE\n");
#endif
dwErr = DfsVolDelete(pDfsVolList, iVol);
goto ReStart;
default:
#if DBG
if (DfsSvcVerbose)
DbgPrint("default\n");
#endif
dwErr = ERROR_INTERNAL_DB_CORRUPTION;
}
}
}
if (pVol->pRecovery != NULL)
MarshalBufferFree(pVol->pRecovery);
pVol->pRecovery = NULL;
pVol->cbRecovery = 0;
}
if (dwErr != ERROR_SUCCESS)
goto AllDone;
//
// Now apply deleted replica list to each volume
//
for (iVol = 0; dwErr == ERROR_SUCCESS && iVol < pDfsVolList->VolCount; iVol++) {
pVol = &pDfsVolList->Volumes[iVol];
for (iDelRepl = 0; dwErr == ERROR_SUCCESS && iDelRepl < pVol->DelReplCount; iDelRepl++) {
#if 0 // XXX This appears to be wrong - don't do it.
dwErr = DfsReplDeleteByName(
pVol,
pVol->DelReplicaInfo[iDelRepl].pwszServerName,
pVol->DelReplicaInfo[iDelRepl].pwszShareName);
#endif
DfsFreeRepl(&pVol->DelReplicaInfo[iDelRepl]);
}
if (pVol->DelReplicaInfo != NULL) {
free(pVol->DelReplicaInfo);
pVol->DelReplicaInfo = NULL;
}
if (pVol->DelFtModification != NULL) {
free(pVol->DelFtModification);
pVol->DelFtModification = NULL;
}
pVol->DelReplCount = 0;
}
AllDone:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsRecoverVolList returning %d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: DfsVolDelete, public
//
// Synopsis: Removes a DFS_VOLUME from DFS_VOLUME_LIST
//
// Arguments: [pDfsVolList] -- Pointer to DFS_VOLUME_LIST work on.
// [iVol] -- Index of volume to delete
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
DfsVolDelete(
PDFS_VOLUME_LIST pDfsVolList,
ULONG iVol)
{
ULONG i;
DWORD dwErr = ERROR_SUCCESS;
ASSERT(iVol < pDfsVolList->VolCount);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsVolDelete(%d)\n", iVol);
#endif
//
// Free any memory this Volume is using
//
DfsFreeVol(&pDfsVolList->Volumes[iVol]);
//
// Since we're shrinking the list, we simply clip out the entry we don't want
// and adjust the count.
//
for (i = iVol+1; i < pDfsVolList->VolCount; i++)
pDfsVolList->Volumes[i-1] = pDfsVolList->Volumes[i];
pDfsVolList->VolCount--;
RtlZeroMemory(&pDfsVolList->Volumes[pDfsVolList->VolCount], sizeof(DFS_VOLUME));
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsVolDelete returning %d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: DfsReplDeleteByIndex, public
//
// Synopsis: Removes a PDFS_REPLICA_INFO from a DFS_VOLUME's replica list
//
// Arguments: [pDfsVol] -- Pointer to DFS_VOLUME work on.
// [iRepl] -- Index of replica to delete
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
DfsReplDeleteByIndex(
PDFS_VOLUME pVol,
ULONG iRepl)
{
ULONG i;
DWORD dwErr = ERROR_SUCCESS;
ASSERT(iRepl < pVol->ReplCount);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsReplDeleteByIndex(%d)\n", iRepl);
#endif
//
// Free any memory this replica is using
//
DfsFreeRepl(&pVol->ReplicaInfo[iRepl]);
//
// Since we're shrinking the list(s), we simply clip out the entry we don't want
// and adjust the count.
//
for (i = iRepl+1; i < pVol->ReplCount; i++) {
pVol->ReplicaInfo[i-1] = pVol->ReplicaInfo[i];
pVol->FtModification[i-1] = pVol->FtModification[i];
}
pVol->ReplCount--;
RtlZeroMemory(&pVol->ReplicaInfo[pVol->ReplCount], sizeof(DFS_REPLICA_INFO));
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsReplDeleteByIndex returning %d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: DfsReplDeleteByName, public
//
// Synopsis: Removes a PDFS_REPLICA_INFO from a DFS_VOLUME's replica list. Simply
// looks up the replica by name and then calls DfsReplDeleteByIndex()
//
// Arguments: [pDfsVol] -- Pointer to DFS_VOLUME work on.
// [pwszServername] - Server Name
// [pwszShareName] - Share Name
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
DfsReplDeleteByName(
PDFS_VOLUME pVol,
LPWSTR pwszServerName,
LPWSTR pwszShareName)
{
ULONG iRep;
DWORD dwErr = ERROR_SUCCESS;
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsReplDeleteByName(%ws,%ws)\n", pwszServerName, pwszShareName);
#endif
if (pwszServerName == NULL || pwszShareName == NULL) {
dwErr = ERROR_INVALID_PARAMETER;
goto AllDone;
}
ReStart:
//
// Scan the volume's replica list, and if there is a match on the
// passed-in servername and sharename, remove the replica.
//
for (iRep = 0; iRep < pVol->ReplCount; iRep++) {
if (_wcsicmp(pVol->ReplicaInfo[iRep].pwszServerName, pwszServerName) == 0
&&
_wcsicmp(pVol->ReplicaInfo[iRep].pwszShareName, pwszShareName) == 0
) {
dwErr = DfsReplDeleteByIndex(pVol, iRep);
goto ReStart;
}
}
AllDone:
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsReplDeleteByName returning %d\n", dwErr);
#endif
return dwErr;
}
//+----------------------------------------------------------------------------
//
// Function: DfsDelReplDelete, public
//
// Synopsis: Removes a PDFS_REPLICA_INFO from a DFS_VOLUME's deleted replica list
//
// Arguments: [pDfsVol] -- Pointer to DFS_VOLUME work on.
// [iDelRepl] -- Index of Deleted replica to delete
//
// Returns:
//
//-----------------------------------------------------------------------------
DWORD
DfsDelReplDelete(
PDFS_VOLUME pVol,
ULONG iDelRepl)
{
ULONG i;
DWORD dwErr = ERROR_SUCCESS;
ASSERT(iDelRepl < pVol->DelReplCount);
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsDelReplDelete(%d)\n", iDelRepl);
#endif
//
// Free any memory this replica is using
//
DfsFreeRepl(&pVol->DelReplicaInfo[iDelRepl]);
//
// Since we're shrinking the list(s), we simply clip out the entry we don't want
// and adjust the count.
//
for (i = iDelRepl+1; i < pVol->DelReplCount; i++) {
pVol->DelReplicaInfo[i-1] = pVol->DelReplicaInfo[i];
pVol->DelFtModification[i-1] = pVol->DelFtModification[i];
}
pVol->DelReplCount--;
RtlZeroMemory(&pVol->DelReplicaInfo[pVol->DelReplCount], sizeof(DFS_REPLICA_INFO));
#if DBG
if (DfsSvcVerbose)
DbgPrint("DfsDelReplDelete returning %d\n", dwErr);
#endif
return dwErr;
}
#if DBG
void
DumpBuf(PCHAR cp, ULONG len)
{
ULONG i, j, c;
for (i = 0; i < len; i += 16) {
DbgPrint("%08x ", i /* +(ULONG)cp */);
for (j = 0; j < 16; j++) {
if (j == 8)
DbgPrint(" ");
if (i+j < len) {
c = cp[i+j] & 0xff;
DbgPrint("%02x ", c);
} else {
DbgPrint(" ");
}
}
DbgPrint(" ");
for (j = 0; j < 16; j++) {
if (j == 8)
DbgPrint("|");
if (i+j < len) {
c = cp[i+j] & 0xff;
if (c < ' ' || c > '~')
c = '.';
DbgPrint("%c", c);
} else {
DbgPrint(" ");
}
}
DbgPrint("\n");
}
}
//+------------------------------------------------------------------------
//
// Function: DfsDumpVolList
//
// Synopsis: Prints the volume information represented by the volume
// list passed in.
//
// Returns: [ERROR_SUCCESS] -- If all went well.
//
// History: 11/19/98 JHarper Created
//
//-------------------------------------------------------------------------
VOID
DfsDumpVolList(
PDFS_VOLUME_LIST pDfsVolList)
{
ULONG cVol;
ULONG cRepl;
ULONG cSite;
ULONG i;
GUID guid;
PLIST_ENTRY pListHead;
PLIST_ENTRY pLink;
PDFSM_SITE_ENTRY pSiteEntry;
DbgPrint("****************************************\n");
for (cVol = 0; cVol < pDfsVolList->VolCount; cVol++) {
DbgPrint("Name=%ws\n", pDfsVolList->Volumes[cVol].wszObjectName);
DbgPrint("Prefix: %ws\n", pDfsVolList->Volumes[cVol].wszPrefix);
DbgPrint("Comment: %ws\n", pDfsVolList->Volumes[cVol].wszComment);
DbgPrint("cbRecovery: %d\n", pDfsVolList->Volumes[cVol].cbRecovery);
DbgPrint("ReplCount=%d\n", pDfsVolList->Volumes[cVol].ReplCount);
DbgPrint("AllocatedReplCount=%d\n", pDfsVolList->Volumes[cVol].AllocatedReplCount);
for (cRepl = 0; cRepl < pDfsVolList->Volumes[cVol].ReplCount; cRepl++) {
DbgPrint("[%d]ServerName=%ws\n",
cRepl, pDfsVolList->Volumes[cVol].ReplicaInfo[cRepl].pwszServerName);
DbgPrint("[%d]ShareName=%ws\n",
cRepl, pDfsVolList->Volumes[cVol].ReplicaInfo[cRepl].pwszShareName);
}
DbgPrint("DelReplCount=%d\n", pDfsVolList->Volumes[cVol].DelReplCount);
DbgPrint("AllocatedDelReplCount=%d\n", pDfsVolList->Volumes[cVol].AllocatedDelReplCount);
for (cRepl = 0; cRepl < pDfsVolList->Volumes[cVol].DelReplCount; cRepl++) {
DbgPrint("[%d]ServerName=%ws\n",
cRepl, pDfsVolList->Volumes[cVol].DelReplicaInfo[cRepl].pwszServerName);
DbgPrint("[%d]ShareName=%ws\n",
cRepl, pDfsVolList->Volumes[cVol].DelReplicaInfo[cRepl].pwszShareName);
}
DbgPrint("\n");
}
DbgPrint("---------SiteTable-------\n");
guid = pDfsVolList->SiteGuid;
DbgPrint("SiteTableGuid:"
"%08lX-%04X-%04X-%02X%02X%02X%02X%02X%02X%02X%02X\n",
guid.Data1, guid.Data2, guid.Data3, (int) guid.Data4[0],
(int) guid.Data4[1], (int) guid.Data4[2], (int) guid.Data4[3],
(int) guid.Data4[4], (int) guid.Data4[5],
(int) guid.Data4[6], (int) guid.Data4[7]);
pListHead = &pDfsVolList->SiteList;
if (pListHead->Flink == pListHead)
return;
for (pLink = pListHead->Flink; pLink != pListHead; pLink = pLink->Flink) {
pSiteEntry = CONTAINING_RECORD(pLink, DFSM_SITE_ENTRY, Link);
DbgPrint("[%ws-%d sites]\n",
pSiteEntry->ServerName,
pSiteEntry->Info.cSites);
for (i = 0; i < pSiteEntry->Info.cSites; i++) {
DbgPrint("\t%ws\n", pSiteEntry->Info.Site[i].SiteName);
}
}
DbgPrint("****************************************\n");
}
#endif // DBG