reactos/lib/kernel32/misc/handle.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS system libraries
   5  * FILE:            lib/kernel32/misc/handle.c
   6  * PURPOSE:         Object  functions
   7  * PROGRAMMER:      Ariadne ( ariadne@xs4all.nl)
   8  * UPDATE HISTORY:
   9  *                  Created 01/11/98
  10  */
  11
  12 /* INCLUDES ******************************************************************/
  13
  14 #include <k32.h>
  15
  16 #define NDEBUG
  17 #include "../include/debug.h"
  18
  19 /* GLOBALS *******************************************************************/
  20
  21 HANDLE STDCALL
  22 DuplicateConsoleHandle (HANDLE  hConsole,
  23                         DWORD   dwDesiredAccess,
  24                         BOOL    bInheritHandle,
  25                         DWORD   dwOptions);
  26
  27 /* FUNCTIONS *****************************************************************/
  28
  29 /*
  30  * @implemented
  31  */
  32 BOOL WINAPI
  33 GetHandleInformation (HANDLE hObject,
  34                       LPDWORD lpdwFlags)
  35 {
  36   PRTL_USER_PROCESS_PARAMETERS Ppb;
  37   OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
  38   ULONG BytesWritten;
  39   NTSTATUS Status;
  40   DWORD Flags;
  41
  42   Ppb = NtCurrentPeb()->ProcessParameters;
  43   switch ((ULONG)hObject)
  44   {
  45     case STD_INPUT_HANDLE:
  46       hObject = Ppb->StandardInput;
  47       break;
  48     case STD_OUTPUT_HANDLE:
  49       hObject = Ppb->StandardOutput;
  50       break;
  51     case STD_ERROR_HANDLE:
  52       hObject = Ppb->StandardError;
  53       break;
  54   }
  55
  56   Status = NtQueryObject (hObject,
  57                           ObjectHandleInformation,
  58                           &HandleInfo,
  59                           sizeof(OBJECT_HANDLE_ATTRIBUTE_INFORMATION),
  60                           &BytesWritten);
  61   if (NT_SUCCESS(Status))
  62   {
  63     Flags = 0;
  64     if (HandleInfo.Inherit)
  65       Flags |= HANDLE_FLAG_INHERIT;
  66     if (HandleInfo.ProtectFromClose)
  67       Flags |= HANDLE_FLAG_PROTECT_FROM_CLOSE;
  68
  69     *lpdwFlags = Flags;
  70
  71     return TRUE;
  72   }
  73   else
  74   {
  75     SetLastErrorByStatus (Status);
  76     return FALSE;
  77   }
  78 }
  79
  80
  81 /*
  82  * @implemented
  83  */
  84 BOOL STDCALL
  85 SetHandleInformation (HANDLE hObject,
  86                       DWORD dwMask,
  87                       DWORD dwFlags)
  88 {
  89   PRTL_USER_PROCESS_PARAMETERS Ppb;
  90   OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleInfo;
  91   ULONG BytesWritten;
  92   NTSTATUS Status;
  93
  94   Ppb = NtCurrentPeb()->ProcessParameters;
  95   switch ((ULONG)hObject)
  96   {
  97     case STD_INPUT_HANDLE:
  98       hObject = Ppb->StandardInput;
  99       break;
 100     case STD_OUTPUT_HANDLE:
 101       hObject = Ppb->StandardOutput;
 102       break;
 103     case STD_ERROR_HANDLE:
 104       hObject = Ppb->StandardError;
 105       break;
 106   }
 107
 108   Status = NtQueryObject (hObject,
 109                           ObjectHandleInformation,
 110                           &HandleInfo,
 111                           sizeof(OBJECT_HANDLE_ATTRIBUTE_INFORMATION),
 112                           &BytesWritten);
 113   if (NT_SUCCESS(Status))
 114   {
 115     HandleInfo.Inherit = (dwFlags & HANDLE_FLAG_INHERIT) != 0;
 116     HandleInfo.ProtectFromClose = (dwFlags & HANDLE_FLAG_PROTECT_FROM_CLOSE) != 0;
 117     Status = NtSetInformationObject (hObject,
 118                                      ObjectHandleInformation,
 119                                      &HandleInfo,
 120                                      sizeof(OBJECT_HANDLE_ATTRIBUTE_INFORMATION));
 121     if(!NT_SUCCESS(Status))
 122     {
 123       SetLastErrorByStatus (Status);
 124       return FALSE;
 125     }
 126
 127     return TRUE;
 128   }
 129   else
 130   {
 131     SetLastErrorByStatus (Status);
 132     return FALSE;
 133   }
 134 }
 135
 136
 137 /*
 138  * @implemented
 139  */
 140 BOOL STDCALL CloseHandle(HANDLE  hObject)
 141 /*
 142  * FUNCTION: Closes an open object handle
 143  * PARAMETERS:
 144  *       hObject = Identifies an open object handle
 145  * RETURNS: If the function succeeds, the return value is nonzero
 146  *          If the function fails, the return value is zero
 147  */
 148 {
 149    PRTL_USER_PROCESS_PARAMETERS Ppb;
 150    NTSTATUS Status;
 151
 152    Ppb = NtCurrentPeb()->ProcessParameters;
 153    switch ((ULONG)hObject)
 154    {
 155      case STD_INPUT_HANDLE:
 156        hObject = Ppb->StandardInput;
 157        break;
 158      case STD_OUTPUT_HANDLE:
 159        hObject = Ppb->StandardOutput;
 160        break;
 161      case STD_ERROR_HANDLE:
 162        hObject = Ppb->StandardError;
 163        break;
 164    }
 165
 166    if (IsConsoleHandle(hObject))
 167      {
 168         return(CloseConsoleHandle(hObject));
 169      }
 170
 171    Status = NtClose(hObject);
 172    if (!NT_SUCCESS(Status))
 173      {
 174         SetLastErrorByStatus (Status);
 175         return FALSE;
 176      }
 177
 178    return TRUE;
 179 }
 180
 181
 182 /*
 183  * @implemented
 184  */
 185 BOOL STDCALL DuplicateHandle(HANDLE hSourceProcessHandle,
 186                                 HANDLE hSourceHandle,
 187                                 HANDLE hTargetProcessHandle,
 188                                 LPHANDLE lpTargetHandle,
 189                                 DWORD dwDesiredAccess,
 190                                 BOOL bInheritHandle,
 191                                 DWORD dwOptions)
 192 {
 193    PRTL_USER_PROCESS_PARAMETERS Ppb;
 194    DWORD SourceProcessId, TargetProcessId;
 195    NTSTATUS Status;
 196
 197    Ppb = NtCurrentPeb()->ProcessParameters;
 198    switch ((ULONG)hSourceHandle)
 199    {
 200      case STD_INPUT_HANDLE:
 201        hSourceHandle = Ppb->StandardInput;
 202        break;
 203      case STD_OUTPUT_HANDLE:
 204        hSourceHandle = Ppb->StandardOutput;
 205        break;
 206      case STD_ERROR_HANDLE:
 207        hSourceHandle = Ppb->StandardError;
 208        break;
 209    }
 210
 211    if (IsConsoleHandle(hSourceHandle))
 212    {
 213       SourceProcessId = GetProcessId(hSourceProcessHandle);
 214       TargetProcessId = GetProcessId(hTargetProcessHandle);
 215       if (!SourceProcessId || !TargetProcessId ||
 216           SourceProcessId != TargetProcessId ||
 217           SourceProcessId != GetCurrentProcessId())
 218       {
 219         SetLastError(ERROR_INVALID_PARAMETER);
 220         return FALSE;
 221       }
 222
 223       *lpTargetHandle = DuplicateConsoleHandle(hSourceHandle, dwDesiredAccess, bInheritHandle, dwOptions);
 224       return *lpTargetHandle != INVALID_HANDLE_VALUE;
 225    }
 226
 227    Status = NtDuplicateObject(hSourceProcessHandle,
 228                               hSourceHandle,
 229                               hTargetProcessHandle,
 230                               lpTargetHandle,
 231                               dwDesiredAccess,
 232                               (BOOLEAN)bInheritHandle,
 233                               dwOptions);
 234    if (!NT_SUCCESS(Status))
 235      {
 236         SetLastErrorByStatus (Status);
 237         return FALSE;
 238      }
 239
 240    return TRUE;
 241 }
 242
 243
 244 /*
 245  * @implemented
 246  */
 247 UINT STDCALL SetHandleCount(UINT nCount)
 248 {
 249    return(nCount);
 250 }
 251
 252 /* EOF */