lib/advapi32/token/privilege.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/advapi32/token/privilege.c
   6  * PURPOSE:         advapi32.dll token's privilege handling
   7  * PROGRAMMER:      E.Aliberti
   8  * UPDATE HISTORY:
   9  *      20010317 ea     stubs
  10  */
  11 #include <windows.h>
  12 #include <ddk/ntddk.h>
  13
  14
  15 /**********************************************************************
  16  *      LookupPrivilegeValueA                           EXPORTED
  17  *      LookupPrivilegeValueW                           EXPORTED
  18  *
  19  * @implemented
  20  */
  21 BOOL STDCALL LookupPrivilegeValueA (
  22         LPCSTR  lpSystemName,
  23         LPCSTR  lpName,
  24         PLUID   lpLuid
  25         )
  26 {
  27         BOOL            rv = FALSE;
  28         DWORD           le = ERROR_SUCCESS;
  29
  30         ANSI_STRING     SystemNameA;
  31         UNICODE_STRING  SystemNameW;
  32         ANSI_STRING     NameA;
  33         UNICODE_STRING  NameW;
  34
  35         HANDLE          ProcessHeap = GetProcessHeap ();
  36
  37
  38         /* Remote system? */
  39         if (NULL != lpSystemName)
  40         {
  41                 RtlInitAnsiString (
  42                         & SystemNameA,
  43                         (LPSTR) lpSystemName
  44                         );
  45                 RtlAnsiStringToUnicodeString (
  46                         & SystemNameW,
  47                         & SystemNameA,
  48                         TRUE
  49                         );
  50         }
  51         /* Check the privilege name is not NULL */
  52         if (NULL != lpName)
  53         {
  54                 RtlInitAnsiString (
  55                         & NameA,
  56                         (LPSTR) lpName
  57                         );
  58                 RtlAnsiStringToUnicodeString (
  59                         & NameW,
  60                         & NameA,
  61                         TRUE
  62                         );
  63         }
  64         else
  65         {
  66                 SetLastError (ERROR_INVALID_PARAMETER);
  67                 return (FALSE);
  68         }
  69         /*
  70          * Forward the call to the UNICODE version
  71          * of this API.
  72          */
  73         if (FALSE == (rv = LookupPrivilegeValueW (
  74                                 (lpSystemName ? SystemNameW.Buffer : NULL),
  75                                 NameW.Buffer,
  76                                 lpLuid
  77                                 )
  78                         )
  79                 )
  80         {
  81                 le = GetLastError ();
  82         }
  83         /* Remote system? */
  84         if (NULL != lpSystemName)
  85         {
  86                 RtlFreeHeap (
  87                         ProcessHeap,
  88                         0,
  89                         SystemNameW.Buffer
  90                         );
  91         }
  92         /* Name */
  93         RtlFreeHeap (
  94                 ProcessHeap,
  95                 0,
  96                NameW.Buffer
  97                );
  98         /*
  99          * Set the last error, if any reported by
 100          * the UNICODE call.
 101          */
 102         if (ERROR_SUCCESS != le)
 103         {
 104                 SetLastError (le);
 105         }
 106         return (rv);
 107 }
 108
 109
 110 BOOL STDCALL LookupPrivilegeValueW (
 111         LPCWSTR lpSystemName,
 112         LPCWSTR lpName,
 113         PLUID   lpLuid
 114         )
 115 {
 116         SetLastError (ERROR_CALL_NOT_IMPLEMENTED);
 117         return (FALSE);
 118 }
 119
 120
 121 /**********************************************************************
 122  *      LookupPrivilegeDisplayNameA                     EXPORTED
 123  *      LookupPrivilegeDisplayNameW                     EXPORTED
 124  *
 125  * @unimplemented
 126  */
 127 BOOL STDCALL LookupPrivilegeDisplayNameA (
 128         LPCSTR  lpSystemName,
 129         LPCSTR  lpName,
 130         LPSTR   lpDisplayName,
 131         LPDWORD cbDisplayName,
 132         LPDWORD lpLanguageId
 133         )
 134 {
 135         SetLastError (ERROR_CALL_NOT_IMPLEMENTED);
 136         return (FALSE);
 137 }
 138
 139
 140 /*
 141  * @unimplemented
 142  */
 143 BOOL STDCALL LookupPrivilegeDisplayNameW (
 144         LPCWSTR lpSystemName,
 145         LPCWSTR lpName,
 146         LPWSTR  lpDisplayName,
 147         LPDWORD cbDisplayName,
 148         LPDWORD lpLanguageId
 149         )
 150 {
 151         SetLastError (ERROR_CALL_NOT_IMPLEMENTED);
 152         return (FALSE);
 153 }
 154
 155
 156 /**********************************************************************
 157  *      LookupPrivilegeNameA                            EXPORTED
 158  *      LookupPrivilegeNameW                            EXPORTED
 159  *
 160  * @unimplemented
 161  */
 162 BOOL STDCALL LookupPrivilegeNameA (
 163         LPCSTR  lpSystemName,
 164         PLUID   lpLuid,
 165         LPSTR   lpName,
 166         LPDWORD cbName
 167         )
 168 {
 169         SetLastError (ERROR_CALL_NOT_IMPLEMENTED);
 170         return (FALSE);
 171 }
 172
 173 /*
 174  * @unimplemented
 175  */
 176 BOOL STDCALL LookupPrivilegeNameW (
 177         LPCWSTR lpSystemName,
 178         PLUID   lpLuid,
 179         LPWSTR  lpName,
 180         LPDWORD cbName
 181         )
 182 {
 183         SetLastError (ERROR_CALL_NOT_IMPLEMENTED);
 184         return (FALSE);
 185 }
 186
 187
 188 /**********************************************************************
 189  *      PrivilegeCheck                                  EXPORTED
 190  *
 191  * @implemented
 192  */
 193 BOOL STDCALL
 194 PrivilegeCheck (HANDLE ClientToken,
 195                 PPRIVILEGE_SET RequiredPrivileges,
 196                 LPBOOL pfResult)
 197 {
 198   BOOLEAN Result;
 199   NTSTATUS Status;
 200
 201   Status = NtPrivilegeCheck (ClientToken,
 202                              RequiredPrivileges,
 203                              &Result);
 204   if (!NT_SUCCESS (Status))
 205     {
 206       SetLastError (RtlNtStatusToDosError (Status));
 207       return FALSE;
 208     }
 209
 210   *pfResult = (BOOL) Result;
 211
 212   return TRUE;
 213 }
 214
 215 /* EOF */