scheduler/handle.c

   1 /*
   2  * Win32 process handles
   3  *
   4  * Copyright 1998 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <stdio.h>
   9 #include "winbase.h"
  10 #include "winerror.h"
  11 #include "heap.h"
  12 #include "process.h"
  13
  14 #define HTABLE_SIZE  0x30  /* Handle table initial size */
  15 #define HTABLE_INC   0x10  /* Handle table increment */
  16
  17 /* Reserved access rights */
  18 #define RESERVED_ALL           (0x0007 << RESERVED_SHIFT)
  19 #define RESERVED_SHIFT         25
  20 #define RESERVED_INHERIT       (HANDLE_FLAG_INHERIT<<RESERVED_SHIFT)
  21 #define RESERVED_CLOSE_PROTECT (HANDLE_FLAG_PROTECT_FROM_CLOSE<<RESERVED_SHIFT)
  22
  23
  24 /***********************************************************************
  25  *           HANDLE_AllocTable
  26  */
  27 HANDLE_TABLE *HANDLE_AllocTable( PDB32 *process )
  28 {
  29     HANDLE_TABLE *table = HeapAlloc( process->system_heap, HEAP_ZERO_MEMORY,
  30                                      sizeof(HANDLE_TABLE) +
  31                                      (HTABLE_SIZE-1) * sizeof(HANDLE_ENTRY) );
  32     if (!table) return NULL;
  33     table->count = HTABLE_SIZE;
  34     return table;
  35 }
  36
  37
  38 /***********************************************************************
  39  *           HANDLE_GrowTable
  40  */
  41 static BOOL32 HANDLE_GrowTable( PDB32 *process )
  42 {
  43     HANDLE_TABLE *table;
  44
  45     SYSTEM_LOCK();
  46     table = process->handle_table;
  47     table = HeapReAlloc( process->system_heap,
  48                          HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, table,
  49                          sizeof(HANDLE_TABLE) +
  50                          (table->count+HTABLE_INC-1) * sizeof(HANDLE_ENTRY) );
  51     if (table)
  52     {
  53         table->count += HTABLE_INC;
  54         process->handle_table = table;
  55     }
  56     SYSTEM_UNLOCK();
  57     return (table != NULL);
  58 }
  59
  60
  61 /***********************************************************************
  62  *           HANDLE_Alloc
  63  *
  64  * Allocate a handle for a kernel object and increment its refcount.
  65  */
  66 HANDLE32 HANDLE_Alloc( K32OBJ *ptr, DWORD access, BOOL32 inherit )
  67 {
  68     HANDLE32 h;
  69     HANDLE_ENTRY *entry;
  70     PDB32 *pdb = PROCESS_Current();
  71
  72     assert( ptr );
  73
  74     /* Set the inherit reserved flag */
  75     access &= ~RESERVED_ALL;
  76     if (inherit) access |= RESERVED_INHERIT;
  77
  78     SYSTEM_LOCK();
  79     K32OBJ_IncCount( ptr );
  80     entry = pdb->handle_table->entries;
  81     for (h = 0; h < pdb->handle_table->count; h++, entry++)
  82         if (!entry->ptr) break;
  83     if ((h < pdb->handle_table->count) || HANDLE_GrowTable( pdb ))
  84     {
  85         entry = &pdb->handle_table->entries[h];
  86         entry->access = access;
  87         entry->ptr    = ptr;
  88         SYSTEM_UNLOCK();
  89         return h + 1;  /* Avoid handle 0 */
  90     }
  91     K32OBJ_DecCount( ptr );
  92     SYSTEM_UNLOCK();
  93     SetLastError( ERROR_OUTOFMEMORY );
  94     return INVALID_HANDLE_VALUE32;
  95 }
  96
  97
  98 /***********************************************************************
  99  *           HANDLE_GetObjPtr
 100  *
 101  * Retrieve a pointer to a kernel object and increments its reference count.
 102  * The refcount must be decremented when the pointer is no longer used.
 103  */
 104 K32OBJ *HANDLE_GetObjPtr( HANDLE32 handle, K32OBJ_TYPE type, DWORD access )
 105 {
 106     K32OBJ *ptr = NULL;
 107     PDB32 *pdb = PROCESS_Current();
 108
 109     SYSTEM_LOCK();
 110     if ((handle > 0) && (handle <= pdb->handle_table->count))
 111     {
 112         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 113         if ((entry->access & access) != access)
 114             fprintf( stderr, "Warning: handle %08x bad access (acc=%08lx req=%08lx)\n",
 115                      handle, entry->access, access );
 116         ptr = entry->ptr;
 117         if (ptr && ((type == K32OBJ_UNKNOWN) || (ptr->type == type)))
 118             K32OBJ_IncCount( ptr );
 119         else
 120             ptr = NULL;
 121     }
 122     SYSTEM_UNLOCK();
 123     if (!ptr) SetLastError( ERROR_INVALID_HANDLE );
 124     return ptr;
 125 }
 126
 127
 128 /***********************************************************************
 129  *           HANDLE_SetObjPtr
 130  *
 131  * Change the object pointer of a handle, and increment the refcount.
 132  * Use with caution!
 133  */
 134 BOOL32 HANDLE_SetObjPtr( HANDLE32 handle, K32OBJ *ptr, DWORD access )
 135 {
 136     BOOL32 ret = FALSE;
 137     PDB32 *pdb = PROCESS_Current();
 138
 139     SYSTEM_LOCK();
 140     if ((handle > 0) && (handle <= pdb->handle_table->count))
 141     {
 142         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 143         K32OBJ *old_ptr = entry->ptr;
 144         K32OBJ_IncCount( ptr );
 145         entry->access = access;
 146         entry->ptr    = ptr;
 147         if (old_ptr) K32OBJ_DecCount( old_ptr );
 148         ret = TRUE;
 149     }
 150     SYSTEM_UNLOCK();
 151     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 152     return ret;
 153 }
 154
 155
 156 /*********************************************************************
 157  *           CloseHandle   (KERNEL32.23)
 158  */
 159 BOOL32 WINAPI CloseHandle( HANDLE32 handle )
 160 {
 161     BOOL32 ret = FALSE;
 162     PDB32 *pdb = PROCESS_Current();
 163     K32OBJ *ptr;
 164
 165     SYSTEM_LOCK();
 166     if ((handle > 0) && (handle <= pdb->handle_table->count))
 167     {
 168         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 169         if ((ptr = entry->ptr))
 170         {
 171             if (!(entry->access & RESERVED_CLOSE_PROTECT))
 172             {
 173                 entry->access = 0;
 174                 entry->ptr    = NULL;
 175                 K32OBJ_DecCount( ptr );
 176                 ret = TRUE;
 177             }
 178             /* FIXME: else SetLastError */
 179         }
 180     }
 181     SYSTEM_UNLOCK();
 182     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 183     return ret;
 184 }
 185
 186
 187 /*********************************************************************
 188  *           GetHandleInformation   (KERNEL32.336)
 189  */
 190 BOOL32 WINAPI GetHandleInformation( HANDLE32 handle, LPDWORD flags )
 191 {
 192     BOOL32 ret = FALSE;
 193     PDB32 *pdb = PROCESS_Current();
 194
 195     SYSTEM_LOCK();
 196     if ((handle > 0) && (handle <= pdb->handle_table->count))
 197     {
 198         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 199         if (entry->ptr)
 200         {
 201             if (flags)
 202                 *flags = (entry->access & RESERVED_ALL) >> RESERVED_SHIFT;
 203             ret = TRUE;
 204         }
 205     }
 206     SYSTEM_UNLOCK();
 207     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 208     return ret;
 209 }
 210
 211
 212 /*********************************************************************
 213  *           SetHandleInformation   (KERNEL32.653)
 214  */
 215 BOOL32 WINAPI SetHandleInformation( HANDLE32 handle, DWORD mask, DWORD flags )
 216 {
 217     BOOL32 ret = FALSE;
 218     PDB32 *pdb = PROCESS_Current();
 219
 220     mask  = (mask << RESERVED_SHIFT) & RESERVED_ALL;
 221     flags = (flags << RESERVED_SHIFT) & RESERVED_ALL;
 222     SYSTEM_LOCK();
 223     if ((handle > 0) && (handle <= pdb->handle_table->count))
 224     {
 225         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 226         if (entry->ptr)
 227         {
 228             entry->access = (entry->access & ~mask) | flags;
 229             ret = TRUE;
 230         }
 231     }
 232     SYSTEM_UNLOCK();
 233     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 234     return ret;
 235 }