lib/advapi32/sec/ac.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/advapi32/sec/ac.c
   6  * PURPOSE:         ACL/ACE functions
   7  */
   8
   9 #define NTOS_MODE_USER
  10 #include <ntos.h>
  11 #include <windows.h>
  12
  13
  14 /* --- ACL --- */
  15
  16 /*
  17  * @implemented
  18  */
  19 WINBOOL
  20 STDCALL
  21 GetAclInformation (
  22         PACL                    pAcl,
  23         LPVOID                  pAclInformation,
  24         DWORD                   nAclInformationLength,
  25         ACL_INFORMATION_CLASS   dwAclInformationClass
  26         )
  27 {
  28         NTSTATUS Status;
  29
  30         Status = RtlQueryInformationAcl (pAcl,
  31                                          pAclInformation,
  32                                          nAclInformationLength,
  33                                          dwAclInformationClass);
  34         if (!NT_SUCCESS(Status))
  35         {
  36                 SetLastError (RtlNtStatusToDosError (Status));
  37                 return FALSE;
  38         }
  39
  40         return TRUE;
  41 }
  42
  43
  44 #if 0
  45 DWORD
  46 WINAPI
  47 GetAuditedPermissionsFromAclA (
  48         IN      PACL            pacl,
  49         IN      PTRUSTEE_A      pTrustee,
  50         OUT     PACCESS_MASK    pSuccessfulAuditedRights,
  51         OUT     PACCESS_MASK    pFailedAuditRights
  52         )
  53 {
  54         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  55         return 0;
  56 }
  57
  58
  59 DWORD
  60 WINAPI
  61 GetAuditedPermissionsFromAclW (
  62         IN      PACL            pacl,
  63         IN      PTRUSTEE_W      pTrustee,
  64         OUT     PACCESS_MASK    pSuccessfulAuditedRights,
  65         OUT     PACCESS_MASK    pFailedAuditRights
  66         )
  67 {
  68         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  69         return 0;
  70 }
  71
  72
  73 DWORD
  74 WINAPI
  75 GetEffectiveRightsFromAclA (
  76         IN      PACL            pacl,
  77         IN      PTRUSTEE_A      pTrustee,
  78         OUT     PACCESS_MASK    pAccessRights
  79         )
  80 {
  81         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  82         return 0;
  83 }
  84
  85
  86 DWORD
  87 WINAPI
  88 GetEffectiveRightsFromAclW (
  89         IN      PACL            pacl,
  90         IN      PTRUSTEE_W      pTrustee,
  91         OUT     PACCESS_MASK    pAccessRights
  92         )
  93 {
  94         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  95         return 0;
  96 }
  97
  98
  99 DWORD
 100 WINAPI
 101 GetExplicitEntriesFromAclA (
 102         IN      PACL                    pacl,
 103         OUT     PULONG                  pcCountOfExplicitEntries,
 104         OUT     PEXPLICIT_ACCESS_A      * pListOfExplicitEntries
 105         )
 106 {
 107         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 108         return 0;
 109 }
 110
 111
 112 DWORD
 113 WINAPI
 114 GetExplicitEntriesFromAclW (
 115         IN      PACL                    pacl,
 116         OUT     PULONG                  pcCountOfExplicitEntries,
 117         OUT     PEXPLICIT_ACCESS_W      * pListOfExplicitEntries
 118         )
 119 {
 120         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 121         return 0;
 122 }
 123 #endif
 124
 125
 126 /*
 127  * @implemented
 128  */
 129 WINBOOL
 130 STDCALL
 131 InitializeAcl (
 132         PACL    pAcl,
 133         DWORD   nAclLength,
 134         DWORD   dwAclRevision
 135         )
 136 {
 137         NTSTATUS Status;
 138
 139         Status = RtlCreateAcl (pAcl,
 140                                nAclLength,
 141                                dwAclRevision);
 142         if (!NT_SUCCESS(Status))
 143         {
 144                 SetLastError (RtlNtStatusToDosError (Status));
 145                 return FALSE;
 146         }
 147
 148         return TRUE;
 149 }
 150
 151
 152 /*
 153  * @implemented
 154  */
 155 WINBOOL
 156 STDCALL
 157 IsValidAcl (
 158         PACL    pAcl
 159         )
 160 {
 161         return RtlValidAcl (pAcl);
 162 }
 163
 164
 165 /*
 166  * @implemented
 167  */
 168 WINBOOL
 169 STDCALL
 170 SetAclInformation (
 171         PACL                    pAcl,
 172         LPVOID                  pAclInformation,
 173         DWORD                   nAclInformationLength,
 174         ACL_INFORMATION_CLASS   dwAclInformationClass
 175         )
 176 {
 177         NTSTATUS Status;
 178
 179         Status = RtlSetInformationAcl (pAcl,
 180                                        pAclInformation,
 181                                        nAclInformationLength,
 182                                        dwAclInformationClass);
 183         if (!NT_SUCCESS(Status))
 184         {
 185                 SetLastError (RtlNtStatusToDosError (Status));
 186                 return FALSE;
 187         }
 188
 189         return TRUE;
 190 }
 191
 192
 193 #if 0
 194 DWORD
 195 WINAPI
 196 SetEntriesInAclA (
 197         IN      ULONG                   cCountOfExplicitEntries,
 198         IN      PEXPLICIT_ACCESS_A      pListOfExplicitEntries,
 199         IN      PACL                    OldAcl,
 200         OUT     PACL                    * NewAcl
 201         )
 202 {
 203         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 204         return 0;
 205 }
 206
 207
 208 DWORD
 209 WINAPI
 210 SetEntriesInAclW (
 211         IN      ULONG                   cCountOfExplicitEntries,
 212         IN      PEXPLICIT_ACCESS_W      pListOfExplicitEntries,
 213         IN      PACL                    OldAcl,
 214         OUT     PACL                    * NewAcl
 215         )
 216 {
 217         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 218         return 0;
 219 }
 220 #endif
 221
 222
 223
 224 /* --- ACE --- */
 225
 226 /*
 227  * @implemented
 228  */
 229 WINBOOL
 230 STDCALL
 231 AddAccessAllowedAce (
 232         PACL    pAcl,
 233         DWORD   dwAceRevision,
 234         DWORD   AccessMask,
 235         PSID    pSid
 236         )
 237 {
 238         NTSTATUS Status;
 239
 240         Status = RtlAddAccessAllowedAce (pAcl,
 241                                          dwAceRevision,
 242                                          AccessMask,
 243                                          pSid);
 244         if (!NT_SUCCESS(Status))
 245         {
 246                 SetLastError (RtlNtStatusToDosError (Status));
 247                 return FALSE;
 248         }
 249
 250         return TRUE;
 251 }
 252
 253
 254 /*
 255  * @implemented
 256  */
 257 WINBOOL
 258 STDCALL
 259 AddAccessDeniedAce (
 260         PACL    pAcl,
 261         DWORD   dwAceRevision,
 262         DWORD   AccessMask,
 263         PSID    pSid
 264         )
 265 {
 266         NTSTATUS Status;
 267
 268         Status = RtlAddAccessDeniedAce (pAcl,
 269                                         dwAceRevision,
 270                                         AccessMask,
 271                                         pSid);
 272         if (!NT_SUCCESS(Status))
 273         {
 274                 SetLastError (RtlNtStatusToDosError (Status));
 275                 return FALSE;
 276         }
 277
 278         return TRUE;
 279 }
 280
 281
 282 /*
 283  * @implemented
 284  */
 285 WINBOOL
 286 STDCALL
 287 AddAce (
 288         PACL    pAcl,
 289         DWORD   dwAceRevision,
 290         DWORD   dwStartingAceIndex,
 291         LPVOID  pAceList,
 292         DWORD   nAceListLength
 293         )
 294 {
 295         NTSTATUS Status;
 296
 297         Status = RtlAddAce (pAcl,
 298                             dwAceRevision,
 299                             dwStartingAceIndex,
 300                             pAceList,
 301                             nAceListLength);
 302         if (!NT_SUCCESS(Status))
 303         {
 304                 SetLastError (RtlNtStatusToDosError (Status));
 305                 return FALSE;
 306         }
 307
 308         return TRUE;
 309 }
 310
 311
 312 /*
 313  * @implemented
 314  */
 315 WINBOOL
 316 STDCALL
 317 AddAuditAccessAce (
 318         PACL    pAcl,
 319         DWORD   dwAceRevision,
 320         DWORD   dwAccessMask,
 321         PSID    pSid,
 322         WINBOOL bAuditSuccess,
 323         WINBOOL bAuditFailure
 324         )
 325 {
 326         NTSTATUS Status;
 327
 328         Status = RtlAddAuditAccessAce (pAcl,
 329                                        dwAceRevision,
 330                                        dwAccessMask,
 331                                        pSid,
 332                                        bAuditSuccess,
 333                                        bAuditFailure);
 334         if (!NT_SUCCESS(Status))
 335         {
 336                 SetLastError (RtlNtStatusToDosError (Status));
 337                 return FALSE;
 338         }
 339
 340         return TRUE;
 341 }
 342
 343
 344 /*
 345  * @implemented
 346  */
 347 WINBOOL
 348 STDCALL
 349 DeleteAce (
 350         PACL    pAcl,
 351         DWORD   dwAceIndex
 352         )
 353 {
 354         NTSTATUS Status;
 355
 356         Status = RtlDeleteAce (pAcl,
 357                                dwAceIndex);
 358         if (!NT_SUCCESS(Status))
 359         {
 360                 SetLastError (RtlNtStatusToDosError (Status));
 361                 return FALSE;
 362         }
 363
 364         return TRUE;
 365 }
 366
 367
 368 /*
 369  * @implemented
 370  */
 371 WINBOOL
 372 STDCALL
 373 FindFirstFreeAce (
 374         PACL    pAcl,
 375         LPVOID  * pAce
 376         )
 377 {
 378         return RtlFirstFreeAce (pAcl,
 379                                 (PACE*)pAce);
 380 }
 381
 382
 383 /*
 384  * @implemented
 385  */
 386 WINBOOL
 387 STDCALL
 388 GetAce (
 389         PACL    pAcl,
 390         DWORD   dwAceIndex,
 391         LPVOID  * pAce
 392         )
 393 {
 394         NTSTATUS Status;
 395
 396         Status = RtlGetAce (pAcl,
 397                             dwAceIndex,
 398                             (PACE*)pAce);
 399         if (!NT_SUCCESS(Status))
 400         {
 401                 SetLastError (RtlNtStatusToDosError (Status));
 402                 return FALSE;
 403         }
 404
 405         return TRUE;
 406 }
 407
 408 /* EOF */