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     Status = RtlCreateUnicodeStringFromAsciiz(&Name,
 160                                               (PCHAR)SubsystemName);
 161     if (!NT_SUCCESS(Status))
 162     {
 163         SetLastError(RtlNtStatusToDosError(Status));
 164         return FALSE;
 165     }
 166
 167     Status = NtCloseObjectAuditAlarm(&Name,
 168                                      HandleId,
 169                                      GenerateOnClose);
 170     RtlFreeUnicodeString(&Name);
 171     if (!NT_SUCCESS (Status))
 172     {
 173         SetLastError(RtlNtStatusToDosError(Status));
 174         return FALSE;
 175     }
 176
 177     return TRUE;
 178 }
 179
 180
 181 /*
 182  * @implemented
 183  */
 184 BOOL WINAPI
 185 ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
 186                        LPVOID HandleId,
 187                        BOOL GenerateOnClose)
 188 {
 189     UNICODE_STRING Name;
 190     NTSTATUS Status;
 191
 192     RtlInitUnicodeString(&Name,
 193                          (PWSTR)SubsystemName);
 194
 195     Status = NtCloseObjectAuditAlarm(&Name,
 196                                      HandleId,
 197                                      GenerateOnClose);
 198     if (!NT_SUCCESS(Status))
 199     {
 200         SetLastError(RtlNtStatusToDosError(Status));
 201         return FALSE;
 202     }
 203
 204     return TRUE;
 205 }
 206
 207
 208 /*
 209  * @implemented
 210  */
 211 BOOL WINAPI
 212 ObjectDeleteAuditAlarmA(LPCSTR SubsystemName,
 213                         LPVOID HandleId,
 214                         BOOL GenerateOnClose)
 215 {
 216     UNICODE_STRING Name;
 217     NTSTATUS Status;
 218
 219     Status = RtlCreateUnicodeStringFromAsciiz(&Name,
 220                                               (PCHAR)SubsystemName);
 221     if (!NT_SUCCESS(Status))
 222     {
 223         SetLastError(RtlNtStatusToDosError(Status));
 224         return FALSE;
 225     }
 226
 227     Status = NtDeleteObjectAuditAlarm(&Name,
 228                                       HandleId,
 229                                       GenerateOnClose);
 230     RtlFreeUnicodeString(&Name);
 231     if (!NT_SUCCESS(Status))
 232     {
 233         SetLastError(RtlNtStatusToDosError(Status));
 234         return FALSE;
 235     }
 236
 237     return TRUE;
 238 }
 239
 240
 241 /*
 242  * @implemented
 243  */
 244 BOOL WINAPI
 245 ObjectDeleteAuditAlarmW(LPCWSTR SubsystemName,
 246                         LPVOID HandleId,
 247                         BOOL GenerateOnClose)
 248 {
 249     UNICODE_STRING Name;
 250     NTSTATUS Status;
 251
 252     RtlInitUnicodeString(&Name,
 253                          (PWSTR)SubsystemName);
 254
 255     Status = NtDeleteObjectAuditAlarm(&Name,
 256                                       HandleId,
 257                                       GenerateOnClose);
 258     if (!NT_SUCCESS(Status))
 259     {
 260         SetLastError(RtlNtStatusToDosError(Status));
 261         return FALSE;
 262     }
 263
 264     return TRUE;
 265 }
 266
 267
 268 /*
 269  * @implemented
 270  */
 271 BOOL WINAPI
 272 ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
 273                       LPVOID HandleId,
 274                       LPSTR ObjectTypeName,
 275                       LPSTR ObjectName,
 276                       PSECURITY_DESCRIPTOR pSecurityDescriptor,
 277                       HANDLE ClientToken,
 278                       DWORD DesiredAccess,
 279                       DWORD GrantedAccess,
 280                       PPRIVILEGE_SET Privileges,
 281                       BOOL ObjectCreation,
 282                       BOOL AccessGranted,
 283                       LPBOOL GenerateOnClose)
 284 {
 285     UNICODE_STRING SubsystemNameU;
 286     UNICODE_STRING ObjectTypeNameU;
 287     UNICODE_STRING ObjectNameU;
 288     NTSTATUS Status;
 289
 290     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 291                                      (PCHAR)SubsystemName);
 292     RtlCreateUnicodeStringFromAsciiz(&ObjectTypeNameU,
 293                                      (PCHAR)ObjectTypeName);
 294     RtlCreateUnicodeStringFromAsciiz(&ObjectNameU,
 295                                      (PCHAR)ObjectName);
 296
 297     Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
 298                                     HandleId,
 299                                     &ObjectTypeNameU,
 300                                     &ObjectNameU,
 301                                     pSecurityDescriptor,
 302                                     ClientToken,
 303                                     DesiredAccess,
 304                                     GrantedAccess,
 305                                     Privileges,
 306                                     ObjectCreation,
 307                                     AccessGranted,
 308                                     (PBOOLEAN)GenerateOnClose);
 309     RtlFreeUnicodeString(&SubsystemNameU);
 310     RtlFreeUnicodeString(&ObjectTypeNameU);
 311     RtlFreeUnicodeString(&ObjectNameU);
 312     if (!NT_SUCCESS(Status))
 313     {
 314         SetLastError(RtlNtStatusToDosError(Status));
 315         return FALSE;
 316     }
 317
 318     return TRUE;
 319 }
 320
 321
 322 /*
 323  * @implemented
 324  */
 325 BOOL WINAPI
 326 ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
 327                       LPVOID HandleId,
 328                       LPWSTR ObjectTypeName,
 329                       LPWSTR ObjectName,
 330                       PSECURITY_DESCRIPTOR pSecurityDescriptor,
 331                       HANDLE ClientToken,
 332                       DWORD DesiredAccess,
 333                       DWORD GrantedAccess,
 334                       PPRIVILEGE_SET Privileges,
 335                       BOOL ObjectCreation,
 336                       BOOL AccessGranted,
 337                       LPBOOL GenerateOnClose)
 338 {
 339     UNICODE_STRING SubsystemNameU;
 340     UNICODE_STRING ObjectTypeNameU;
 341     UNICODE_STRING ObjectNameU;
 342     NTSTATUS Status;
 343
 344     RtlInitUnicodeString(&SubsystemNameU,
 345                          (PWSTR)SubsystemName);
 346     RtlInitUnicodeString(&ObjectTypeNameU,
 347                          (PWSTR)ObjectTypeName);
 348     RtlInitUnicodeString(&ObjectNameU,
 349                          (PWSTR)ObjectName);
 350
 351     Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
 352                                     HandleId,
 353                                     &ObjectTypeNameU,
 354                                     &ObjectNameU,
 355                                     pSecurityDescriptor,
 356                                     ClientToken,
 357                                     DesiredAccess,
 358                                     GrantedAccess,
 359                                     Privileges,
 360                                     ObjectCreation,
 361                                     AccessGranted,
 362                                     (PBOOLEAN)GenerateOnClose);
 363     if (!NT_SUCCESS(Status))
 364     {
 365         SetLastError(RtlNtStatusToDosError(Status));
 366         return FALSE;
 367     }
 368
 369     return TRUE;
 370 }
 371
 372
 373 /*
 374  * @implemented
 375  */
 376 BOOL WINAPI
 377 ObjectPrivilegeAuditAlarmA(LPCSTR SubsystemName,
 378                            LPVOID HandleId,
 379                            HANDLE ClientToken,
 380                            DWORD DesiredAccess,
 381                            PPRIVILEGE_SET Privileges,
 382                            BOOL AccessGranted)
 383 {
 384     UNICODE_STRING SubsystemNameU;
 385     NTSTATUS Status;
 386
 387     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 388                                      (PCHAR)SubsystemName);
 389
 390     Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
 391                                          HandleId,
 392                                          ClientToken,
 393                                          DesiredAccess,
 394                                          Privileges,
 395                                          AccessGranted);
 396     RtlFreeUnicodeString (&SubsystemNameU);
 397     if (!NT_SUCCESS(Status))
 398     {
 399         SetLastError(RtlNtStatusToDosError(Status));
 400         return FALSE;
 401     }
 402
 403     return TRUE;
 404 }
 405
 406
 407 /*
 408  * @implemented
 409  */
 410 BOOL WINAPI
 411 ObjectPrivilegeAuditAlarmW(LPCWSTR SubsystemName,
 412                            LPVOID HandleId,
 413                            HANDLE ClientToken,
 414                            DWORD DesiredAccess,
 415                            PPRIVILEGE_SET Privileges,
 416                            BOOL AccessGranted)
 417 {
 418     UNICODE_STRING SubsystemNameU;
 419     NTSTATUS Status;
 420
 421     RtlInitUnicodeString(&SubsystemNameU,
 422                          (PWSTR)SubsystemName);
 423
 424     Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
 425                                          HandleId,
 426                                          ClientToken,
 427                                          DesiredAccess,
 428                                          Privileges,
 429                                          AccessGranted);
 430     if (!NT_SUCCESS(Status))
 431     {
 432         SetLastError(RtlNtStatusToDosError(Status));
 433         return FALSE;
 434     }
 435
 436     return TRUE;
 437 }
 438
 439
 440 /*
 441  * @implemented
 442  */
 443 BOOL WINAPI
 444 PrivilegedServiceAuditAlarmA(LPCSTR SubsystemName,
 445                              LPCSTR ServiceName,
 446                              HANDLE ClientToken,
 447                              PPRIVILEGE_SET Privileges,
 448                              BOOL AccessGranted)
 449 {
 450     UNICODE_STRING SubsystemNameU;
 451     UNICODE_STRING ServiceNameU;
 452     NTSTATUS Status;
 453
 454     RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
 455                                      (PCHAR)SubsystemName);
 456     RtlCreateUnicodeStringFromAsciiz(&ServiceNameU,
 457                                      (PCHAR)ServiceName);
 458
 459     Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
 460                                            &ServiceNameU,
 461                                            ClientToken,
 462                                            Privileges,
 463                                            AccessGranted);
 464     RtlFreeUnicodeString(&SubsystemNameU);
 465     RtlFreeUnicodeString(&ServiceNameU);
 466     if (!NT_SUCCESS(Status))
 467     {
 468         SetLastError(RtlNtStatusToDosError(Status));
 469         return FALSE;
 470     }
 471
 472     return TRUE;
 473 }
 474
 475
 476 /*
 477  * @implemented
 478  */
 479 BOOL WINAPI
 480 PrivilegedServiceAuditAlarmW(LPCWSTR SubsystemName,
 481                              LPCWSTR ServiceName,
 482                              HANDLE ClientToken,
 483                              PPRIVILEGE_SET Privileges,
 484                              BOOL AccessGranted)
 485 {
 486     UNICODE_STRING SubsystemNameU;
 487     UNICODE_STRING ServiceNameU;
 488     NTSTATUS Status;
 489
 490     RtlInitUnicodeString(&SubsystemNameU,
 491                          (PWSTR)SubsystemName);
 492     RtlInitUnicodeString(&ServiceNameU,
 493                          (PWSTR)ServiceName);
 494
 495     Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
 496                                            &ServiceNameU,
 497                                            ClientToken,
 498                                            Privileges,
 499                                            AccessGranted);
 500     if (!NT_SUCCESS(Status))
 501     {
 502         SetLastError(RtlNtStatusToDosError(Status));
 503         return FALSE;
 504     }
 505
 506     return TRUE;
 507 }
 508
 509
 510 /*
 511  * @unimplemented
 512  */
 513 BOOL WINAPI
 514 AccessCheckByTypeResultListAndAuditAlarmByHandleW(IN LPCWSTR SubsystemName,
 515                                                   IN LPVOID HandleId,
 516                                                   IN HANDLE ClientToken,
 517                                                   IN LPCWSTR ObjectTypeName,
 518                                                   IN LPCWSTR ObjectName,
 519                                                   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 520                                                   IN PSID PrincipalSelfSid,
 521                                                   IN DWORD DesiredAccess,
 522                                                   IN AUDIT_EVENT_TYPE AuditType,
 523                                                   IN DWORD Flags,
 524                                                   IN POBJECT_TYPE_LIST ObjectTypeList,
 525                                                   IN DWORD ObjectTypeListLength,
 526                                                   IN PGENERIC_MAPPING GenericMapping,
 527                                                   IN BOOL ObjectCreation,
 528                                                   OUT LPDWORD GrantedAccess,
 529                                                   OUT LPDWORD AccessStatusList,
 530                                                   OUT LPBOOL pfGenerateOnClose)
 531 {
 532     FIXME("%s() not implemented!\n", __FUNCTION__);
 533     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 534     return FALSE;
 535 }
 536
 537
 538 /*
 539  * @unimplemented
 540  */
 541 BOOL WINAPI
 542 AccessCheckByTypeResultListAndAuditAlarmByHandleA(IN LPCSTR SubsystemName,
 543                                                   IN LPVOID HandleId,
 544                                                   IN HANDLE ClientToken,
 545                                                   IN LPCSTR ObjectTypeName,
 546                                                   IN LPCSTR ObjectName,
 547                                                   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 548                                                   IN PSID PrincipalSelfSid,
 549                                                   IN DWORD DesiredAccess,
 550                                                   IN AUDIT_EVENT_TYPE AuditType,
 551                                                   IN DWORD Flags,
 552                                                   IN POBJECT_TYPE_LIST ObjectTypeList,
 553                                                   IN DWORD ObjectTypeListLength,
 554                                                   IN PGENERIC_MAPPING GenericMapping,
 555                                                   IN BOOL ObjectCreation,
 556                                                   OUT LPDWORD GrantedAccess,
 557                                                   OUT LPDWORD AccessStatusList,
 558                                                   OUT LPBOOL pfGenerateOnClose)
 559 {
 560     FIXME("%s() not implemented!\n", __FUNCTION__);
 561     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 562     return FALSE;
 563 }
 564
 565
 566 /*
 567  * @unimplemented
 568  */
 569 BOOL WINAPI
 570 AccessCheckByTypeResultListAndAuditAlarmW(IN LPCWSTR SubsystemName,
 571                                           IN LPVOID HandleId,
 572                                           IN LPCWSTR ObjectTypeName,
 573                                           IN LPCWSTR ObjectName,
 574                                           IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 575                                           IN PSID PrincipalSelfSid,
 576                                           IN DWORD DesiredAccess,
 577                                           IN AUDIT_EVENT_TYPE AuditType,
 578                                           IN DWORD Flags,
 579                                           IN POBJECT_TYPE_LIST ObjectTypeList,
 580                                           IN DWORD ObjectTypeListLength,
 581                                           IN PGENERIC_MAPPING GenericMapping,
 582                                           IN BOOL ObjectCreation,
 583                                           OUT LPDWORD GrantedAccess,
 584                                           OUT LPDWORD AccessStatusList,
 585                                           OUT LPBOOL pfGenerateOnClose)
 586 {
 587     FIXME("%s() not implemented!\n", __FUNCTION__);
 588     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 589     return FALSE;
 590 }
 591
 592
 593 /*
 594  * @unimplemented
 595  */
 596 BOOL WINAPI
 597 AccessCheckByTypeResultListAndAuditAlarmA(IN LPCSTR SubsystemName,
 598                                           IN LPVOID HandleId,
 599                                           IN LPCSTR ObjectTypeName,
 600                                           IN LPCSTR ObjectName,
 601                                           IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 602                                           IN PSID PrincipalSelfSid,
 603                                           IN DWORD DesiredAccess,
 604                                           IN AUDIT_EVENT_TYPE AuditType,
 605                                           IN DWORD Flags,
 606                                           IN POBJECT_TYPE_LIST ObjectTypeList,
 607                                           IN DWORD ObjectTypeListLength,
 608                                           IN PGENERIC_MAPPING GenericMapping,
 609                                           IN BOOL ObjectCreation,
 610                                           OUT LPDWORD GrantedAccess,
 611                                           OUT LPDWORD AccessStatusList,
 612                                           OUT LPBOOL pfGenerateOnClose)
 613 {
 614     FIXME("%s() not implemented!\n", __FUNCTION__);
 615     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 616     return FALSE;
 617 }
 618
 619
 620 /*
 621  * @unimplemented
 622  */
 623 BOOL WINAPI
 624 AccessCheckByTypeAndAuditAlarmW(IN LPCWSTR SubsystemName,
 625                                 IN LPVOID HandleId,
 626                                 IN LPCWSTR ObjectTypeName,
 627                                 IN LPCWSTR ObjectName,
 628                                 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 629                                 IN PSID PrincipalSelfSid,
 630                                 IN DWORD DesiredAccess,
 631                                 IN AUDIT_EVENT_TYPE AuditType,
 632                                 IN DWORD Flags,
 633                                 IN POBJECT_TYPE_LIST ObjectTypeList,
 634                                 IN DWORD ObjectTypeListLength,
 635                                 IN PGENERIC_MAPPING GenericMapping,
 636                                 IN BOOL ObjectCreation,
 637                                 OUT LPDWORD GrantedAccess,
 638                                 OUT LPBOOL AccessStatus,
 639                                 OUT LPBOOL pfGenerateOnClose)
 640 {
 641     FIXME("%s() not implemented!\n", __FUNCTION__);
 642     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 643     return FALSE;
 644 }
 645
 646
 647 /*
 648  * @unimplemented
 649  */
 650 BOOL WINAPI
 651 AccessCheckByTypeAndAuditAlarmA(IN LPCSTR SubsystemName,
 652                                 IN LPVOID HandleId,
 653                                 IN LPCSTR ObjectTypeName,
 654                                 IN LPCSTR ObjectName,
 655                                 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 656                                 IN PSID PrincipalSelfSid,
 657                                 IN DWORD DesiredAccess,
 658                                 IN AUDIT_EVENT_TYPE AuditType,
 659                                 IN DWORD Flags,
 660                                 IN POBJECT_TYPE_LIST ObjectTypeList,
 661                                 IN DWORD ObjectTypeListLength,
 662                                 IN PGENERIC_MAPPING GenericMapping,
 663                                 IN BOOL ObjectCreation,
 664                                 OUT LPDWORD GrantedAccess,
 665                                 OUT LPBOOL AccessStatus,
 666                                 OUT LPBOOL pfGenerateOnClose)
 667 {
 668     FIXME("%s() not implemented!\n", __FUNCTION__);
 669     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 670     return FALSE;
 671 }
 672
 673 /* EOF */