cacls.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

                            if (!ConvertSidToStringSid(Sid,
                                                       &SidString))
                            {
                                Error = TRUE;
                                break;
                            }
                        }

                        /* print the file name or space */
                        _tprintf(_T("%s "),
                                 FullFileName);

                        /* attempt to map the SID to a user name */
                        if (AceIndex == 0)
                        {
                            DWORD i = 0;

                            /* overwrite the full file name with spaces so we
                               only print the file name once */
                            while (FullFileName[i] != _T('\0'))
                                FullFileName[i++] = _T(' ');
                        }

                        /* print the domain and/or user if possible, or the SID string */
                        if (Name != NULL && Domain[0] != _T('\0'))
                        {
                            _tprintf(_T("%s\\%s:"),
                                     Domain,
                                     Name);
                            IndentAccess = (DWORD)_tcslen(Domain) + _tcslen(Name);
                        }
                        else
                        {
                            LPTSTR DisplayString = (Name != NULL ? Name : SidString);

                            _tprintf(_T("%s:"),
                                     DisplayString);
                            IndentAccess = (DWORD)_tcslen(DisplayString);
                        }

                        /* print the ACE Flags */
                        if (Ace->Header.AceFlags & CONTAINER_INHERIT_ACE)
                        {
                            IndentAccess += LoadAndPrintString(NULL,
                                                               IDS_ABBR_CI);
                        }
                        if (Ace->Header.AceFlags & OBJECT_INHERIT_ACE)
                        {
                            IndentAccess += LoadAndPrintString(NULL,
                                                               IDS_ABBR_OI);
                        }
                        if (Ace->Header.AceFlags & INHERIT_ONLY_ACE)
                        {
                            IndentAccess += LoadAndPrintString(NULL,
                                                               IDS_ABBR_IO);
                        }

                        IndentAccess += 2;

                        /* print the access rights */
                        MapGenericMask(&AccessMask,
                                       &FileGenericMapping);
                        if (Ace->Header.AceType & ACCESS_DENIED_ACE_TYPE)
                        {
                            if (AccessMask == FILE_ALL_ACCESS)
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_ABBR_NONE);
                            }
                            else
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_DENY);
                                goto PrintSpecialAccess;
                            }
                        }
                        else
                        {
                            if (AccessMask == FILE_ALL_ACCESS)
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_ABBR_FULL);
                            }
                            else if (!(Ace->Mask & (GENERIC_READ | GENERIC_EXECUTE)) &&
                                     AccessMask == (FILE_GENERIC_READ | FILE_EXECUTE))
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_ABBR_READ);
                            }
                            else if (AccessMask == (FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_EXECUTE | DELETE))
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_ABBR_CHANGE);
                            }
                            else if (AccessMask == FILE_GENERIC_WRITE)
                            {
                                LoadAndPrintString(NULL,
                                                   IDS_ABBR_WRITE);
                            }
                            else
                            {
                                DWORD x, x2;
                                static const struct
                                {
                                    DWORD Access;
                                    UINT uID;
                                }
                                AccessRights[] =
                                {
                                    {FILE_WRITE_ATTRIBUTES, IDS_FILE_WRITE_ATTRIBUTES},
                                    {FILE_READ_ATTRIBUTES, IDS_FILE_READ_ATTRIBUTES},
                                    {FILE_DELETE_CHILD, IDS_FILE_DELETE_CHILD},
                                    {FILE_EXECUTE, IDS_FILE_EXECUTE},
                                    {FILE_WRITE_EA, IDS_FILE_WRITE_EA},
                                    {FILE_READ_EA, IDS_FILE_READ_EA},
                                    {FILE_APPEND_DATA, IDS_FILE_APPEND_DATA},
                                    {FILE_WRITE_DATA, IDS_FILE_WRITE_DATA},
                                    {FILE_READ_DATA, IDS_FILE_READ_DATA},
                                    {FILE_GENERIC_EXECUTE, IDS_FILE_GENERIC_EXECUTE},
                                    {FILE_GENERIC_WRITE, IDS_FILE_GENERIC_WRITE},
                                    {FILE_GENERIC_READ, IDS_FILE_GENERIC_READ},
                                    {GENERIC_ALL, IDS_GENERIC_ALL},
                                    {GENERIC_EXECUTE, IDS_GENERIC_EXECUTE},
                                    {GENERIC_WRITE, IDS_GENERIC_WRITE},
                                    {GENERIC_READ, IDS_GENERIC_READ},
                                    {MAXIMUM_ALLOWED, IDS_MAXIMUM_ALLOWED},
                                    {ACCESS_SYSTEM_SECURITY, IDS_ACCESS_SYSTEM_SECURITY},
                                    {SPECIFIC_RIGHTS_ALL, IDS_SPECIFIC_RIGHTS_ALL},
                                    {STANDARD_RIGHTS_REQUIRED, IDS_STANDARD_RIGHTS_REQUIRED},
                                    {SYNCHRONIZE, IDS_SYNCHRONIZE},
                                    {WRITE_OWNER, IDS_WRITE_OWNER},
                                    {WRITE_DAC, IDS_WRITE_DAC},
                                    {READ_CONTROL, IDS_READ_CONTROL},
                                    {DELETE, IDS_DELETE},
                                    {STANDARD_RIGHTS_ALL, IDS_STANDARD_RIGHTS_ALL},
                                };

                                LoadAndPrintString(NULL,
                                                   IDS_ALLOW);

PrintSpecialAccess:
                                LoadAndPrintString(NULL,
                                                   IDS_SPECIAL_ACCESS);

                                /* print the special access rights */
                                x = sizeof(AccessRights) / sizeof(AccessRights[0]);
                                while (x-- != 0)
                                {
                                    if ((Ace->Mask & AccessRights[x].Access) == AccessRights[x].Access)
                                    {
                                        _tprintf(_T("\n%s "),
                                                 FullFileName);
                                        for (x2 = 0;
                                             x2 < IndentAccess;
                                             x2++)
                                        {
                                            _tprintf(_T(" "));
                                        }

                                        LoadAndPrintString(NULL,
                                                           AccessRights[x].uID);
                                    }
                                }

                                _tprintf(_T("\n"));
                            }
                        }

                        _tprintf(_T("\n"));

                        /* free up all resources */
                        if (Name != NULL)
                        {
                            HeapFree(GetProcessHeap(),
                                     0,
                                     Name);
                        }

                        if (SidString != NULL)
                        {
                            LocalFree((HLOCAL)SidString);
                        }

                        AceIndex++;
                    }

                    if (!Error)
                        Ret = TRUE;
                }
                else
                {
                    SetLastError(ERROR_NO_SECURITY_ON_OBJECT);
                }
            }
        }

        HeapFree(GetProcessHeap(),
                 0,
                 SecurityDescriptor);
    }
    else
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }

    return Ret;
}


