reactos/dll/win32/advapi32/sec/audit.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/advapi32/sec/audit.c
   6  * PURPOSE:         Audit functions
   7  * PROGRAMMER:      Eric Kohl
   8  * UPDATE HISTORY:
   9  *                  Created 07/19/2003
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <advapi32.h>
  15 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  16
  17 /* FUNCTIONS ****************************************************************/
  18
  19 /*
  20  * @implemented
  21  */
  22 BOOL WINAPI
  23 AccessCheckAndAuditAlarmA(LPCSTR SubsystemName,
  24                           LPVOID HandleId,
  25                           LPSTR ObjectTypeName,
  26                           LPSTR ObjectName,
  27                           PSECURITY_DESCRIPTOR SecurityDescriptor,
  28                           DWORD DesiredAccess,
  29                           PGENERIC_MAPPING GenericMapping,
  30                           BOOL ObjectCreation,
  31                           LPDWORD GrantedAccess,
  32                           LPBOOL AccessStatus,
  33                           LPBOOL pfGenerateOnClose)
  34 {
  35     UNICODE_STRING SubsystemNameU;
  36     UNICODE_STRING ObjectTypeNameU;
  37     UNICODE_STRING ObjectNameU;
  38     NTSTATUS LocalAccessStatus;
  39     BOOLEAN GenerateOnClose;
  40     NTSTATUS Status;
  41
  42     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
  43                                      (PCHAR)SubsystemName);
  44     RtlCreateUnicodeStringFromAsciiz(&ObjectTypeNameU,
  45                                      (PCHAR)ObjectTypeName);
  46     RtlCreateUnicodeStringFromAsciiz(&ObjectNameU,
  47                                      (PCHAR)ObjectName);
  48
  49     Status = NtAccessCheckAndAuditAlarm(&SubsystemNameU,
  50                                         HandleId,
  51                                         &ObjectTypeNameU,
  52                                         &ObjectNameU,
  53                                         SecurityDescriptor,
  54                                         DesiredAccess,
  55                                         GenericMapping,
  56                                         ObjectCreation,
  57                                         GrantedAccess,
  58                                         &LocalAccessStatus,
  59                                         &GenerateOnClose);
  60     RtlFreeUnicodeString(&SubsystemNameU);
  61     RtlFreeUnicodeString(&ObjectTypeNameU);
  62     RtlFreeUnicodeString(&ObjectNameU);
  63
  64     *pfGenerateOnClose = (BOOL)GenerateOnClose;
  65
  66     if (!NT_SUCCESS(Status))
  67     {
  68         SetLastError(RtlNtStatusToDosError(Status));
  69         return FALSE;
  70     }
  71
  72     if (!NT_SUCCESS (LocalAccessStatus))
  73     {
  74         *AccessStatus = FALSE;
  75         SetLastError(RtlNtStatusToDosError(Status));
  76         return FALSE;
  77     }
  78
  79     *AccessStatus = TRUE;
  80
  81     return TRUE;
  82 }
  83
  84
  85 /*
  86  * @implemented
  87  */
  88 BOOL WINAPI
  89 AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName,
  90                           LPVOID HandleId,
  91                           LPWSTR ObjectTypeName,
  92                           LPWSTR ObjectName,
  93                           PSECURITY_DESCRIPTOR SecurityDescriptor,
  94                           DWORD DesiredAccess,
  95                           PGENERIC_MAPPING GenericMapping,
  96                           BOOL ObjectCreation,
  97                           LPDWORD GrantedAccess,
  98                           LPBOOL AccessStatus,
  99                           LPBOOL pfGenerateOnClose)
 100 {
 101     UNICODE_STRING SubsystemNameU;
 102     UNICODE_STRING ObjectTypeNameU;
 103     UNICODE_STRING ObjectNameU;
 104     NTSTATUS LocalAccessStatus;
 105     BOOLEAN GenerateOnClose;
 106     NTSTATUS Status;
 107
 108     RtlInitUnicodeString(&SubsystemNameU,
 109                          (PWSTR)SubsystemName);
 110     RtlInitUnicodeString(&ObjectTypeNameU,
 111                          (PWSTR)ObjectTypeName);
 112     RtlInitUnicodeString(&ObjectNameU,
 113                          (PWSTR)ObjectName);
 114
 115     Status = NtAccessCheckAndAuditAlarm(&SubsystemNameU,
 116                                         HandleId,
 117                                         &ObjectTypeNameU,
 118                                         &ObjectNameU,
 119                                         SecurityDescriptor,
 120                                         DesiredAccess,
 121                                         GenericMapping,
 122                                         ObjectCreation,
 123                                         GrantedAccess,
 124                                         &LocalAccessStatus,
 125                                         &GenerateOnClose);
 126
 127     *pfGenerateOnClose = (BOOL)GenerateOnClose;
 128
 129     if (!NT_SUCCESS(Status))
 130     {
 131         SetLastError(RtlNtStatusToDosError(Status));
 132         return FALSE;
 133     }
 134
 135     if (!NT_SUCCESS(LocalAccessStatus))
 136     {
 137         *AccessStatus = FALSE;
 138         SetLastError(RtlNtStatusToDosError(Status));
 139         return FALSE;
 140     }
 141
 142     *AccessStatus = TRUE;
 143
 144     return TRUE;
 145 }
 146
 147
 148 /*
 149  * @implemented
 150  */
 151 BOOL WINAPI
 152 ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
 153                        LPVOID HandleId,
 154                        BOOL GenerateOnClose)
 155 {
 156     UNICODE_STRING Name;
 157     NTSTATUS Status;
 158
 159     if (!RtlCreateUnicodeStringFromAsciiz(&Name, SubsystemName))
 160     {
 161         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 162         return FALSE;
 163     }
 164
 165     Status = NtCloseObjectAuditAlarm(&Name,
 166                                      HandleId,
 167                                      GenerateOnClose);
 168     RtlFreeUnicodeString(&Name);
 169     if (!NT_SUCCESS (Status))
 170     {
 171         SetLastError(RtlNtStatusToDosError(Status));
 172         return FALSE;
 173     }
 174
 175     return TRUE;
 176 }
 177
 178
 179 /*
 180  * @implemented
 181  */
 182 BOOL WINAPI
 183 ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
 184                        LPVOID HandleId,
 185                        BOOL GenerateOnClose)
 186 {
 187     UNICODE_STRING Name;
 188     NTSTATUS Status;
 189
 190     RtlInitUnicodeString(&Name,
 191                          (PWSTR)SubsystemName);
 192
 193     Status = NtCloseObjectAuditAlarm(&Name,
 194                                      HandleId,
 195                                      GenerateOnClose);
 196     if (!NT_SUCCESS(Status))
 197     {
 198         SetLastError(RtlNtStatusToDosError(Status));
 199         return FALSE;
 200     }
 201
 202     return TRUE;
 203 }
 204
 205
 206 /*
 207  * @implemented
 208  */
 209 BOOL WINAPI
 210 ObjectDeleteAuditAlarmA(LPCSTR SubsystemName,
 211                         LPVOID HandleId,
 212                         BOOL GenerateOnClose)
 213 {
 214     UNICODE_STRING Name;
 215     NTSTATUS Status;
 216
 217     if (!RtlCreateUnicodeStringFromAsciiz(&Name, SubsystemName))
 218     {
 219         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 220         return FALSE;
 221     }
 222
 223     Status = NtDeleteObjectAuditAlarm(&Name,
 224                                       HandleId,
 225                                       GenerateOnClose);
 226     RtlFreeUnicodeString(&Name);
 227     if (!NT_SUCCESS(Status))
 228     {
 229         SetLastError(RtlNtStatusToDosError(Status));
 230         return FALSE;
 231     }
 232
 233     return TRUE;
 234 }
 235
 236
 237 /*
 238  * @implemented
 239  */
 240 BOOL WINAPI
 241 ObjectDeleteAuditAlarmW(LPCWSTR SubsystemName,
 242                         LPVOID HandleId,
 243                         BOOL GenerateOnClose)
 244 {
 245     UNICODE_STRING Name;
 246     NTSTATUS Status;
 247
 248     RtlInitUnicodeString(&Name,
 249                          (PWSTR)SubsystemName);
 250
 251     Status = NtDeleteObjectAuditAlarm(&Name,
 252                                       HandleId,
 253                                       GenerateOnClose);
 254     if (!NT_SUCCESS(Status))
 255     {
 256         SetLastError(RtlNtStatusToDosError(Status));
 257         return FALSE;
 258     }
 259
 260     return TRUE;
 261 }
 262
 263
 264 /*
 265  * @implemented
 266  */
 267 BOOL WINAPI
 268 ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
 269                       LPVOID HandleId,
 270                       LPSTR ObjectTypeName,
 271                       LPSTR ObjectName,
 272                       PSECURITY_DESCRIPTOR pSecurityDescriptor,
 273                       HANDLE ClientToken,
 274                       DWORD DesiredAccess,
 275                       DWORD GrantedAccess,
 276                       PPRIVILEGE_SET Privileges,
 277                       BOOL ObjectCreation,
 278                       BOOL AccessGranted,
 279                       LPBOOL GenerateOnClose)
 280 {
 281     UNICODE_STRING SubsystemNameU;
 282     UNICODE_STRING ObjectTypeNameU;
 283     UNICODE_STRING ObjectNameU;
 284     NTSTATUS Status;
 285
 286     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 287                                      (PCHAR)SubsystemName);
 288     RtlCreateUnicodeStringFromAsciiz(&ObjectTypeNameU,
 289                                      (PCHAR)ObjectTypeName);
 290     RtlCreateUnicodeStringFromAsciiz(&ObjectNameU,
 291                                      (PCHAR)ObjectName);
 292
 293     Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
 294                                     HandleId,
 295                                     &ObjectTypeNameU,
 296                                     &ObjectNameU,
 297                                     pSecurityDescriptor,
 298                                     ClientToken,
 299                                     DesiredAccess,
 300                                     GrantedAccess,
 301                                     Privileges,
 302                                     ObjectCreation,
 303                                     AccessGranted,
 304                                     (PBOOLEAN)GenerateOnClose);
 305     RtlFreeUnicodeString(&SubsystemNameU);
 306     RtlFreeUnicodeString(&ObjectTypeNameU);
 307     RtlFreeUnicodeString(&ObjectNameU);
 308     if (!NT_SUCCESS(Status))
 309     {
 310         SetLastError(RtlNtStatusToDosError(Status));
 311         return FALSE;
 312     }
 313
 314     return TRUE;
 315 }
 316
 317
 318 /*
 319  * @implemented
 320  */
 321 BOOL WINAPI
 322 ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
 323                       LPVOID HandleId,
 324                       LPWSTR ObjectTypeName,
 325                       LPWSTR ObjectName,
 326                       PSECURITY_DESCRIPTOR pSecurityDescriptor,
 327                       HANDLE ClientToken,
 328                       DWORD DesiredAccess,
 329                       DWORD GrantedAccess,
 330                       PPRIVILEGE_SET Privileges,
 331                       BOOL ObjectCreation,
 332                       BOOL AccessGranted,
 333                       LPBOOL GenerateOnClose)
 334 {
 335     UNICODE_STRING SubsystemNameU;
 336     UNICODE_STRING ObjectTypeNameU;
 337     UNICODE_STRING ObjectNameU;
 338     NTSTATUS Status;
 339
 340     RtlInitUnicodeString(&SubsystemNameU,
 341                          (PWSTR)SubsystemName);
 342     RtlInitUnicodeString(&ObjectTypeNameU,
 343                          (PWSTR)ObjectTypeName);
 344     RtlInitUnicodeString(&ObjectNameU,
 345                          (PWSTR)ObjectName);
 346
 347     Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
 348                                     HandleId,
 349                                     &ObjectTypeNameU,
 350                                     &ObjectNameU,
 351                                     pSecurityDescriptor,
 352                                     ClientToken,
 353                                     DesiredAccess,
 354                                     GrantedAccess,
 355                                     Privileges,
 356                                     ObjectCreation,
 357                                     AccessGranted,
 358                                     (PBOOLEAN)GenerateOnClose);
 359     if (!NT_SUCCESS(Status))
 360     {
 361         SetLastError(RtlNtStatusToDosError(Status));
 362         return FALSE;
 363     }
 364
 365     return TRUE;
 366 }
 367
 368
 369 /*
 370  * @implemented
 371  */
 372 BOOL WINAPI
 373 ObjectPrivilegeAuditAlarmA(LPCSTR SubsystemName,
 374                            LPVOID HandleId,
 375                            HANDLE ClientToken,
 376                            DWORD DesiredAccess,
 377                            PPRIVILEGE_SET Privileges,
 378                            BOOL AccessGranted)
 379 {
 380     UNICODE_STRING SubsystemNameU;
 381     NTSTATUS Status;
 382
 383     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 384                                      (PCHAR)SubsystemName);
 385
 386     Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
 387                                          HandleId,
 388                                          ClientToken,
 389                                          DesiredAccess,
 390                                          Privileges,
 391                                          AccessGranted);
 392     RtlFreeUnicodeString (&SubsystemNameU);
 393     if (!NT_SUCCESS(Status))
 394     {
 395         SetLastError(RtlNtStatusToDosError(Status));
 396         return FALSE;
 397     }
 398
 399     return TRUE;
 400 }
 401
 402
 403 /*
 404  * @implemented
 405  */
 406 BOOL WINAPI
 407 ObjectPrivilegeAuditAlarmW(LPCWSTR SubsystemName,
 408                            LPVOID HandleId,
 409                            HANDLE ClientToken,
 410                            DWORD DesiredAccess,
 411                            PPRIVILEGE_SET Privileges,
 412                            BOOL AccessGranted)
 413 {
 414     UNICODE_STRING SubsystemNameU;
 415     NTSTATUS Status;
 416
 417     RtlInitUnicodeString(&SubsystemNameU,
 418                          (PWSTR)SubsystemName);
 419
 420     Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
 421                                          HandleId,
 422                                          ClientToken,
 423                                          DesiredAccess,
 424                                          Privileges,
 425                                          AccessGranted);
 426     if (!NT_SUCCESS(Status))
 427     {
 428         SetLastError(RtlNtStatusToDosError(Status));
 429         return FALSE;
 430     }
 431
 432     return TRUE;
 433 }
 434
 435
 436 /*
 437  * @implemented
 438  */
 439 BOOL WINAPI
 440 PrivilegedServiceAuditAlarmA(LPCSTR SubsystemName,
 441                              LPCSTR ServiceName,
 442                              HANDLE ClientToken,
 443                              PPRIVILEGE_SET Privileges,
 444                              BOOL AccessGranted)
 445 {
 446     UNICODE_STRING SubsystemNameU;
 447     UNICODE_STRING ServiceNameU;
 448     NTSTATUS Status;
 449
 450     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 451                                      (PCHAR)SubsystemName);
 452     RtlCreateUnicodeStringFromAsciiz(&ServiceNameU,
 453                                      (PCHAR)ServiceName);
 454
 455     Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
 456                                            &ServiceNameU,
 457                                            ClientToken,
 458                                            Privileges,
 459                                            AccessGranted);
 460     RtlFreeUnicodeString(&SubsystemNameU);
 461     RtlFreeUnicodeString(&ServiceNameU);
 462     if (!NT_SUCCESS(Status))
 463     {
 464         SetLastError(RtlNtStatusToDosError(Status));
 465         return FALSE;
 466     }
 467
 468     return TRUE;
 469 }
 470
 471
 472 /*
 473  * @implemented
 474  */
 475 BOOL WINAPI
 476 PrivilegedServiceAuditAlarmW(LPCWSTR SubsystemName,
 477                              LPCWSTR ServiceName,
 478                              HANDLE ClientToken,
 479                              PPRIVILEGE_SET Privileges,
 480                              BOOL AccessGranted)
 481 {
 482     UNICODE_STRING SubsystemNameU;
 483     UNICODE_STRING ServiceNameU;
 484     NTSTATUS Status;
 485
 486     RtlInitUnicodeString(&SubsystemNameU,
 487                          (PWSTR)SubsystemName);
 488     RtlInitUnicodeString(&ServiceNameU,
 489                          (PWSTR)ServiceName);
 490
 491     Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
 492                                            &ServiceNameU,
 493                                            ClientToken,
 494                                            Privileges,
 495                                            AccessGranted);
 496     if (!NT_SUCCESS(Status))
 497     {
 498         SetLastError(RtlNtStatusToDosError(Status));
 499         return FALSE;
 500     }
 501
 502     return TRUE;
 503 }
 504
 505
 506 /*
 507  * @unimplemented
 508  */
 509 BOOL WINAPI
 510 AccessCheckByTypeResultListAndAuditAlarmByHandleW(IN LPCWSTR SubsystemName,
 511                                                   IN LPVOID HandleId,
 512                                                   IN HANDLE ClientToken,
 513                                                   IN LPCWSTR ObjectTypeName,
 514                                                   IN LPCWSTR ObjectName,
 515                                                   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 516                                                   IN PSID PrincipalSelfSid,
 517                                                   IN DWORD DesiredAccess,
 518                                                   IN AUDIT_EVENT_TYPE AuditType,
 519                                                   IN DWORD Flags,
 520                                                   IN POBJECT_TYPE_LIST ObjectTypeList,
 521                                                   IN DWORD ObjectTypeListLength,
 522                                                   IN PGENERIC_MAPPING GenericMapping,
 523                                                   IN BOOL ObjectCreation,
 524                                                   OUT LPDWORD GrantedAccess,
 525                                                   OUT LPDWORD AccessStatusList,
 526                                                   OUT LPBOOL pfGenerateOnClose)
 527 {
 528     FIXME("%s() not implemented!\n", __FUNCTION__);
 529     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 530     return FALSE;
 531 }
 532
 533
 534 /*
 535  * @unimplemented
 536  */
 537 BOOL WINAPI
 538 AccessCheckByTypeResultListAndAuditAlarmByHandleA(IN LPCSTR SubsystemName,
 539                                                   IN LPVOID HandleId,
 540                                                   IN HANDLE ClientToken,
 541                                                   IN LPCSTR ObjectTypeName,
 542                                                   IN LPCSTR ObjectName,
 543                                                   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 544                                                   IN PSID PrincipalSelfSid,
 545                                                   IN DWORD DesiredAccess,
 546                                                   IN AUDIT_EVENT_TYPE AuditType,
 547                                                   IN DWORD Flags,
 548                                                   IN POBJECT_TYPE_LIST ObjectTypeList,
 549                                                   IN DWORD ObjectTypeListLength,
 550                                                   IN PGENERIC_MAPPING GenericMapping,
 551                                                   IN BOOL ObjectCreation,
 552                                                   OUT LPDWORD GrantedAccess,
 553                                                   OUT LPDWORD AccessStatusList,
 554                                                   OUT LPBOOL pfGenerateOnClose)
 555 {
 556     FIXME("%s() not implemented!\n", __FUNCTION__);
 557     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 558     return FALSE;
 559 }
 560
 561
 562 /*
 563  * @unimplemented
 564  */
 565 BOOL WINAPI
 566 AccessCheckByTypeResultListAndAuditAlarmW(IN LPCWSTR SubsystemName,
 567                                           IN LPVOID HandleId,
 568                                           IN LPCWSTR ObjectTypeName,
 569                                           IN LPCWSTR ObjectName,
 570                                           IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 571                                           IN PSID PrincipalSelfSid,
 572                                           IN DWORD DesiredAccess,
 573                                           IN AUDIT_EVENT_TYPE AuditType,
 574                                           IN DWORD Flags,
 575                                           IN POBJECT_TYPE_LIST ObjectTypeList,
 576                                           IN DWORD ObjectTypeListLength,
 577                                           IN PGENERIC_MAPPING GenericMapping,
 578                                           IN BOOL ObjectCreation,
 579                                           OUT LPDWORD GrantedAccess,
 580                                           OUT LPDWORD AccessStatusList,
 581                                           OUT LPBOOL pfGenerateOnClose)
 582 {
 583     FIXME("%s() not implemented!\n", __FUNCTION__);
 584     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 585     return FALSE;
 586 }
 587
 588
 589 /*
 590  * @unimplemented
 591  */
 592 BOOL WINAPI
 593 AccessCheckByTypeResultListAndAuditAlarmA(IN LPCSTR SubsystemName,
 594                                           IN LPVOID HandleId,
 595                                           IN LPCSTR ObjectTypeName,
 596                                           IN LPCSTR ObjectName,
 597                                           IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 598                                           IN PSID PrincipalSelfSid,
 599                                           IN DWORD DesiredAccess,
 600                                           IN AUDIT_EVENT_TYPE AuditType,
 601                                           IN DWORD Flags,
 602                                           IN POBJECT_TYPE_LIST ObjectTypeList,
 603                                           IN DWORD ObjectTypeListLength,
 604                                           IN PGENERIC_MAPPING GenericMapping,
 605                                           IN BOOL ObjectCreation,
 606                                           OUT LPDWORD GrantedAccess,
 607                                           OUT LPDWORD AccessStatusList,
 608                                           OUT LPBOOL pfGenerateOnClose)
 609 {
 610     FIXME("%s() not implemented!\n", __FUNCTION__);
 611     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 612     return FALSE;
 613 }
 614
 615
 616 /*
 617  * @unimplemented
 618  */
 619 BOOL WINAPI
 620 AccessCheckByTypeAndAuditAlarmW(IN LPCWSTR SubsystemName,
 621                                 IN LPVOID HandleId,
 622                                 IN LPCWSTR ObjectTypeName,
 623                                 IN LPCWSTR ObjectName,
 624                                 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 625                                 IN PSID PrincipalSelfSid,
 626                                 IN DWORD DesiredAccess,
 627                                 IN AUDIT_EVENT_TYPE AuditType,
 628                                 IN DWORD Flags,
 629                                 IN POBJECT_TYPE_LIST ObjectTypeList,
 630                                 IN DWORD ObjectTypeListLength,
 631                                 IN PGENERIC_MAPPING GenericMapping,
 632                                 IN BOOL ObjectCreation,
 633                                 OUT LPDWORD GrantedAccess,
 634                                 OUT LPBOOL AccessStatus,
 635                                 OUT LPBOOL pfGenerateOnClose)
 636 {
 637     FIXME("%s() not implemented!\n", __FUNCTION__);
 638     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 639     return FALSE;
 640 }
 641
 642
 643 /*
 644  * @unimplemented
 645  */
 646 BOOL WINAPI
 647 AccessCheckByTypeAndAuditAlarmA(IN LPCSTR SubsystemName,
 648                                 IN LPVOID HandleId,
 649                                 IN LPCSTR ObjectTypeName,
 650                                 IN LPCSTR ObjectName,
 651                                 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 652                                 IN PSID PrincipalSelfSid,
 653                                 IN DWORD DesiredAccess,
 654                                 IN AUDIT_EVENT_TYPE AuditType,
 655                                 IN DWORD Flags,
 656                                 IN POBJECT_TYPE_LIST ObjectTypeList,
 657                                 IN DWORD ObjectTypeListLength,
 658                                 IN PGENERIC_MAPPING GenericMapping,
 659                                 IN BOOL ObjectCreation,
 660                                 OUT LPDWORD GrantedAccess,
 661                                 OUT LPBOOL AccessStatus,
 662                                 OUT LPBOOL pfGenerateOnClose)
 663 {
 664     FIXME("%s() not implemented!\n", __FUNCTION__);
 665     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 666     return FALSE;
 667 }
 668
 669 /* EOF */