home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / dcom / dcomperm / aclmgmt.cpp next >
C/C++ Source or Header  |  1997-04-07  |  6KB  |  247 lines
  1. /*++
  2.  
  3. DCOM Permission Configuration Sample
  4. Copyright (c) 1996, Microsoft Corporation. All rights reserved.
  5.  
  6. Module Name:
  7.  
  8.     aclmgmt.cpp
  9.  
  10. Abstract:
  11.  
  12.     Routines to manage access control lists
  13.  
  14. Author:
  15.  
  16.     Michael Nelson
  17.  
  18. Environment:
  19.  
  20.     Windows NT
  21.  
  22. --*/
  23.  
  24. #include <windows.h>
  25. #include <stdio.h>
  26. #include <conio.h>
  27. #include <tchar.h>
  28. #include "ntsecapi.h"
  29. #include "dcomperm.h"
  30.  
  31. DWORD
  32. CopyACL (
  33.     PACL OldACL,
  34.     PACL NewACL
  35.     )
  36. {
  37.     ACL_SIZE_INFORMATION  aclSizeInfo;
  38.     LPVOID                ace;
  39.     ACE_HEADER            *aceHeader;
  40.     ULONG                 i;
  41.  
  42.     GetAclInformation (OldACL, (LPVOID) &aclSizeInfo, (DWORD) sizeof (aclSizeInfo), AclSizeInformation);
  43.  
  44.     //
  45.     // Copy all of the ACEs to the new ACL
  46.     //
  47.  
  48.     for (i = 0; i < aclSizeInfo.AceCount; i++)
  49.     {
  50.         //
  51.         // Get the ACE and header info
  52.         //
  53.  
  54.         if (!GetAce (OldACL, i, &ace))
  55.             return GetLastError();
  56.  
  57.         aceHeader = (ACE_HEADER *) ace;
  58.  
  59.         //
  60.         // Add the ACE to the new list
  61.         //
  62.  
  63.         if (!AddAce (NewACL, ACL_REVISION, 0xffffffff, ace, aceHeader->AceSize))
  64.             return GetLastError();
  65.     }
  66.  
  67.     return ERROR_SUCCESS;
  68. }
  69.  
  70. DWORD
  71. AddAccessDeniedACEToACL (
  72.     PACL *Acl,
  73.     DWORD PermissionMask,
  74.     LPTSTR Principal
  75.     )
  76. {
  77.     ACL_SIZE_INFORMATION  aclSizeInfo;
  78.     int                   aclSize;
  79.     DWORD                 returnValue;
  80.     PSID                  principalSID;
  81.     PACL                  oldACL, newACL;
  82.  
  83.     oldACL = *Acl;
  84.  
  85.     returnValue = GetPrincipalSID (Principal, &principalSID);
  86.     if (returnValue != ERROR_SUCCESS)
  87.         return returnValue;
  88.  
  89.     GetAclInformation (oldACL, (LPVOID) &aclSizeInfo, (DWORD) sizeof (ACL_SIZE_INFORMATION), AclSizeInformation);
  90.  
  91.     aclSize = aclSizeInfo.AclBytesInUse +
  92.               sizeof (ACL) + sizeof (ACCESS_DENIED_ACE) +
  93.               GetLengthSid (principalSID) - sizeof (DWORD);
  94.  
  95.     newACL = (PACL) new BYTE [aclSize];
  96.  
  97.     if (!InitializeAcl (newACL, aclSize, ACL_REVISION))
  98.     {
  99.         free (principalSID);
  100.         return GetLastError();
  101.     }
  102.  
  103.     if (!AddAccessDeniedAce (newACL, ACL_REVISION2, PermissionMask, principalSID))
  104.     {
  105.         free (principalSID);
  106.         return GetLastError();
  107.     }
  108.  
  109.     returnValue = CopyACL (oldACL, newACL);
  110.     if (returnValue != ERROR_SUCCESS)
  111.     {
  112.         free (principalSID);
  113.         return returnValue;
  114.     }
  115.  
  116.     *Acl = newACL;
  117.  
  118.     free (principalSID);
  119.     return ERROR_SUCCESS;
  120. }
  121.  
  122. DWORD
  123. AddAccessAllowedACEToACL (
  124.     PACL *Acl,
  125.     DWORD PermissionMask,
  126.     LPTSTR Principal
  127.     )
  128. {
  129.     ACL_SIZE_INFORMATION  aclSizeInfo;
  130.     int                   aclSize;
  131.     DWORD                 returnValue;
  132.     PSID                  principalSID;
  133.     PACL                  oldACL, newACL;
  134.  
  135.     oldACL = *Acl;
  136.  
  137.     returnValue = GetPrincipalSID (Principal, &principalSID);
  138.     if (returnValue != ERROR_SUCCESS)
  139.         return returnValue;
  140.  
  141.     GetAclInformation (oldACL, (LPVOID) &aclSizeInfo, (DWORD) sizeof (ACL_SIZE_INFORMATION), AclSizeInformation);
  142.  
  143.     aclSize = aclSizeInfo.AclBytesInUse +
  144.               sizeof (ACL) + sizeof (ACCESS_ALLOWED_ACE) +
  145.               GetLengthSid (principalSID) - sizeof (DWORD);
  146.  
  147.     newACL = (PACL) new BYTE [aclSize];
  148.  
  149.     if (!InitializeAcl (newACL, aclSize, ACL_REVISION))
  150.     {
  151.         free (principalSID);
  152.         return GetLastError();
  153.     }
  154.  
  155.     returnValue = CopyACL (oldACL, newACL);
  156.     if (returnValue != ERROR_SUCCESS)
  157.     {
  158.         free (principalSID);
  159.         return returnValue;
  160.     }
  161.  
  162.     if (!AddAccessAllowedAce (newACL, ACL_REVISION2, PermissionMask, principalSID))
  163.     {
  164.         free (principalSID);
  165.         return GetLastError();
  166.     }
  167.  
  168.     *Acl = newACL;
  169.  
  170.     free (principalSID);
  171.     return ERROR_SUCCESS;
  172. }
  173.  
  174. DWORD
  175. RemovePrincipalFromACL (
  176.     PACL Acl,
  177.     LPTSTR Principal
  178.     )
  179. {
  180.     ACL_SIZE_INFORMATION    aclSizeInfo;
  181.     ULONG                   i;
  182.     LPVOID                  ace;
  183.     ACCESS_ALLOWED_ACE      *accessAllowedAce;
  184.     ACCESS_DENIED_ACE       *accessDeniedAce;
  185.     SYSTEM_AUDIT_ACE        *systemAuditAce;
  186.     PSID                    principalSID;
  187.     DWORD                   returnValue;
  188.     ACE_HEADER              *aceHeader;
  189.  
  190.     returnValue = GetPrincipalSID (Principal, &principalSID);
  191.     if (returnValue != ERROR_SUCCESS)
  192.         return returnValue;
  193.  
  194.     GetAclInformation (Acl, (LPVOID) &aclSizeInfo, (DWORD) sizeof (ACL_SIZE_INFORMATION), AclSizeInformation);
  195.  
  196.     for (i = 0; i < aclSizeInfo.AceCount; i++)
  197.     {
  198.         if (!GetAce (Acl, i, &ace))
  199.         {
  200.             free (principalSID);
  201.             return GetLastError();
  202.         }
  203.  
  204.         aceHeader = (ACE_HEADER *) ace;
  205.  
  206.         if (aceHeader->AceType == ACCESS_ALLOWED_ACE_TYPE)
  207.         {
  208.             accessAllowedAce = (ACCESS_ALLOWED_ACE *) ace;
  209.  
  210.             if (EqualSid (principalSID, (PSID) &accessAllowedAce->SidStart))
  211.             {
  212.                 DeleteAce (Acl, i);
  213.                 free (principalSID);
  214.                 return ERROR_SUCCESS;
  215.             }
  216.         } else
  217.  
  218.         if (aceHeader->AceType == ACCESS_DENIED_ACE_TYPE)
  219.         {
  220.             accessDeniedAce = (ACCESS_DENIED_ACE *) ace;
  221.  
  222.             if (EqualSid (principalSID, (PSID) &accessDeniedAce->SidStart))
  223.             {
  224.                 DeleteAce (Acl, i);
  225.                 free (principalSID);
  226.                 return ERROR_SUCCESS;
  227.             }
  228.         } else
  229.  
  230.         if (aceHeader->AceType == SYSTEM_AUDIT_ACE_TYPE)
  231.         {
  232.             systemAuditAce = (SYSTEM_AUDIT_ACE *) ace;
  233.  
  234.             if (EqualSid (principalSID, (PSID) &systemAuditAce->SidStart))
  235.             {
  236.                 DeleteAce (Acl, i);
  237.                 free (principalSID);
  238.                 return ERROR_SUCCESS;
  239.             }
  240.         }
  241.     }
  242.  
  243.     free (principalSID);
  244.     return ERROR_SUCCESS;
  245. }
  246.  
  247.