int __cdecl _tmain(int argc, const TCHAR *argv[])
{
    if (argc < 2)
    {
        PrintHelp();
        return 1;
    }
    else
    {
        TCHAR FullPath[MAX_PATH + 1];
        TCHAR *FilePart = NULL;
        WIN32_FIND_DATA FindData;
        HANDLE hFind;
        DWORD LastError;
        BOOL ContinueAccessDenied = FALSE;

        if (argc > 2)
        {
            /* FIXME - parse arguments */
        }

        /* get the full path of where we're searching in */
        if (GetFullPathName(argv[1],
                            sizeof(FullPath) / sizeof(FullPath[0]),
                            FullPath,
                            &FilePart) != 0)
        {
            if (FilePart != NULL)
                *FilePart = _T('\0');
        }
        else
            goto Error;

        /* find the file(s) */
        hFind = FindFirstFile(argv[1],
                              &FindData);
        if (hFind != INVALID_HANDLE_VALUE)
        {
            do
            {
                if (!(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
                    (_tcscmp(FindData.cFileName,
                             _T(".")) &&
                     _tcscmp(FindData.cFileName,
                             _T(".."))))
                {
                    if (argc > 2)
                    {
                        /* FIXME - edit or replace the descriptor */
                    }
                    else
                    {
                        if (!PrintFileDacl(FullPath,
                                           FindData.cFileName))
                        {
                            LastError = GetLastError();

                            if (LastError == ERROR_ACCESS_DENIED &&
                                ContinueAccessDenied)
                            {
                                PrintErrorMessage(LastError);
                            }
                            else
                                break;
                        }
                        else
                            _tprintf(_T("\n"));
                    }
                }
            } while (FindNextFile(hFind,
                                  &FindData));

            FindClose(hFind);

            if (GetLastError() != ERROR_NO_MORE_FILES)
            {
                goto Error;
            }
        }
        else
        {
Error:
            PrintErrorMessage(GetLastError());
            return 1;
        }
    }

    return 0;
}