869 lines
30 KiB
C++
869 lines
30 KiB
C++
//#pragma title( "SDResolve.cpp - SDResolve: A Domain Migration Utility" )
|
|
|
|
/*
|
|
Copyright (c) 1995-1998, Mission Critical Software, Inc. All rights reserved.
|
|
===============================================================================
|
|
Module - sdresolve.cpp
|
|
System - SDResolve
|
|
Author - Christy Boles
|
|
Created - 97/07/11
|
|
Description - Routines to iterate through files, shares, and printers
|
|
when processing security on a machine.
|
|
Updates -
|
|
===============================================================================
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <iostream.h>
|
|
#include <fstream.h>
|
|
#include <assert.h>
|
|
|
|
#include "Common.hpp"
|
|
#include "ErrDct.hpp"
|
|
#include "UString.hpp"
|
|
#include "sd.hpp"
|
|
|
|
#include "sidcache.hpp"
|
|
#include "enumvols.hpp"
|
|
#include "SecObj.hpp"
|
|
#include "ealen.hpp"
|
|
#include "BkupRstr.hpp"
|
|
#include "TxtSid.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
bool enforce;
|
|
extern TErrorDct err;
|
|
extern bool silent;
|
|
extern bool IsMachineName(const LPWSTR name);
|
|
extern bool IsShareName(const LPWSTR name);
|
|
extern bool ContainsWildcard( WCHAR const * name);
|
|
|
|
|
|
#define MAX_BUFFER_LENGTH 10000
|
|
#define PRINT_BUFFER_SIZE 2000
|
|
|
|
//******************************************************************************************************
|
|
// Main routine for SDResolve
|
|
|
|
// Iterates files and directories to be resolved
|
|
void
|
|
IteratePath(
|
|
WCHAR * path, // in -path to start iterating from
|
|
SecurityTranslatorArgs * args, // in -translation settings
|
|
TSDResolveStats * stats, // in -stats (to display pathnames & pass to ResolveSD)
|
|
TSecurableObject * LC, // in -last container
|
|
TSecurableObject * LL, // in -last file
|
|
bool haswc // in -indicates whether path contains a wc character
|
|
)
|
|
{
|
|
HANDLE hFind;
|
|
WIN32_FIND_DATA findEntry;
|
|
BOOL b;
|
|
TFileSD * currSD;
|
|
bool changeLastCont;
|
|
bool changeLastLeaf;
|
|
WCHAR * appendPath = NULL;
|
|
WCHAR safepath[LEN_Path + 10];
|
|
TFileSD * LastContain = (TFileSD*) LC;
|
|
TFileSD * LastLeaf = (TFileSD*) LL;
|
|
WCHAR localPath[LEN_Path];
|
|
// this is the first (for this) dir
|
|
|
|
safecopy(safepath,path);
|
|
safecopy(localPath,path);
|
|
|
|
// Check to see if path is longer than MAX_PATH
|
|
// if so, add \\?\ to the beginning of it to
|
|
// turn off path parsing
|
|
if ( UStrLen(path) >= MAX_PATH && path[2] != L'?' )
|
|
{
|
|
WCHAR temp[LEN_Path];
|
|
|
|
if ( (path[0] == L'\\') && (path[1] == L'\\') ) // UNC name
|
|
{
|
|
UStrCpy(temp,L"\\\\?\\UNC\\");
|
|
}
|
|
else
|
|
{
|
|
UStrCpy(temp,L"\\\\?\\");
|
|
}
|
|
UStrCpy(temp + UStrLen(temp),path);
|
|
safecopy(localPath,temp);
|
|
}
|
|
appendPath = localPath + UStrLen(localPath);
|
|
|
|
if ( *(appendPath-1) == L'\\' ) // if there's already a backslash on the end of the path, don't add another one
|
|
appendPath--;
|
|
if ( ! haswc )
|
|
UStrCpy(appendPath, "\\*.*");
|
|
if ( args->LogVerbose() )
|
|
err.DbgMsgWrite(0,L"Starting IteratePath: %ls",path);
|
|
|
|
for ( b = ((hFind = FindFirstFile(localPath, &findEntry)) != INVALID_HANDLE_VALUE)
|
|
; b ; b = FindNextFile(hFind, &findEntry) )
|
|
{
|
|
if ( ! haswc)
|
|
appendPath[1] = '\0'; // restore path -- remove \*.* append
|
|
if ( ! UStrCmp((LPWSTR)findEntry.cFileName,L".") || ! UStrCmp((LPWSTR)findEntry.cFileName,L"..") )
|
|
continue; // ignore names '.' and '..'
|
|
if ( ! haswc )
|
|
UStrCpy(appendPath+1, findEntry.cFileName);
|
|
else
|
|
{
|
|
for ( WCHAR * ch = appendPath-1; ch >= path && *ch != L'\\' ; ch-- )
|
|
;
|
|
UStrCpy(ch+1,findEntry.cFileName);
|
|
}
|
|
if ( ((TAccountCache *)args->Cache())->IsCancelled() )
|
|
{
|
|
break;
|
|
}
|
|
currSD = new TFileSD(localPath);
|
|
stats->DisplayPath(localPath);
|
|
if ( !currSD || !currSD->HasSecurity() )
|
|
{
|
|
//err.MsgWrite(0,"Error: Couldn't get the SD");
|
|
}
|
|
else
|
|
{
|
|
if ( findEntry.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) // if dir
|
|
{
|
|
// resolve this container & iterate next container
|
|
changeLastCont = currSD->ResolveSD(args,stats,directory,LastContain);
|
|
if ( changeLastCont )
|
|
{
|
|
if ( LastContain && LastContain != LC )
|
|
{
|
|
delete LastContain;
|
|
}
|
|
LastContain = currSD;
|
|
}
|
|
else
|
|
{
|
|
delete currSD;
|
|
}
|
|
IteratePath(localPath,args,stats,LastContain,LastLeaf,false);
|
|
}
|
|
else
|
|
{
|
|
// iterate this file with last
|
|
changeLastLeaf = currSD->ResolveSD(args,stats,file,LastLeaf);
|
|
if ( changeLastLeaf )
|
|
{
|
|
if ( LastLeaf && LastLeaf != LL )
|
|
{
|
|
delete LastLeaf;
|
|
}
|
|
LastLeaf = currSD;
|
|
}
|
|
else
|
|
{
|
|
delete currSD;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( LastContain && LastContain != LC )
|
|
{
|
|
delete LastContain;
|
|
}
|
|
if ( LastLeaf && LastLeaf != LL )
|
|
{
|
|
delete LastLeaf;
|
|
}
|
|
appendPath[0] = '\0';
|
|
DWORD rc = GetLastError();
|
|
|
|
if ( args->LogVerbose() )
|
|
err.DbgMsgWrite(0,L"Closing IteratePath %S",safepath);
|
|
FindClose(hFind);
|
|
switch ( rc )
|
|
{
|
|
case ERROR_NO_MORE_FILES:
|
|
case 0:
|
|
break;
|
|
default:
|
|
err.SysMsgWrite(ErrE, rc, DCT_MSG_FIND_FILE_FAILED_SD, path, rc);
|
|
}
|
|
return;
|
|
}
|
|
|
|
DWORD
|
|
ResolvePrinter(
|
|
PRINTER_INFO_4 * pPrinter, // in - printer information
|
|
SecurityTranslatorArgs * args, // in - translation settings
|
|
TSDResolveStats * stats // in - stats
|
|
)
|
|
{
|
|
DWORD rc = 0;
|
|
// DWORD needed = 0;
|
|
|
|
TPrintSD sd(pPrinter->pPrinterName);
|
|
|
|
if ( sd.GetSecurity() )
|
|
{
|
|
sd.ResolveSD(args,stats,printer,NULL);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
ServerResolvePrinters(
|
|
WCHAR const * server, // in -translate the printers on this server
|
|
SecurityTranslatorArgs * args, // in -translation settings
|
|
TSDResolveStats * stats // in -stats
|
|
)
|
|
{
|
|
DWORD rc = 0;
|
|
PRINTER_INFO_4 * pInfo = NULL;
|
|
BYTE * buffer = new BYTE[PRINT_BUFFER_SIZE];
|
|
DWORD cbNeeded = PRINT_BUFFER_SIZE;
|
|
DWORD nReturned = 0;
|
|
|
|
if (!buffer)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
if (! EnumPrinters(PRINTER_ENUM_LOCAL,NULL,4,buffer,PRINT_BUFFER_SIZE,&cbNeeded,&nReturned) )
|
|
{
|
|
rc = GetLastError();
|
|
if ( rc == ERROR_INSUFFICIENT_BUFFER )
|
|
{
|
|
// try again with a bigger buffer size
|
|
delete buffer;
|
|
buffer = new BYTE[cbNeeded];
|
|
if (!buffer)
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
if (! EnumPrinters(PRINTER_ENUM_LOCAL,NULL,4,buffer,cbNeeded,&cbNeeded,&nReturned) )
|
|
{
|
|
rc = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! rc )
|
|
{
|
|
pInfo = (PRINTER_INFO_4 *)buffer;
|
|
for ( DWORD i = 0 ; i < nReturned ; i++ )
|
|
{
|
|
ResolvePrinter(&(pInfo[i]),args,stats);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_ERROR_ENUMERATING_LOCAL_PRINTERS_D,rc);
|
|
}
|
|
|
|
delete buffer;
|
|
|
|
return rc;
|
|
}
|
|
int
|
|
ServerResolveShares(
|
|
WCHAR const * server, // in -enumerate and translate the shares on this server
|
|
SecurityTranslatorArgs * args, // in -translation settings
|
|
TSDResolveStats * stats // in -stats (to display pathnames & pass to ResolveSD)
|
|
)
|
|
{
|
|
DWORD rc = 0;
|
|
DWORD numRead = 0;
|
|
DWORD totalEntries = 0;
|
|
DWORD resumeHandle = 0;
|
|
SHARE_INFO_0 * bufPtr = NULL;
|
|
WCHAR serverName[LEN_Computer];
|
|
WCHAR fullPath[LEN_Path];
|
|
WCHAR * pServerName = serverName;
|
|
DWORD ttlRead = 0;
|
|
|
|
if ( server )
|
|
{
|
|
safecopy(serverName,server);
|
|
}
|
|
else
|
|
{
|
|
pServerName = NULL;
|
|
|
|
}
|
|
|
|
do
|
|
{
|
|
rc = NetShareEnum(pServerName,0,(LPBYTE *)&bufPtr,MAX_BUFFER_LENGTH,&numRead,&totalEntries,&resumeHandle);
|
|
|
|
if ( ! rc || rc == ERROR_MORE_DATA )
|
|
{
|
|
for ( UINT i = 0 ; i < numRead ; i++ )
|
|
{
|
|
// Process the SD
|
|
if ( pServerName )
|
|
{
|
|
swprintf(fullPath,L"%s\\%s",pServerName,bufPtr[i].shi0_netname);
|
|
}
|
|
else
|
|
{
|
|
swprintf(fullPath,L"%s",bufPtr[i].shi0_netname);
|
|
}
|
|
|
|
|
|
TShareSD tSD(fullPath);
|
|
|
|
if ( tSD.HasSecurity() )
|
|
{
|
|
stats->DisplayPath(fullPath,TRUE);
|
|
tSD.ResolveSD(args,stats,share,NULL);
|
|
}
|
|
}
|
|
ttlRead += numRead;
|
|
resumeHandle = ttlRead;
|
|
NetApiBufferFree(bufPtr);
|
|
}
|
|
} while ( rc == ERROR_MORE_DATA && numRead < totalEntries );
|
|
|
|
if ( rc && rc != ERROR_MORE_DATA )
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_SHARE_ENUM_FAILED_SD,server,rc);
|
|
|
|
return rc;
|
|
}
|
|
|
|
void
|
|
ResolveFilePath(
|
|
SecurityTranslatorArgs * args, // in - translation options
|
|
TSDResolveStats * Stats, // in - class to display stats
|
|
WCHAR * path, // in - path name
|
|
bool validAlone, // in - whether this object exists (false for share names and volume roots)
|
|
bool containsWC, // in - true if path contains wildcard
|
|
bool iscontainer // in - whether the starting path is a container
|
|
)
|
|
{
|
|
TFileSD * pSD;
|
|
|
|
if ( args->LogVerbose() )
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_S,path);
|
|
|
|
Stats->DisplayPath(path);
|
|
|
|
if ( validAlone && ! containsWC )
|
|
{
|
|
pSD = new TFileSD(path);
|
|
if (!pSD)
|
|
return;
|
|
if ( pSD->HasSecurity() )
|
|
pSD->ResolveSD(args,
|
|
Stats,
|
|
iscontainer?directory:file,
|
|
NULL);
|
|
delete pSD;
|
|
}
|
|
if ( iscontainer || containsWC )
|
|
{
|
|
IteratePath(path,
|
|
args,
|
|
Stats,
|
|
NULL,
|
|
NULL,
|
|
containsWC);
|
|
}
|
|
if ( args->Cache()->IsCancelled() )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
|
|
}
|
|
}
|
|
|
|
void WriteOptions(SecurityTranslatorArgs * args)
|
|
{
|
|
//* WCHAR cmd[1000] = L"SecurityTranslation ";;
|
|
WCHAR cmd[1000];
|
|
WCHAR arg[300];
|
|
|
|
|
|
UStrCpy(cmd, GET_STRING(IDS_STOptions_Start));
|
|
|
|
if ( args->NoChange() )
|
|
{
|
|
//* UStrCpy(cmd +UStrLen(cmd), L"WriteChanges:No ");
|
|
UStrCpy(cmd +UStrLen(cmd), GET_STRING(IDS_STOptions_WriteChng));
|
|
}
|
|
if ( args->TranslateFiles() )
|
|
{
|
|
//* UStrCpy(cmd +UStrLen(cmd), L"Files:Yes ");
|
|
UStrCpy(cmd +UStrLen(cmd), GET_STRING(IDS_STOptions_Files));
|
|
}
|
|
if ( args->TranslateShares() )
|
|
{
|
|
//* UStrCpy(cmd + UStrLen(cmd),L"Shares:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_Shares));
|
|
}
|
|
if ( args->TranslateLocalGroups() )
|
|
{
|
|
//* UStrCpy(cmd + UStrLen(cmd),L"LGroups:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_LocalGroup));
|
|
}
|
|
if ( args->TranslateUserRights() )
|
|
{
|
|
// UStrCpy(cmd + UStrLen(cmd),L"UserRights:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_URights));
|
|
}
|
|
if ( args->TranslatePrinters() )
|
|
{
|
|
// UStrCpy(cmd + UStrLen(cmd),L"UserRights:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_Printers));
|
|
}
|
|
if ( args->TranslateUserProfiles() )
|
|
{
|
|
//* UStrCpy(cmd + UStrLen(cmd),L"Profiles:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_Profiles));
|
|
}
|
|
if ( args->TranslateRecycler() )
|
|
{
|
|
//* UStrCpy(cmd + UStrLen(cmd),L"RecycleBin:Yes ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_RBin));
|
|
}
|
|
|
|
if ( *args->LogFile() )
|
|
{
|
|
//* wsprintf(arg,L"LogFile:%S ",args->LogFile());
|
|
wsprintf(arg,GET_STRING(IDS_STOptions_LogName),args->LogFile());
|
|
UStrCpy(cmd +UStrLen(cmd), arg);
|
|
}
|
|
if ( args->TranslationMode() == ADD_SECURITY )
|
|
{
|
|
//* UStrCpy(cmd +UStrLen(cmd), L"TranslationMode:Add ");
|
|
UStrCpy(cmd +UStrLen(cmd), GET_STRING(IDS_STOptions_AddMode));
|
|
}
|
|
else if ( args->TranslationMode() == REMOVE_SECURITY )
|
|
{
|
|
//* UStrCpy(cmd +UStrLen(cmd), L"TranslationMode:Remove ");
|
|
UStrCpy(cmd +UStrLen(cmd), GET_STRING(IDS_STOptions_RemoveMode));
|
|
}
|
|
else
|
|
{
|
|
//* UStrCpy(cmd + UStrLen(cmd),L"TranslationMode:Replace ");
|
|
UStrCpy(cmd + UStrLen(cmd),GET_STRING(IDS_STOptions_ReplaceMode));
|
|
}
|
|
wsprintf(arg,L"%s %s ",args->Source(), args->Target());
|
|
UStrCpy(cmd +UStrLen(cmd), arg);
|
|
|
|
err.MsgWrite(0,DCT_MSG_GENERIC_S,&*cmd);
|
|
}
|
|
|
|
void
|
|
TranslateRecycler(
|
|
SecurityTranslatorArgs * args, // in - translation options
|
|
TSDResolveStats * Stats, // in - class to display stats
|
|
WCHAR * path // in - drive name
|
|
)
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_RECYCLER_S,path);
|
|
WCHAR folder[LEN_Path];
|
|
WCHAR const * recycler = L"RECYCLER";
|
|
WCHAR strSid[200];
|
|
WCHAR srcPath[LEN_Path];
|
|
WCHAR tgtPath[LEN_Path];
|
|
DWORD lenStrSid = DIM(strSid);
|
|
_wfinddata_t fData;
|
|
// long hRecycler;
|
|
LONG_PTR hRecycler;
|
|
PSID pSidSrc = NULL, pSidTgt = NULL;
|
|
TRidNode * pNode;
|
|
DWORD rc = 0;
|
|
|
|
swprintf(folder,L"%s\\%s\\*",path,recycler);
|
|
|
|
long mode = args->TranslationMode();
|
|
|
|
// Windows 2000 checks the SD for the recycle bin when the recycle bin is opened. If the SD does not match the
|
|
// default template (permissions for user, admin, and system), Windows displays a message that the recycle bin is corrupt.
|
|
// This change may also be in NT 4 SP 7. To avoid causing this corrupt recycle bin message, we will always translate the
|
|
// recycle bins in replace mode. We will not change if we are doing a remove.
|
|
if (args->TranslationMode() != REMOVE_SECURITY)
|
|
args->SetTranslationMode(REPLACE_SECURITY);
|
|
|
|
// use _wfind to look for hidden files in the folder
|
|
for ( hRecycler = _wfindfirst(folder,&fData) ; hRecycler != -1 && ( rc == 0 ); rc = (DWORD)_wfindnext(hRecycler,&fData) )
|
|
{
|
|
pSidSrc = SidFromString(fData.name);
|
|
if ( pSidSrc )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_RECYCLE_FOLDER_S,fData.name);
|
|
pNode = (TRidNode*)args->Cache()->Lookup(pSidSrc);
|
|
if ( pNode && pNode != (TRidNode*)-1 )
|
|
{
|
|
pSidTgt = args->Cache()->GetTgtSid(pNode);
|
|
// get the target directory name
|
|
GetTextualSid(pSidTgt,strSid,&lenStrSid);
|
|
if ( args->LogVerbose() )
|
|
err.DbgMsgWrite(0,L"Target sid is: %ls",strSid);
|
|
if ( ! args->NoChange() && args->TranslationMode() != REMOVE_SECURITY )
|
|
{
|
|
// rename the directory
|
|
swprintf(srcPath,L"%s\\%s\\%s",path,recycler,fData.name);
|
|
swprintf(tgtPath,L"%s\\%s\\%s",path,recycler,strSid);
|
|
if ( ! MoveFile(srcPath,tgtPath) )
|
|
{
|
|
rc = GetLastError();
|
|
if ( (rc == ERROR_ALREADY_EXISTS) && (args->TranslationMode() == REPLACE_SECURITY) )
|
|
{
|
|
// the target recycle bin already exists
|
|
// attempt to rename it with a suffix, so we can rename the new bin to the SID
|
|
WCHAR tmpPath[LEN_Path];
|
|
long ndx = 0;
|
|
|
|
do
|
|
{
|
|
swprintf(tmpPath,L"%ls%ls%ld",tgtPath,GET_STRING(IDS_RenamedRecyclerSuffix),ndx);
|
|
if (! MoveFile(tgtPath,tmpPath) )
|
|
{
|
|
rc = GetLastError();
|
|
ndx++;
|
|
}
|
|
else
|
|
{
|
|
rc = 0;
|
|
err.MsgWrite(0,DCT_MSG_RECYCLER_RENAMED_SS,tgtPath,tmpPath);
|
|
}
|
|
} while ( rc == ERROR_ALREADY_EXISTS );
|
|
if ( ! rc )
|
|
{
|
|
// we have moved the pre-existing target recycler out of the way
|
|
// now retry the rename
|
|
if (! MoveFile(srcPath,tgtPath) )
|
|
{
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_RECYCLER_RENAME_FAILED_SD,pNode->GetAcctName(),rc);
|
|
}
|
|
else
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_RECYCLER_RENAMED_SS,srcPath,tgtPath);
|
|
// run security translation on the new folder
|
|
ResolveFilePath(args,Stats,tgtPath,TRUE,FALSE,TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_RECYCLER_RENAME_FAILED_SD,pNode->GetAcctName(),rc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_RECYCLER_RENAME_FAILED_SD,pNode->GetAcctName(),rc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_RECYCLER_RENAMED_SS,srcPath,tgtPath);
|
|
// run security translation on the new folder
|
|
ResolveFilePath(args,Stats,tgtPath,TRUE,FALSE,TRUE);
|
|
}
|
|
|
|
}
|
|
FreeSid(pSidTgt);
|
|
}
|
|
FreeSid(pSidSrc);
|
|
}
|
|
}
|
|
// set the translation mode back to its original value
|
|
args->SetTranslationMode(mode);
|
|
}
|
|
|
|
// if the specified node is a normal share, this attempts to convert it to a path
|
|
// using the administrative shares
|
|
void
|
|
BuildAdminPathForShare(
|
|
TPathNode * tnode,
|
|
WCHAR * adminShare
|
|
)
|
|
{
|
|
// if all else fails, return the same name as specified in the node
|
|
UStrCpy(adminShare,tnode->GetPathName());
|
|
|
|
SHARE_INFO_502 * shInfo = NULL;
|
|
DWORD rc = 0;
|
|
WCHAR shareName[LEN_Path];
|
|
WCHAR * slash = NULL;
|
|
|
|
UStrCpy(shareName,tnode->GetPathName() + UStrLen(tnode->GetServerName()) +1);
|
|
slash = wcschr(shareName,L'\\');
|
|
if ( slash )
|
|
*slash = 0;
|
|
|
|
|
|
rc = NetShareGetInfo(tnode->GetServerName(),shareName,502,(LPBYTE*)&shInfo);
|
|
if ( ! rc )
|
|
{
|
|
if ( *shInfo->shi502_path )
|
|
{
|
|
// build the administrative path name for the share
|
|
UStrCpy(adminShare,tnode->GetServerName());
|
|
UStrCpy(adminShare + UStrLen(adminShare),L"\\");
|
|
UStrCpy(adminShare + UStrLen(adminShare),shInfo->shi502_path);
|
|
WCHAR * colon = wcschr(adminShare,L':');
|
|
if ( colon )
|
|
{
|
|
*colon = L'$';
|
|
UStrCpy(adminShare + UStrLen(adminShare),L"\\");
|
|
UStrCpy(adminShare + UStrLen(adminShare),slash+1);
|
|
|
|
}
|
|
else
|
|
{
|
|
// something went wrong -- revert to the given path
|
|
UStrCpy(adminShare,tnode->GetPathName());
|
|
}
|
|
|
|
}
|
|
NetApiBufferFree(shInfo);
|
|
}
|
|
}
|
|
|
|
|
|
// Main routine for resolving file and directory SD's.
|
|
int
|
|
ResolveAll(
|
|
SecurityTranslatorArgs * args, // in- translation settings
|
|
TSDResolveStats * Stats // in- counts of examined, changed objects, etc.
|
|
)
|
|
{
|
|
WCHAR * warg;
|
|
WCHAR * machine;
|
|
UINT errmode;
|
|
int retcode = 0;
|
|
TPathNode * tnode;
|
|
|
|
errmode = SetErrorMode(SEM_FAILCRITICALERRORS);
|
|
|
|
if ( ! retcode )
|
|
{
|
|
WriteOptions(args);
|
|
Stats->InitDisplay(args->NoChange());
|
|
|
|
err.MsgWrite(0,DCT_MSG_FST_STARTING);
|
|
|
|
// Process Files and Directories
|
|
if (! args->IsLocalSystem() )
|
|
{
|
|
TNodeListEnum tenum;
|
|
for (tnode = (TPathNode *)tenum.OpenFirst((TNodeList *)args->PathList()) ; tnode ; tnode = (TPathNode *)tenum.Next() )
|
|
{
|
|
DWORD rc;
|
|
BOOL needToGetBR = FALSE;
|
|
// BOOL abort = FALSE;
|
|
// BOOL firstTime = TRUE;
|
|
|
|
warg = tnode->GetPathName();
|
|
machine = GetMachineName(warg);
|
|
|
|
needToGetBR = ( args->TranslateFiles() );
|
|
|
|
if ( *tnode->GetServerName() && ! args->IsLocalSystem() )
|
|
{
|
|
warg = tnode->GetPathName();
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_S,warg);
|
|
if ( args->TranslateFiles() )
|
|
{
|
|
if ( needToGetBR )
|
|
{
|
|
GetBkupRstrPriv(tnode->GetServerName());
|
|
}
|
|
if ( IsMachineName(warg) )
|
|
{
|
|
// need to process each drive on this machine
|
|
TVolumeEnum vEnum;
|
|
|
|
rc = vEnum.Open(warg,VERIFY_PERSISTENT_ACLS,args->LogVerbose());
|
|
if ( rc )
|
|
{
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_ERROR_ACCESSING_DRIVES_SD,warg,rc);
|
|
}
|
|
else
|
|
{
|
|
while ( warg = vEnum.Next() )
|
|
{
|
|
ResolveFilePath(args,
|
|
Stats,
|
|
warg,
|
|
false, // not valid alone
|
|
false, // no wildcard
|
|
true ); // container
|
|
}
|
|
warg = machine;
|
|
}
|
|
vEnum.Close();
|
|
}
|
|
else
|
|
{
|
|
WCHAR adminShare[LEN_Path];
|
|
|
|
// Verify that the volume is NTFS
|
|
rc = tnode->VerifyPersistentAcls();
|
|
switch ( rc )
|
|
{
|
|
case ERROR_SUCCESS:
|
|
// Process the path
|
|
|
|
// if it's a share name, process the root of the share
|
|
if( IsShareName(tnode->GetPathName()) )
|
|
{
|
|
WCHAR sharePath[LEN_Path];
|
|
|
|
swprintf(sharePath,L"%s\\.",tnode->GetPathName());
|
|
TFileSD sd(sharePath);
|
|
if ( sd.HasSecurity() )
|
|
{
|
|
sd.ResolveSD(args,
|
|
Stats,
|
|
directory,
|
|
NULL);
|
|
}
|
|
}
|
|
// if this is a normal share, convert it to an administrative share
|
|
// path, so that we can take advantage of backup/restore privileges
|
|
BuildAdminPathForShare(tnode,adminShare);
|
|
ResolveFilePath(args,
|
|
Stats,
|
|
adminShare,
|
|
!IsShareName(tnode->GetPathName()),
|
|
ContainsWildcard(tnode->GetPathName()),
|
|
tnode->IsContainer() || IsShareName(tnode->GetPathName()));
|
|
break;
|
|
case ERROR_NO_SECURITY_ON_OBJECT:
|
|
err.MsgWrite(ErrW,DCT_MSG_SKIPPING_FAT_VOLUME_S,warg);
|
|
break;
|
|
default:
|
|
err.SysMsgWrite(ErrE,rc,DCT_MSG_SKIPPING_PATH_SD,warg,rc );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Process the shares for this machine
|
|
if ( args->TranslateShares() )
|
|
{
|
|
if ( IsMachineName(warg) )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_SHARES_S,tnode->GetServerName());
|
|
ServerResolveShares(tnode->GetServerName(),args,Stats);
|
|
}
|
|
else if ( IsShareName(warg) )
|
|
{
|
|
TShareSD sd(warg);
|
|
|
|
if ( sd.HasSecurity() )
|
|
{
|
|
if ( args->LogVerbose() )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_SHARE_S,warg);
|
|
}
|
|
sd.ResolveSD(args,
|
|
Stats,
|
|
share,
|
|
NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// this is a local path
|
|
// Verify that the volume is NTFS
|
|
DWORD rc2;
|
|
|
|
GetBkupRstrPriv((WCHAR*)NULL);
|
|
|
|
rc2 = tnode->VerifyPersistentAcls();
|
|
switch ( rc2 )
|
|
{
|
|
case ERROR_SUCCESS:
|
|
// Process the path
|
|
if ( args->TranslateFiles() )
|
|
{
|
|
ResolveFilePath(args,
|
|
Stats,
|
|
tnode->GetPathName(),
|
|
true, // isValidAlone
|
|
ContainsWildcard(tnode->GetPathName()),
|
|
tnode->IsContainer() );
|
|
}
|
|
break;
|
|
case ERROR_NO_SECURITY_ON_OBJECT:
|
|
err.MsgWrite(ErrW,DCT_MSG_SKIPPING_FAT_VOLUME_S,warg);
|
|
break;
|
|
default:
|
|
err.SysMsgWrite(ErrE,rc2,DCT_MSG_SKIPPING_PATH_SD,warg,rc2 );
|
|
break;
|
|
}
|
|
|
|
}
|
|
if ( machine )
|
|
{
|
|
delete machine;
|
|
machine = NULL;
|
|
}
|
|
}
|
|
tenum.Close();
|
|
}
|
|
else
|
|
{
|
|
// Translate the entire machine
|
|
err.MsgWrite(0,DCT_MSG_LOCAL_TRANSLATION);
|
|
if ( args->TranslateFiles() || args->TranslateRecycler() )
|
|
{
|
|
GetBkupRstrPriv((WCHAR const*)NULL);
|
|
// need to process each drive on this machine
|
|
TVolumeEnum vEnum;
|
|
|
|
vEnum.SetLocalMode(TRUE);
|
|
|
|
DWORD rc2 = vEnum.Open(NULL,VERIFY_PERSISTENT_ACLS,args->LogVerbose());
|
|
if ( rc2 )
|
|
{
|
|
err.SysMsgWrite(ErrE,rc2,DCT_MSG_ERROR_ACCESSING_LOCAL_DRIVES_D,rc2);
|
|
}
|
|
else
|
|
{
|
|
while ( warg = vEnum.Next() )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_S,warg);
|
|
|
|
if ( args->TranslateFiles() )
|
|
{
|
|
ResolveFilePath(args,
|
|
Stats,
|
|
warg,
|
|
false, // not valid alone
|
|
false, // no wildcard
|
|
true ); // container
|
|
}
|
|
if ( args->TranslateRecycler() )
|
|
{
|
|
TranslateRecycler(args,Stats,warg);
|
|
}
|
|
}
|
|
warg = NULL;
|
|
}
|
|
vEnum.Close();
|
|
}
|
|
if ( args->TranslateShares() )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_LOCAL_SHARES,NULL);
|
|
ServerResolveShares(NULL,args,Stats);
|
|
}
|
|
if ( args->TranslatePrinters() )
|
|
{
|
|
err.MsgWrite(0,DCT_MSG_PROCESSING_LOCAL_PRINTERS,NULL);
|
|
ServerResolvePrinters(NULL,args,Stats);
|
|
}
|
|
}
|
|
Stats->DisplayPath(L"");
|
|
} // end if ( ! retcode)
|
|
|
|
SetErrorMode(errmode);
|
|
|
|
return retcode;
|
|
}
|
|
|