1391 lines
44 KiB
C++
1391 lines
44 KiB
C++
//+------------------------------------------------------------------
|
|
//
|
|
// Copyright (C) 1995, Microsoft Corporation.
|
|
//
|
|
// File: t2.cxx
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// History: Nov-93 DaveMont Created.
|
|
//
|
|
//-------------------------------------------------------------------
|
|
#include <t2.hxx>
|
|
#include <filesec.hxx>
|
|
#include <fileenum.hxx>
|
|
#include <dumpsec.hxx>
|
|
#include "caclsmsg.h"
|
|
#include <locale.h>
|
|
#include <string.h>
|
|
#include <winnlsp.h>
|
|
#include <tchar.h>
|
|
#if DBG
|
|
ULONG Debug;
|
|
#endif
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// local prototypes
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOLEAN OpenToken(PHANDLE ph);
|
|
void printfsid(SID *psid, ULONG *outputoffset);
|
|
void printface(ACE_HEADER *paceh, BOOL fdir, ULONG outputoffset);
|
|
void printfmask(ULONG mask, UCHAR acetype, BOOL fdir, ULONG outputoffset);
|
|
WCHAR *mbstowcs(char *aname );
|
|
BOOL GetUserAndAccess(TCHAR *arg, WCHAR **user, ULONG *access);
|
|
#if DBG
|
|
ULONG DebugEnumerate(TCHAR *filename, ULONG option);
|
|
#endif
|
|
ULONG DisplayAces(TCHAR *filename, ULONG option);
|
|
ULONG ModifyAces(TCHAR *filename,
|
|
MODE emode,
|
|
ULONG option,
|
|
TCHAR *argv[],
|
|
LONG astart[], LONG aend[] );
|
|
|
|
ULONG GetCmdLineArgs(INT argc, TCHAR *argv[],
|
|
ULONG *option,
|
|
LONG astart[], LONG aend[],
|
|
MODE *emode
|
|
#if DBG
|
|
,ULONG *debug
|
|
#endif
|
|
);
|
|
ULONG
|
|
__cdecl
|
|
printmessage (FILE* fp, DWORD messageID, ...);
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: vfcprintf
|
|
//
|
|
// Synopsis: prints formatted text to [pOut]. This function will call the
|
|
// defulat c printf functions if it can not call WriteConsole().
|
|
// We are calling WriteConsole() because it will display extended
|
|
// characters, were as fprintf, printf ..., functions do not display
|
|
// multi linguel strings.
|
|
//
|
|
// Arguments: [pOut] - Must be stdout, stderr, otherwise the function will just
|
|
// call standard c functions.
|
|
// [pszFormate] - Format string
|
|
// [argList] - variable length argument list.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void vfcprintf(FILE *pOut, LPCTSTR pszFormat, va_list argList)
|
|
{
|
|
HANDLE handle;
|
|
|
|
//
|
|
// Get the standard handles for output. This assumes that the callers is calling with
|
|
// either stdout or stderr, if it's anything else then just use normal sprintf.
|
|
//
|
|
TCHAR szText[2048];
|
|
if(pOut == stdout){
|
|
handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
} else if(pOut == stderr ){
|
|
handle = GetStdHandle(STD_ERROR_HANDLE);
|
|
} else {
|
|
do_normal:
|
|
#if defined(_UNICODE) || defined(UNICODE)
|
|
vswprintf( szText, pszFormat, argList );
|
|
fwprintf(pOut, szText );
|
|
#else
|
|
vsprintf( szText, pszFormat, argList );
|
|
fprintf(pOut, szText );
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
//
|
|
// If we can't get the output handle then just send it to standard fprintf functions
|
|
//
|
|
if(INVALID_HANDLE_VALUE == handle){
|
|
goto do_normal;
|
|
}
|
|
|
|
//
|
|
// Format the text using standard C functions.
|
|
//
|
|
#if defined(_UNICODE) || defined(UNICODE)
|
|
vswprintf( szText, pszFormat, argList );
|
|
#else
|
|
vsprintf( szText, pszFormat, argList );
|
|
#endif
|
|
|
|
DWORD cRead = 0;
|
|
//
|
|
// If we can't get the console mode from this handle, then it is being piped somewhere else
|
|
// and we must use sprintf to write, because WriteConsole only works with a console
|
|
// output handle.
|
|
//
|
|
if(!GetConsoleMode( handle, &cRead ))
|
|
{
|
|
DWORD cchBuffer = lstrlen(szText);
|
|
LPSTR lpAnsiBuffer = (LPSTR) LocalAlloc(LMEM_FIXED, (cchBuffer+1)*sizeof(WCHAR));
|
|
|
|
if (lpAnsiBuffer != NULL)
|
|
{
|
|
cchBuffer = WideCharToMultiByte(CP_OEMCP,
|
|
0,
|
|
szText,
|
|
cchBuffer + 1,
|
|
lpAnsiBuffer,
|
|
(cchBuffer +1) * sizeof(WCHAR),
|
|
NULL,
|
|
NULL);
|
|
|
|
if (cchBuffer != 0)
|
|
{
|
|
fprintf(pOut,"%s",lpAnsiBuffer);
|
|
}
|
|
|
|
LocalFree(lpAnsiBuffer);
|
|
}
|
|
|
|
} else {
|
|
WriteConsole( handle, szText, lstrlen(szText), &cRead, NULL);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: fcprintf
|
|
//
|
|
// synopsis: Same as fprintf, except this will call vfcprintf, which
|
|
// prints to the console use WriteConsole.
|
|
//
|
|
// Arguments: [pOut] - FILE stream to output to.
|
|
// [pszFormate] - Format string
|
|
// [...] - variable length argument list.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
__cdecl
|
|
fcprintf( FILE *pOut, LPCTSTR pszFormat, ...)
|
|
{
|
|
va_list marker;
|
|
va_start(marker, pszFormat);
|
|
vfcprintf( pOut, pszFormat, marker);
|
|
va_end(marker);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: fcprintf
|
|
//
|
|
// synopsis: Same as printf, except this will call vfcprintf, which
|
|
// prints to the console use WriteConsole.
|
|
//
|
|
// Arguments: [pszFormate] - Format string
|
|
// [...] - variable length argument list.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
__cdecl
|
|
cprintf( LPCTSTR pszFormat, ...)
|
|
{
|
|
va_list marker;
|
|
va_start(marker, pszFormat);
|
|
vfcprintf( stdout, pszFormat, marker);
|
|
va_end(marker);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: Usage
|
|
//
|
|
// Synopsis: prints usage functionality
|
|
//
|
|
// Arguments: none
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
VOID usage()
|
|
{
|
|
printmessage(stdout, MSG_CACLS_USAGE, NULL);
|
|
|
|
#if DBG
|
|
if (Debug)
|
|
{
|
|
printf("\n /B deBug <[#]>\n");
|
|
printf(" default is display error returned\n");
|
|
printf(" in /B '#' is a mask: 1 display SIDS values\n");
|
|
printf(" 2 display access masks\n");
|
|
printf(" 4 display error returned\n");
|
|
printf(" 8 display error location\n");
|
|
printf(" 0x10 verbose\n");
|
|
printf(" 0x20 verboser\n");
|
|
printf(" 0x40 enumerate names\n");
|
|
printf(" 0x80 enumerate failures\n");
|
|
printf(" 0x100 enumerate starts and returns\n");
|
|
printf(" 0x200 enumerate extra data\n");
|
|
printf(" 0x400 size allocation data\n");
|
|
printf(" 0x800 display enumeration of files\n");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
BOOL
|
|
IsAclSupported(LPCWSTR lpszFileName)
|
|
{
|
|
BOOL bReturn = TRUE;
|
|
WCHAR szVolumePathName[MAX_PATH+1];
|
|
if(GetVolumePathName(lpszFileName,
|
|
szVolumePathName,
|
|
MAX_PATH))
|
|
{
|
|
int nLen = wcslen(szVolumePathName);
|
|
if((WCHAR)szVolumePathName[nLen -1] != L'\\')
|
|
{
|
|
szVolumePathName[nLen] = L'\\';
|
|
szVolumePathName[nLen++] = L'\0';
|
|
}
|
|
DWORD dwFlags = 0;
|
|
if(GetVolumeInformation(szVolumePathName,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&dwFlags,
|
|
NULL,
|
|
0))
|
|
{
|
|
if(!(FS_PERSISTENT_ACLS & dwFlags))
|
|
{
|
|
printmessage(stdout,MSG_CACLS_NOT_NTFS);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
return bReturn;
|
|
}
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: Main, Public
|
|
//
|
|
// Synopsis: main!!
|
|
//
|
|
// Arguments: IN [argc] - cmdline arguement count
|
|
// IN [argv] - input cmdline arguements
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#if defined( __cplusplus )
|
|
extern "C" {
|
|
#endif
|
|
VOID _cdecl wmain(int argc, wchar_t *argvw[])
|
|
{
|
|
char lBuf[6];
|
|
|
|
//
|
|
// Set the local to system OEM code page.
|
|
//
|
|
setlocale(LC_ALL, ".OCP" );
|
|
SetThreadUILanguage(0);
|
|
|
|
//
|
|
// Convert the wide character set to string array.
|
|
//
|
|
LONG astart[MAX_OPTIONS], aend[MAX_OPTIONS];
|
|
MODE emode;
|
|
|
|
LONG ret = 0;
|
|
ULONG option;
|
|
|
|
if (ERROR_SUCCESS != (ret = GetCmdLineArgs(argc, argvw,
|
|
&option,
|
|
astart, aend,
|
|
&emode
|
|
#if DBG
|
|
,&Debug
|
|
#endif
|
|
)))
|
|
{
|
|
usage();
|
|
exit(ret);
|
|
}
|
|
|
|
if(!IsAclSupported(argvw[1]))
|
|
exit(1);
|
|
switch (emode)
|
|
{
|
|
case MODE_DISPLAY:
|
|
ret = DisplayAces(argvw[1], option);
|
|
break;
|
|
case MODE_REPLACE:
|
|
case MODE_MODIFY:
|
|
ret = ModifyAces(argvw[1], emode, option, argvw, astart, aend );
|
|
break;
|
|
#if DBG
|
|
case MODE_DEBUG_ENUMERATE:
|
|
ret = DebugEnumerate(argvw[1], option);
|
|
break;
|
|
#endif
|
|
default:
|
|
{
|
|
usage();
|
|
exit(1);
|
|
}
|
|
}
|
|
if (ERROR_SUCCESS != ret)
|
|
{
|
|
LAST_ERROR((stderr, "Cacls failed, %ld\n",ret))
|
|
if( ret == ERROR_BAD_ARGUMENTS )
|
|
ret = MSG_CACLS_INVALID_ARGUMENT;
|
|
printmessage(stderr, ret, NULL);
|
|
|
|
if( ret == MSG_CACLS_INVALID_ARGUMENT )
|
|
usage();
|
|
}
|
|
exit(ret);
|
|
}
|
|
#if defined( __cplusplus )
|
|
}
|
|
#endif
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetCmdLineArgs
|
|
//
|
|
// Synopsis: gets and parses command line arguments into commands
|
|
// recognized by this program
|
|
//
|
|
// Arguments: IN [argc] - cmdline arguement count
|
|
// IN [argv] - input cmdline arguements
|
|
// OUT [option] - requested option
|
|
// OUT [astart] - start of arguments for each option
|
|
// OUT [aend] - end of arguments for each option
|
|
// OUT [emode] - mode of operation
|
|
// OUT [debug] - debug mask
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG GetCmdLineArgs(INT argc, TCHAR *argv[],
|
|
ULONG *option,
|
|
LONG astart[], LONG aend[],
|
|
MODE *emode
|
|
#if DBG
|
|
,ULONG *debug
|
|
#endif
|
|
)
|
|
{
|
|
ARG_MODE_INDEX am = ARG_MODE_INDEX_NEED_OPTION;
|
|
|
|
#if DBG
|
|
*debug = 0;
|
|
#endif
|
|
*emode = MODE_DISPLAY;
|
|
*option = 0;
|
|
|
|
for (LONG j=0; j < MAX_OPTIONS ;j++ )
|
|
{
|
|
astart[j] = 0;
|
|
aend[j] = 0;
|
|
}
|
|
|
|
if ( (argc < 2) || (argv[1][0] == '/') )
|
|
{
|
|
#if DBG
|
|
// do this so debug args are printed out
|
|
|
|
if (argc >= 2)
|
|
{
|
|
if ( (0 == lstrcmpi(&argv[1][1], TEXT("deBug"))) ||
|
|
(0 == lstrcmpi(&argv[1][1], TEXT("b"))) )
|
|
{
|
|
*debug = DEBUG_LAST_ERROR;
|
|
}
|
|
}
|
|
#endif
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
|
|
for (LONG k = 2; k < argc ; k++ )
|
|
{
|
|
if (argv[k][0] == '/')
|
|
{
|
|
switch (am)
|
|
{
|
|
case ARG_MODE_INDEX_NEED_OPTION:
|
|
#if DBG
|
|
case ARG_MODE_INDEX_DEBUG:
|
|
#endif
|
|
break;
|
|
|
|
case ARG_MODE_INDEX_DENY:
|
|
case ARG_MODE_INDEX_REVOKE:
|
|
case ARG_MODE_INDEX_GRANT:
|
|
case ARG_MODE_INDEX_REPLACE:
|
|
if (astart[am] == k)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
break;
|
|
|
|
default:
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
|
|
if ( (0 == lstrcmpi(&argv[k][1], TEXT("Tree"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("t"))) )
|
|
{
|
|
if (*option & OPTION_TREE)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
*option |= OPTION_TREE;
|
|
am = ARG_MODE_INDEX_NEED_OPTION;
|
|
continue;
|
|
}
|
|
|
|
if ( (0 == lstrcmpi(&argv[k][1], TEXT("Continue"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("c"))) )
|
|
{
|
|
if (*option & OPTION_CONTINUE_ON_ERROR)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
*option |= OPTION_CONTINUE_ON_ERROR;
|
|
am = ARG_MODE_INDEX_NEED_OPTION;
|
|
continue;
|
|
}
|
|
|
|
if ( (0 == lstrcmpi(&argv[k][1], TEXT("Edit"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("E"))) )
|
|
{
|
|
if (*emode != MODE_DISPLAY)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
*emode = MODE_MODIFY;
|
|
am = ARG_MODE_INDEX_NEED_OPTION;
|
|
continue;
|
|
}
|
|
|
|
#if DBG
|
|
if ( (0 == lstrcmpi(&argv[k][1], TEXT("deBug"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("b"))) )
|
|
{
|
|
if (*debug)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
am = ARG_MODE_INDEX_DEBUG;
|
|
*debug = DEBUG_LAST_ERROR;
|
|
continue;
|
|
}
|
|
#endif
|
|
if ( (0 == lstrcmpi(&argv[k][1], TEXT("Deny"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("D"))) )
|
|
{
|
|
am = ARG_MODE_INDEX_DENY;
|
|
*option |= OPTION_DENY;
|
|
} else if ( (0 == lstrcmpi(&argv[k][1], TEXT("Revoke"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("R"))) )
|
|
{
|
|
am = ARG_MODE_INDEX_REVOKE;
|
|
*option |= OPTION_REVOKE;
|
|
} else if ( (0 == lstrcmpi(&argv[k][1], TEXT("Grant"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("G"))) )
|
|
{
|
|
am = ARG_MODE_INDEX_GRANT;
|
|
*option |= OPTION_GRANT;
|
|
} else if ( (0 == lstrcmpi(&argv[k][1], TEXT("rePlace"))) ||
|
|
(0 == lstrcmpi(&argv[k][1], TEXT("P"))) )
|
|
{
|
|
*option |= OPTION_REPLACE;
|
|
am = ARG_MODE_INDEX_REPLACE;
|
|
} else
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
|
|
if (astart[am] != 0)
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
astart[am] = k+1;
|
|
} else
|
|
{
|
|
switch (am)
|
|
{
|
|
case ARG_MODE_INDEX_NEED_OPTION:
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
|
|
#if DBG
|
|
case ARG_MODE_INDEX_DEBUG:
|
|
*debug = _wtol(argv[k]);
|
|
if (*debug & DEBUG_ENUMERATE)
|
|
if (*emode == MODE_DISPLAY)
|
|
*emode = MODE_DEBUG_ENUMERATE;
|
|
else
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
|
|
am = ARG_MODE_INDEX_NEED_OPTION;
|
|
break;
|
|
#endif
|
|
case ARG_MODE_INDEX_DENY:
|
|
case ARG_MODE_INDEX_REVOKE:
|
|
case ARG_MODE_INDEX_GRANT:
|
|
case ARG_MODE_INDEX_REPLACE:
|
|
aend[am] = k+1;
|
|
break;
|
|
|
|
default:
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ( (*option & OPTION_DENY) && (aend[ARG_MODE_INDEX_DENY] == 0) ) ||
|
|
( (*option & OPTION_REVOKE) && (aend[ARG_MODE_INDEX_REVOKE] == 0) ) ||
|
|
( (*option & OPTION_GRANT) && (aend[ARG_MODE_INDEX_GRANT] == 0) ) ||
|
|
( (*option & OPTION_REPLACE) && (aend[ARG_MODE_INDEX_REPLACE] == 0) ) )
|
|
{
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
} else if ( (*option & OPTION_DENY) ||
|
|
(*option & OPTION_REVOKE) ||
|
|
(*option & OPTION_GRANT) ||
|
|
(*option & OPTION_REPLACE) )
|
|
{
|
|
if (*emode == MODE_DISPLAY)
|
|
{
|
|
if (*option & OPTION_REVOKE)
|
|
{
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
*emode = MODE_REPLACE;
|
|
}
|
|
}
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: DisplayAces
|
|
//
|
|
// Synopsis: displays ACL from specified file
|
|
//
|
|
// Arguments: IN [filename] - file name
|
|
// IN [option] - display option
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG DisplayAces(TCHAR *filename, ULONG option)
|
|
{
|
|
CFileEnumerate cfe(option & OPTION_TREE);
|
|
WCHAR *pwfilename;
|
|
BOOL fdir;
|
|
ULONG ret;
|
|
|
|
if (NO_ERROR == (ret = cfe.Init(filename, &pwfilename, &fdir)))
|
|
{
|
|
while ( (NO_ERROR == ret) ||
|
|
( ( (ERROR_ACCESS_DENIED == ret ) || (ERROR_SHARING_VIOLATION == ret) )&&
|
|
(option & OPTION_CONTINUE_ON_ERROR) ) )
|
|
{
|
|
#if DBG
|
|
if (fdir)
|
|
DISPLAY((stderr, "processing file: "))
|
|
else
|
|
DISPLAY((stderr, "processing dir: "))
|
|
#endif
|
|
cprintf( TEXT("%s"), pwfilename);
|
|
if (ERROR_ACCESS_DENIED == ret)
|
|
{
|
|
printmessage(stdout,MSG_CACLS_ACCESS_DENIED, NULL);
|
|
} else if (ERROR_SHARING_VIOLATION == ret)
|
|
{
|
|
printmessage(stdout,MSG_CACLS_SHARING_VIOLATION, NULL);
|
|
} else
|
|
{
|
|
DISPLAY((stderr, "\n"))
|
|
VERBOSE((stderr, "\n"))
|
|
CDumpSecurity cds(pwfilename);
|
|
|
|
if (NO_ERROR == (ret = cds.Init()))
|
|
{
|
|
#if DBG
|
|
if (Debug & DEBUG_VERBOSE)
|
|
{
|
|
SID *psid;
|
|
ULONG oo;
|
|
|
|
if (NO_ERROR == (ret = cds.GetSDOwner(&psid)))
|
|
{
|
|
printf(" Owner = ");
|
|
printfsid(psid, &oo);
|
|
if (NO_ERROR == (ret = cds.GetSDGroup(&psid)))
|
|
{
|
|
printf(" Group = ");
|
|
printfsid(psid, &oo);
|
|
}
|
|
else
|
|
ERRORS((stderr, "GetSDGroup failed, %d\n",ret))
|
|
}
|
|
else
|
|
ERRORS((stderr, "GetSDOwner failed, %d\n",ret))
|
|
}
|
|
#endif
|
|
ACE_HEADER *paceh;
|
|
|
|
LONG retace;
|
|
if (NO_ERROR == ret)
|
|
for (retace = cds.GetNextAce(&paceh); retace >= 0; )
|
|
{
|
|
printface(paceh, fdir, wcslen(pwfilename));
|
|
retace = cds.GetNextAce(&paceh);
|
|
if (retace >= 0)
|
|
printf("%*s",
|
|
WideCharToMultiByte(CP_ACP, 0,
|
|
pwfilename, -1,
|
|
NULL, 0,
|
|
NULL, NULL)-1," ");
|
|
}
|
|
}
|
|
#if DBG
|
|
else
|
|
ERRORS((stderr, "cds.init failed, %d\n",ret))
|
|
#endif
|
|
}
|
|
fprintf(stdout, "\n");
|
|
|
|
if ( (NO_ERROR == ret) ||
|
|
( ( (ERROR_ACCESS_DENIED == ret ) || (ERROR_SHARING_VIOLATION == ret) )&&
|
|
(option & OPTION_CONTINUE_ON_ERROR) ) )
|
|
ret = cfe.Next(&pwfilename, &fdir);
|
|
}
|
|
|
|
switch (ret)
|
|
{
|
|
case ERROR_NO_MORE_FILES:
|
|
ret = ERROR_SUCCESS;
|
|
break;
|
|
case ERROR_ACCESS_DENIED:
|
|
case ERROR_SHARING_VIOLATION:
|
|
break;
|
|
case ERROR_SUCCESS:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
} else
|
|
{
|
|
ERRORS((stderr, "cfe.init failed, %d\n",ret))
|
|
}
|
|
return(ret);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: ModifyAces
|
|
//
|
|
// Synopsis: modifies the aces for the specified file(s)
|
|
//
|
|
// Arguments: IN [filename] - name of file(s) to modify the aces on
|
|
// IN [emode] - mode of operation
|
|
// IN [option] - requested option
|
|
// IN [astart] - start of arguments for each option
|
|
// IN [aend] - end of arguments for each option
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG ModifyAces(TCHAR *filename,
|
|
MODE emode,
|
|
ULONG option,
|
|
TCHAR *argv[],
|
|
LONG astart[], LONG aend[])
|
|
{
|
|
CDaclWrap cdw;
|
|
CFileEnumerate cfe(option & OPTION_TREE);
|
|
WCHAR *user = NULL;
|
|
ULONG access;
|
|
ULONG ret = ERROR_SUCCESS;
|
|
WCHAR *pwfilename;
|
|
ULONG curoption;
|
|
|
|
VERBOSERW((stderr, TEXT("user:permission pairs\n") ))
|
|
|
|
// first proces the command line args to build up the new ace
|
|
|
|
for (ULONG j = 0, k = 1;j < MAX_OPTIONS ; k <<= 1, j++ )
|
|
{
|
|
curoption = k;
|
|
if (option & k)
|
|
{
|
|
for (LONG q = astart[j];
|
|
q < aend[j] ; q++ )
|
|
{
|
|
VERBOSERW((stderr, TEXT(" %s\n"),argv[q] ))
|
|
|
|
if ((k & OPTION_GRANT) || (k & OPTION_REPLACE))
|
|
{
|
|
if (!GetUserAndAccess(argv[q], &user, &access))
|
|
{
|
|
#if !defined(UNICODE) || !defined(_UNICODE)
|
|
if (user)
|
|
LocalFree(user);
|
|
#endif
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
if (GENERIC_NONE == access)
|
|
{
|
|
if (!(k & OPTION_REPLACE))
|
|
{
|
|
#if !defined(UNICODE) || !defined(_UNICODE)
|
|
if (user)
|
|
LocalFree(user);
|
|
#endif
|
|
return(ERROR_BAD_ARGUMENTS);
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
#if !defined(UNICODE) || !defined(_UNICODE)
|
|
user = mbstowcs(argv[q]);
|
|
#else
|
|
user = argv[q];
|
|
#endif
|
|
access = GENERIC_NONE;
|
|
}
|
|
|
|
VERBOSERW((stderr, TEXT("OPTION = %d, USER = %ws, ACCESS = %lx\n"),
|
|
option,
|
|
user,
|
|
access))
|
|
|
|
|
|
if (ERROR_SUCCESS != (ret = cdw.SetAccess(curoption,
|
|
user,
|
|
NULL,
|
|
access)))
|
|
{
|
|
ERRORS((stderr, "SetAccess for %ws:%lx failed, %d\n",
|
|
user,
|
|
access,
|
|
ret))
|
|
#if !defined(UNICODE) || !defined(_UNICODE)
|
|
LocalFree(user);
|
|
#endif
|
|
return(ret);
|
|
}
|
|
#if !defined(UNICODE) || !defined(_UNICODE)
|
|
LocalFree(user);
|
|
#endif
|
|
user = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL fdir;
|
|
|
|
if (emode == MODE_REPLACE)
|
|
{
|
|
CHAR well[MAX_PATH];
|
|
CHAR msgbuf[MAX_PATH];
|
|
printmessage(stdout,MSG_CACLS_ARE_YOU_SURE, NULL);
|
|
FormatMessageA(FORMAT_MESSAGE_FROM_HMODULE, NULL, MSG_CACLS_Y, 0,
|
|
msgbuf, MAX_PATH, NULL);
|
|
fgets(well,MAX_PATH,stdin);
|
|
|
|
// remove the trailing return
|
|
if ('\n' == well[strlen(well) - sizeof(CHAR)])
|
|
well[strlen(well) - sizeof(CHAR)] = '\0';
|
|
|
|
if (0 != _stricmp(well, msgbuf))
|
|
{
|
|
FormatMessageA(FORMAT_MESSAGE_FROM_HMODULE, NULL, MSG_CACLS_YES, 0,
|
|
msgbuf, MAX_PATH, NULL);
|
|
if (0 != _stricmp(well, msgbuf))
|
|
return(ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
if (NO_ERROR == (ret = cfe.Init(filename, &pwfilename, &fdir)))
|
|
{
|
|
while ( (NO_ERROR == ret) ||
|
|
( ( (ERROR_ACCESS_DENIED == ret ) || (ERROR_SHARING_VIOLATION == ret) )&&
|
|
(option & OPTION_CONTINUE_ON_ERROR) ) )
|
|
{
|
|
CFileSecurity cfs(pwfilename);
|
|
|
|
if (NO_ERROR == (ret = cfs.Init()))
|
|
{
|
|
if (NO_ERROR != (ret = cfs.SetFS(emode == MODE_REPLACE ? FALSE : TRUE, &cdw, fdir)))
|
|
{
|
|
if (!(((ERROR_ACCESS_DENIED == ret) || (ERROR_SHARING_VIOLATION == ret)) &&
|
|
(option & OPTION_CONTINUE_ON_ERROR)))
|
|
{
|
|
ERRORS((stderr, "SetFS on %ws failed %ld\n",pwfilename, ret))
|
|
return(ret);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If the error is access denied or sharing violation and we are to continue on error,
|
|
// then keep going. Otherwise bail out here.
|
|
//
|
|
|
|
if (!(((ERROR_ACCESS_DENIED == ret) || (ERROR_SHARING_VIOLATION == ret)) &&
|
|
(option & OPTION_CONTINUE_ON_ERROR))) {
|
|
|
|
ERRORS((stderr, "init failed, %d\n",ret))
|
|
return(ret);
|
|
}
|
|
}
|
|
|
|
if (NO_ERROR == ret)
|
|
{
|
|
|
|
if (fdir)
|
|
{
|
|
printmessage(stdout, MSG_CACLS_PROCESSED_DIR, NULL);
|
|
cprintf(L"%s\n", pwfilename);
|
|
}
|
|
else
|
|
{
|
|
printmessage(stdout, MSG_CACLS_PROCESSED_FILE, NULL);
|
|
cprintf(L"%s\n", pwfilename);
|
|
}
|
|
}
|
|
else if (ERROR_ACCESS_DENIED == ret)
|
|
{
|
|
printmessage(stdout, MSG_CACLS_ACCESS_DENIED, NULL);
|
|
cprintf(L"%s\n", pwfilename);
|
|
}
|
|
else if (ret == ERROR_SHARING_VIOLATION)
|
|
{
|
|
printmessage(stdout, MSG_CACLS_SHARING_VIOLATION, NULL);
|
|
cprintf(L"%s\n", pwfilename);
|
|
}
|
|
|
|
if ( (NO_ERROR == ret) ||
|
|
( ( (ERROR_ACCESS_DENIED == ret ) || (ERROR_SHARING_VIOLATION == ret) ) &&
|
|
(option & OPTION_CONTINUE_ON_ERROR) ) )
|
|
ret = cfe.Next(&pwfilename, &fdir);
|
|
}
|
|
|
|
switch (ret)
|
|
{
|
|
case ERROR_NO_MORE_FILES:
|
|
ret = ERROR_SUCCESS;
|
|
break;
|
|
case ERROR_ACCESS_DENIED:
|
|
case ERROR_SHARING_VIOLATION:
|
|
break;
|
|
case ERROR_SUCCESS:
|
|
break;
|
|
default:
|
|
DISPLAY((stderr, "%ws failed: %d\n", pwfilename, ret))
|
|
break;
|
|
}
|
|
} else
|
|
ERRORS((stderr, "file enumeration failed to initialize %ws, %ld\n",pwfilename, ret))
|
|
|
|
if (ret == ERROR_NO_MORE_FILES)
|
|
{
|
|
ret = ERROR_SUCCESS;
|
|
}
|
|
|
|
if (ret != ERROR_SUCCESS)
|
|
{
|
|
ERRORS((stderr, "Enumeration failed, %d\n",ret))
|
|
}
|
|
|
|
return(ret);
|
|
}
|
|
#if DBG
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: DebugEnumerate
|
|
//
|
|
// Synopsis: debug function
|
|
//
|
|
// Arguments: IN [filename] - file name
|
|
// IN [option] - option
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG DebugEnumerate(TCHAR *filename, ULONG option)
|
|
{
|
|
CFileEnumerate cfe(option & OPTION_TREE);
|
|
WCHAR *pwfilename;
|
|
BOOL fdir;
|
|
ULONG ret;
|
|
|
|
ret = cfe.Init(filename, &pwfilename, &fdir);
|
|
while ( (ERROR_SUCCESS == ret) ||
|
|
( (ERROR_ACCESS_DENIED == ret ) &&
|
|
(option & OPTION_CONTINUE_ON_ERROR) ) )
|
|
{
|
|
if (fdir)
|
|
printf("dir name = %ws%ws\n",pwfilename,
|
|
ERROR_ACCESS_DENIED == ret ? L"ACCESS DENIED" : L"");
|
|
else
|
|
printf("file name = %ws%ws\n",pwfilename,
|
|
ERROR_ACCESS_DENIED == ret ? L"ACCESS DENIED" : L"");
|
|
ret = cfe.Next(&pwfilename, &fdir);
|
|
}
|
|
if (ret == ERROR_ACCESS_DENIED)
|
|
{
|
|
if (fdir)
|
|
printf("dir name = %ws%ws\n",pwfilename,
|
|
ERROR_ACCESS_DENIED == ret ? L"ACCESS DENIED" : L"");
|
|
else
|
|
printf("file name = %ws%ws\n",pwfilename,
|
|
ERROR_ACCESS_DENIED == ret ? L"ACCESS DENIED" : L"");
|
|
}
|
|
if (ret != ERROR_NO_MORE_FILES)
|
|
printf("Enumeration failed, %d\n",ret);
|
|
|
|
return(ret);
|
|
}
|
|
#endif
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetUserAccess
|
|
//
|
|
// Synopsis: parses an input string for user:access
|
|
//
|
|
// Arguments: IN [arg] - input string to parse
|
|
// OUT [user] - user if found
|
|
// OUT [access] - access if found
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL GetUserAndAccess(TCHAR *arg, WCHAR **user, ULONG *access)
|
|
{
|
|
TCHAR *saccess = wcschr(arg,':');
|
|
if (saccess)
|
|
{
|
|
*saccess = NULL;
|
|
saccess++;
|
|
|
|
if (wcschr(saccess,':'))
|
|
return(FALSE);
|
|
#if defined(UNICODE) || defined(_UNICODE)
|
|
*user = arg;
|
|
#else
|
|
*user = mbstowcs(arg);
|
|
#endif
|
|
|
|
if (0 == lstrcmpi(saccess, TEXT("F") ))
|
|
{
|
|
*access = ( STANDARD_RIGHTS_ALL |
|
|
FILE_READ_DATA |
|
|
FILE_WRITE_DATA |
|
|
FILE_APPEND_DATA |
|
|
FILE_READ_EA |
|
|
FILE_WRITE_EA |
|
|
FILE_EXECUTE |
|
|
FILE_DELETE_CHILD |
|
|
FILE_READ_ATTRIBUTES |
|
|
FILE_WRITE_ATTRIBUTES );
|
|
}
|
|
else if (0 == lstrcmpi(saccess,TEXT("R") ))
|
|
{
|
|
*access = FILE_GENERIC_READ | FILE_EXECUTE;
|
|
}
|
|
else if (0 == lstrcmpi(saccess, TEXT("C") ))
|
|
{
|
|
*access = FILE_GENERIC_WRITE | FILE_GENERIC_READ | FILE_EXECUTE | DELETE;
|
|
}
|
|
else if (0 == lstrcmpi(saccess, TEXT("N") ))
|
|
{
|
|
*access = GENERIC_NONE;
|
|
}
|
|
else if (0 == lstrcmpi(saccess, TEXT("W") ))
|
|
{
|
|
*access = FILE_GENERIC_WRITE | FILE_EXECUTE;
|
|
}
|
|
else
|
|
return(FALSE);
|
|
return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Function: mbstowcs
|
|
//
|
|
// Synopsis: converts char to wchar, allocates space for wchar
|
|
//
|
|
// Arguments: IN [aname] - char string
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
WCHAR *mbstowcs(char *aname )
|
|
{
|
|
if (aname)
|
|
{
|
|
WCHAR *pwname = NULL;
|
|
pwname = (WCHAR *)LocalAlloc(LMEM_FIXED, sizeof(WCHAR) * (strlen(aname)+1));
|
|
if (NULL == pwname)
|
|
return(NULL);
|
|
WCHAR *prwname = pwname;
|
|
if (MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
|
|
aname, -1,
|
|
prwname, sizeof(WCHAR)*(strlen(aname)+1)) == 0)
|
|
return(NULL);
|
|
return(pwname);
|
|
} else
|
|
return(NULL);
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function:
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOLEAN OpenToken(PHANDLE ph)
|
|
{
|
|
HANDLE hprocess;
|
|
|
|
hprocess = OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
|
|
if (hprocess == NULL)
|
|
return(FALSE);
|
|
|
|
if (OpenProcessToken(hprocess, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ph))
|
|
{
|
|
CloseHandle(hprocess);
|
|
return(TRUE);
|
|
}
|
|
|
|
CloseHandle(hprocess);
|
|
return(FALSE);
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: printfsid
|
|
//
|
|
// Synopsis: prints a NT SID
|
|
//
|
|
// Arguments: IN [psid] - pointer to the sid to print
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void printfsid(SID *psid, ULONG *outputoffset)
|
|
{
|
|
#if DBG
|
|
if ((Debug & DEBUG_VERBOSE) || (Debug & DEBUG_DISPLAY_SIDS))
|
|
{
|
|
printf("S-%lx",psid->Revision);
|
|
|
|
if ( (psid->IdentifierAuthority.Value[0] != 0) ||
|
|
(psid->IdentifierAuthority.Value[1] != 0) )
|
|
{
|
|
printf("0x%02hx%02hx%02hx%02hx%02hx%02hx",
|
|
(USHORT)psid->IdentifierAuthority.Value[0],
|
|
(USHORT)psid->IdentifierAuthority.Value[1],
|
|
(USHORT)psid->IdentifierAuthority.Value[2],
|
|
(USHORT)psid->IdentifierAuthority.Value[3],
|
|
(USHORT)psid->IdentifierAuthority.Value[4],
|
|
(USHORT)psid->IdentifierAuthority.Value[5] );
|
|
} else
|
|
{
|
|
printf("-%lu",
|
|
(ULONG)psid->IdentifierAuthority.Value[5] +
|
|
(ULONG)(psid->IdentifierAuthority.Value[4] << 8) +
|
|
(ULONG)(psid->IdentifierAuthority.Value[3] << 16) +
|
|
(ULONG)(psid->IdentifierAuthority.Value[2] << 24) );
|
|
}
|
|
|
|
if ( 0 < psid->SubAuthorityCount )
|
|
{
|
|
for (int k = 0; k < psid->SubAuthorityCount; k++ )
|
|
{
|
|
printf("-%d",psid->SubAuthority[k]);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
ULONG ret;
|
|
|
|
CAccount ca(psid, NULL);
|
|
|
|
WCHAR *domain = NULL;
|
|
WCHAR *user;
|
|
|
|
if (NO_ERROR == ( ret = ca.GetAccountDomain(&domain) ) )
|
|
{
|
|
if ( (NULL == domain) || (0 == wcslen(domain)) )
|
|
{
|
|
fprintf(stdout, " ");
|
|
*outputoffset +=1;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stdout, " ");
|
|
wprintf(L"%s", domain);
|
|
fprintf(stdout, "\\");
|
|
*outputoffset += 2 + wcslen( domain );;
|
|
}
|
|
|
|
if (NO_ERROR == ( ret = ca.GetAccountName(&user) ) )
|
|
{
|
|
wprintf(L"%s", user);
|
|
fprintf(stdout, ":");
|
|
*outputoffset += 1 + wcslen(user);
|
|
} else
|
|
{
|
|
*outputoffset += printmessage(stdout, MSG_CACLS_NAME_NOT_FOUND, NULL);
|
|
|
|
ERRORS((stderr, "(%lx)",ret))
|
|
}
|
|
} else
|
|
{
|
|
*outputoffset+= printmessage(stdout, MSG_CACLS_DOMAIN_NOT_FOUND, NULL);
|
|
ERRORS((stderr, "(%lx)",ret))
|
|
}
|
|
VERBOSE((stderr, "\n"))
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: printface
|
|
//
|
|
// Synopsis: prints the specifed ace
|
|
//
|
|
// Arguments: IN [paceh] - input ace (header)
|
|
// IN [fdir] - TRUE = directory (different display options)
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
void printface(ACE_HEADER *paceh, BOOL fdir, ULONG outputoffset)
|
|
{
|
|
VERBOSE((stderr, " "))
|
|
VERBOSER((stderr, "\npaceh->AceType = %x\n",paceh->AceType ))
|
|
VERBOSER((stderr, "paceh->AceFlags = %x\n",paceh->AceFlags ))
|
|
VERBOSER((stderr, "paceh->AceSize = %x\n",paceh->AceSize ))
|
|
ACCESS_ALLOWED_ACE *paaa = (ACCESS_ALLOWED_ACE *)paceh;
|
|
printfsid((SID *)&(paaa->SidStart),&outputoffset);
|
|
if (paceh->AceFlags & OBJECT_INHERIT_ACE )
|
|
{
|
|
outputoffset+= printmessage(stdout, MSG_CACLS_OBJECT_INHERIT, NULL);
|
|
}
|
|
if (paceh->AceFlags & CONTAINER_INHERIT_ACE )
|
|
{
|
|
outputoffset+= printmessage(stdout, MSG_CACLS_CONTAINER_INHERIT, NULL);
|
|
}
|
|
if (paceh->AceFlags & NO_PROPAGATE_INHERIT_ACE)
|
|
{
|
|
outputoffset+= printmessage(stdout, MSG_CACLS_NO_PROPAGATE_INHERIT, NULL);
|
|
}
|
|
if (paceh->AceFlags & INHERIT_ONLY_ACE )
|
|
{
|
|
outputoffset+= printmessage(stdout, MSG_CACLS_INHERIT_ONLY, NULL);
|
|
}
|
|
|
|
if (paceh->AceType == ACCESS_DENIED_ACE_TYPE)
|
|
{
|
|
DISPLAY_MASK((stderr, "(DENIED)"))
|
|
VERBOSE((stderr, "(DENIED)"))
|
|
}
|
|
|
|
printfmask(paaa->Mask, paceh->AceType, fdir, outputoffset);
|
|
fprintf(stdout, "\n");
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: printfmask
|
|
//
|
|
// Synopsis: prints the access mask
|
|
//
|
|
// Arguments: IN [mask] - the access mask
|
|
// IN [acetype] - allowed/denied
|
|
// IN [fdir] - TRUE = directory
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CHAR *aRightsStr[] = { "STANDARD_RIGHTS_ALL",
|
|
"DELETE",
|
|
"READ_CONTROL",
|
|
"WRITE_DAC",
|
|
"WRITE_OWNER",
|
|
"SYNCHRONIZE",
|
|
"STANDARD_RIGHTS_REQUIRED",
|
|
"SPECIFIC_RIGHTS_ALL",
|
|
"ACCESS_SYSTEM_SECURITY",
|
|
"MAXIMUM_ALLOWED",
|
|
"GENERIC_READ",
|
|
"GENERIC_WRITE",
|
|
"GENERIC_EXECUTE",
|
|
"GENERIC_ALL",
|
|
"FILE_GENERIC_READ",
|
|
"FILE_GENERIC_WRITE",
|
|
"FILE_GENERIC_EXECUTE",
|
|
"FILE_READ_DATA",
|
|
//FILE_LIST_DIRECTORY
|
|
"FILE_WRITE_DATA",
|
|
//FILE_ADD_FILE
|
|
"FILE_APPEND_DATA",
|
|
//FILE_ADD_SUBDIRECTORY
|
|
"FILE_READ_EA",
|
|
"FILE_WRITE_EA",
|
|
"FILE_EXECUTE",
|
|
//FILE_TRAVERSE
|
|
"FILE_DELETE_CHILD",
|
|
"FILE_READ_ATTRIBUTES",
|
|
"FILE_WRITE_ATTRIBUTES" };
|
|
|
|
#define NUMRIGHTS 26
|
|
ULONG aRights[NUMRIGHTS] = { STANDARD_RIGHTS_ALL ,
|
|
DELETE ,
|
|
READ_CONTROL ,
|
|
WRITE_DAC ,
|
|
WRITE_OWNER ,
|
|
SYNCHRONIZE ,
|
|
STANDARD_RIGHTS_REQUIRED ,
|
|
SPECIFIC_RIGHTS_ALL ,
|
|
ACCESS_SYSTEM_SECURITY ,
|
|
MAXIMUM_ALLOWED ,
|
|
GENERIC_READ ,
|
|
GENERIC_WRITE ,
|
|
GENERIC_EXECUTE ,
|
|
GENERIC_ALL ,
|
|
FILE_GENERIC_READ ,
|
|
FILE_GENERIC_WRITE ,
|
|
FILE_GENERIC_EXECUTE ,
|
|
FILE_READ_DATA ,
|
|
//FILE_LIST_DIRECTORY ,
|
|
FILE_WRITE_DATA ,
|
|
//FILE_ADD_FILE ,
|
|
FILE_APPEND_DATA ,
|
|
//FILE_ADD_SUBDIRECTORY ,
|
|
FILE_READ_EA ,
|
|
FILE_WRITE_EA ,
|
|
FILE_EXECUTE ,
|
|
//FILE_TRAVERSE ,
|
|
FILE_DELETE_CHILD ,
|
|
FILE_READ_ATTRIBUTES ,
|
|
FILE_WRITE_ATTRIBUTES };
|
|
|
|
void printfmask(ULONG mask, UCHAR acetype, BOOL fdir, ULONG outputoffset)
|
|
{
|
|
ULONG savmask = mask;
|
|
VERBOSER((stderr, "mask = %08lx ", mask))
|
|
DISPLAY_MASK((stderr, "mask = %08lx\n", mask))
|
|
|
|
VERBOSE((stderr, " "))
|
|
|
|
#if DBG
|
|
if (!(Debug & (DEBUG_VERBOSE | DEBUG_DISPLAY_MASK)))
|
|
{
|
|
#endif
|
|
if ((acetype == ACCESS_ALLOWED_ACE_TYPE) &&
|
|
(mask == (FILE_GENERIC_READ | FILE_EXECUTE)))
|
|
{
|
|
printmessage(stdout, MSG_CACLS_READ, NULL);
|
|
} else if ((acetype == ACCESS_ALLOWED_ACE_TYPE) &&
|
|
(mask == (FILE_GENERIC_WRITE | FILE_GENERIC_READ | FILE_EXECUTE | DELETE)))
|
|
{
|
|
printmessage(stdout, MSG_CACLS_CHANGE, NULL);
|
|
} else if ((acetype == ACCESS_ALLOWED_ACE_TYPE) &&
|
|
(mask == (GENERIC_WRITE | GENERIC_READ | GENERIC_EXECUTE | DELETE)))
|
|
{
|
|
printmessage(stdout, MSG_CACLS_CHANGE, NULL);
|
|
} else if ((acetype == ACCESS_ALLOWED_ACE_TYPE) &&
|
|
(mask == ( STANDARD_RIGHTS_ALL |
|
|
FILE_READ_DATA |
|
|
FILE_WRITE_DATA |
|
|
FILE_APPEND_DATA |
|
|
FILE_READ_EA |
|
|
FILE_WRITE_EA |
|
|
FILE_EXECUTE |
|
|
FILE_DELETE_CHILD |
|
|
FILE_READ_ATTRIBUTES |
|
|
FILE_WRITE_ATTRIBUTES )) )
|
|
{
|
|
printmessage(stdout, MSG_CACLS_FULL_CONTROL, NULL);
|
|
} else if ((acetype == ACCESS_ALLOWED_ACE_TYPE) &&
|
|
(mask == GENERIC_ALL))
|
|
{
|
|
printmessage(stdout, MSG_CACLS_FULL_CONTROL, NULL);
|
|
} else if ((acetype == ACCESS_DENIED_ACE_TYPE) &&
|
|
(mask == GENERIC_ALL))
|
|
{
|
|
printmessage(stdout, MSG_CACLS_NONE, NULL);
|
|
} else if ((acetype == ACCESS_DENIED_ACE_TYPE) &&
|
|
(mask == ( STANDARD_RIGHTS_ALL |
|
|
FILE_READ_DATA |
|
|
FILE_WRITE_DATA |
|
|
FILE_APPEND_DATA |
|
|
FILE_READ_EA |
|
|
FILE_WRITE_EA |
|
|
FILE_EXECUTE |
|
|
FILE_DELETE_CHILD |
|
|
FILE_READ_ATTRIBUTES |
|
|
FILE_WRITE_ATTRIBUTES )) )
|
|
{
|
|
printmessage(stdout, MSG_CACLS_NONE, NULL);
|
|
} else
|
|
{
|
|
if (acetype == ACCESS_DENIED_ACE_TYPE)
|
|
printmessage(stdout, MSG_CACLS_DENY, NULL);
|
|
|
|
printmessage(stdout, MSG_CACLS_SPECIAL_ACCESS, NULL);
|
|
|
|
for (int k = 0; k<NUMRIGHTS ; k++ )
|
|
{
|
|
if ((mask & aRights[k]) == aRights[k])
|
|
{
|
|
fprintf(stdout, "%*s%s\n",outputoffset, " ", aRightsStr[k]);
|
|
}
|
|
if (mask == 0)
|
|
break;
|
|
}
|
|
}
|
|
#if DBG
|
|
} else
|
|
{
|
|
if (Debug & (DEBUG_DISPLAY_MASK | DEBUG_VERBOSE))
|
|
{
|
|
printf("\n");
|
|
for (int k = 0; k<NUMRIGHTS ; k++ )
|
|
{
|
|
if ((mask & aRights[k]) == aRights[k])
|
|
{
|
|
if (mask != savmask) printf(" |\n");
|
|
printf(" %s",aRightsStr[k]);
|
|
mask &= ~aRights[k];
|
|
}
|
|
if (mask == 0)
|
|
break;
|
|
}
|
|
}
|
|
VERBOSE((stderr, "=%x",mask))
|
|
if (mask != 0)
|
|
DISPLAY((stderr, "=%x/%x",mask,savmask))
|
|
}
|
|
#endif
|
|
fprintf(stdout, " ");
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Function: printmessage
|
|
//
|
|
// Synopsis: prints a message, either from the local message file, or from the system
|
|
//
|
|
// Arguments: IN [fp] - stderr, stdio, etc.
|
|
// IN [messageID] - variable argument list
|
|
//
|
|
// Returns: length of the output buffer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG
|
|
__cdecl
|
|
printmessage (FILE* fp, DWORD messageID, ...)
|
|
{
|
|
WCHAR messagebuffer[4096];
|
|
va_list ap;
|
|
|
|
va_start(ap, messageID);
|
|
|
|
if (!FormatMessage(FORMAT_MESSAGE_FROM_HMODULE, NULL, messageID, 0,
|
|
messagebuffer, 4095, &ap))
|
|
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, messageID, 0,
|
|
messagebuffer, 4095, &ap);
|
|
|
|
CHAR achOem[2048];
|
|
WideCharToMultiByte(CP_OEMCP,
|
|
0,
|
|
messagebuffer,
|
|
-1,
|
|
achOem,
|
|
sizeof(achOem),
|
|
NULL,
|
|
NULL);
|
|
|
|
fprintf(fp, achOem);
|
|
va_end(ap);
|
|
|
|
return(wcslen(messagebuffer));
|
|
}
|