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 #include "server.h"
  14 #include "thread.h"
  15 #include "debug.h"
  16
  17 #define HTABLE_SIZE  0x30  /* Handle table initial size */
  18 #define HTABLE_INC   0x10  /* Handle table increment */
  19
  20 /* Reserved access rights */
  21 #define RESERVED_ALL           (0x0007 << RESERVED_SHIFT)
  22 #define RESERVED_SHIFT         25
  23 #define RESERVED_INHERIT       (HANDLE_FLAG_INHERIT<<RESERVED_SHIFT)
  24 #define RESERVED_CLOSE_PROTECT (HANDLE_FLAG_PROTECT_FROM_CLOSE<<RESERVED_SHIFT)
  25
  26
  27 /***********************************************************************
  28  *           HANDLE_GrowTable
  29  */
  30 static BOOL32 HANDLE_GrowTable( PDB32 *process, INT32 incr )
  31 {
  32     HANDLE_TABLE *table;
  33
  34     SYSTEM_LOCK();
  35     table = process->handle_table;
  36     table = HeapReAlloc( process->system_heap,
  37                          HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, table,
  38                          sizeof(HANDLE_TABLE) +
  39                          (table->count + incr - 1) * sizeof(HANDLE_ENTRY) );
  40     if (table)
  41     {
  42         table->count += incr;
  43         process->handle_table = table;
  44     }
  45     SYSTEM_UNLOCK();
  46     return (table != NULL);
  47 }
  48
  49
  50 /***********************************************************************
  51  *           HANDLE_CreateTable
  52  *
  53  * Create a process handle table, optionally inheriting the parent's handles.
  54  */
  55 BOOL32 HANDLE_CreateTable( PDB32 *pdb, BOOL32 inherit )
  56 {
  57     DWORD size;
  58
  59     /* Process must not already have a handle table */
  60     assert( !pdb->handle_table );
  61
  62     /* If this is the first process, simply allocate a table */
  63     if (!pdb->parent) inherit = FALSE;
  64
  65     SYSTEM_LOCK();
  66     size = inherit ? pdb->parent->handle_table->count : HTABLE_SIZE;
  67     if ((pdb->handle_table = HeapAlloc( pdb->system_heap,
  68                                         HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE,
  69                                         sizeof(HANDLE_TABLE) +
  70                                         (size-1) * sizeof(HANDLE_ENTRY) )))
  71     {
  72         pdb->handle_table->count = size;
  73         if (inherit)
  74         {
  75             HANDLE_ENTRY *src = pdb->parent->handle_table->entries;
  76             HANDLE_ENTRY *dst = pdb->handle_table->entries;
  77             HANDLE32 h;
  78
  79             for (h = 0; h < size; h++, src++, dst++)
  80             {
  81                 /* Check if handle is valid and inheritable */
  82                 if (src->ptr && (src->access & RESERVED_INHERIT))
  83                 {
  84                     dst->access = src->access;
  85                     dst->ptr    = src->ptr;
  86                     dst->server = src->server;
  87                     K32OBJ_IncCount( dst->ptr );
  88                 }
  89             }
  90         }
  91         /* Handle 1 is the process itself (unless the parent decided otherwise) */
  92         if (!pdb->handle_table->entries[1].ptr)
  93         {
  94             pdb->handle_table->entries[1].ptr    = &pdb->header;
  95             pdb->handle_table->entries[1].access = PROCESS_ALL_ACCESS;
  96             pdb->handle_table->entries[1].server = -1;  /* FIXME */
  97             K32OBJ_IncCount( &pdb->header );
  98         }
  99     }
 100     SYSTEM_UNLOCK();
 101     return (pdb->handle_table != NULL);
 102 }
 103
 104
 105 /***********************************************************************
 106  *           HANDLE_Alloc
 107  *
 108  * Allocate a handle for a kernel object and increment its refcount.
 109  */
 110 HANDLE32 HANDLE_Alloc( PDB32 *pdb, K32OBJ *ptr, DWORD access,
 111                        BOOL32 inherit, int server_handle )
 112 {
 113     HANDLE32 h;
 114     HANDLE_ENTRY *entry;
 115
 116     assert( ptr );
 117
 118     /* Set the inherit reserved flag */
 119     access &= ~RESERVED_ALL;
 120     if (inherit) access |= RESERVED_INHERIT;
 121
 122     SYSTEM_LOCK();
 123     K32OBJ_IncCount( ptr );
 124     /* Don't try to allocate handle 0 */
 125     entry = pdb->handle_table->entries + 1;
 126     for (h = 1; h < pdb->handle_table->count; h++, entry++)
 127         if (!entry->ptr) break;
 128     if ((h < pdb->handle_table->count) || HANDLE_GrowTable( pdb, HTABLE_INC ))
 129     {
 130         entry = &pdb->handle_table->entries[h];
 131         entry->access = access;
 132         entry->ptr    = ptr;
 133         entry->server = server_handle;
 134         SYSTEM_UNLOCK();
 135         return h;
 136     }
 137     K32OBJ_DecCount( ptr );
 138     SYSTEM_UNLOCK();
 139     if (server_handle != -1) CLIENT_CloseHandle( server_handle );
 140     SetLastError( ERROR_OUTOFMEMORY );
 141     return INVALID_HANDLE_VALUE32;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           HANDLE_GetObjPtr
 147  *
 148  * Retrieve a pointer to a kernel object and increments its reference count.
 149  * The refcount must be decremented when the pointer is no longer used.
 150  */
 151 K32OBJ *HANDLE_GetObjPtr( PDB32 *pdb, HANDLE32 handle,
 152                           K32OBJ_TYPE type, DWORD access,
 153                           int *server_handle )
 154 {
 155     K32OBJ *ptr = NULL;
 156
 157     SYSTEM_LOCK();
 158     if (HANDLE_IS_GLOBAL( handle ))
 159     {
 160         handle = HANDLE_GLOBAL_TO_LOCAL( handle );
 161         pdb = PROCESS_Initial();
 162     }
 163     if ((handle > 0) && (handle < pdb->handle_table->count))
 164     {
 165         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 166         if ((entry->access & access) != access)
 167             WARN(win32, "Handle %08x bad access (acc=%08lx req=%08lx)\n",
 168                      handle, entry->access, access );
 169         ptr = entry->ptr;
 170         if (server_handle) *server_handle = entry->server;
 171     }
 172     else if (handle == CURRENT_THREAD_PSEUDOHANDLE)
 173     {
 174        ptr = (K32OBJ *)THREAD_Current();
 175        if (server_handle) *server_handle = CURRENT_THREAD_PSEUDOHANDLE;
 176     }
 177     else if (handle == CURRENT_PROCESS_PSEUDOHANDLE)
 178     {
 179        ptr = (K32OBJ *)PROCESS_Current();
 180        if (server_handle) *server_handle = CURRENT_PROCESS_PSEUDOHANDLE;
 181     }
 182
 183     if (ptr && ((type == K32OBJ_UNKNOWN) || (ptr->type == type)))
 184         K32OBJ_IncCount( ptr );
 185     else
 186         ptr = NULL;
 187
 188     SYSTEM_UNLOCK();
 189     if (!ptr) SetLastError( ERROR_INVALID_HANDLE );
 190     return ptr;
 191 }
 192
 193
 194 /***********************************************************************
 195  *           HANDLE_SetObjPtr
 196  *
 197  * Change the object pointer of a handle, and increment the refcount.
 198  * Use with caution!
 199  */
 200 BOOL32 HANDLE_SetObjPtr( PDB32 *pdb, HANDLE32 handle, K32OBJ *ptr,
 201                          DWORD access )
 202 {
 203     BOOL32 ret = FALSE;
 204
 205     SYSTEM_LOCK();
 206     if ((handle > 0) && (handle < pdb->handle_table->count))
 207     {
 208         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 209         K32OBJ *old_ptr = entry->ptr;
 210         K32OBJ_IncCount( ptr );
 211         entry->access = access;
 212         entry->ptr    = ptr;
 213         if (old_ptr) K32OBJ_DecCount( old_ptr );
 214         ret = TRUE;
 215     }
 216     SYSTEM_UNLOCK();
 217     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 218     return ret;
 219 }
 220
 221
 222 /*********************************************************************
 223  *           HANDLE_GetAccess
 224  */
 225 static BOOL32 HANDLE_GetAccess( PDB32 *pdb, HANDLE32 handle, LPDWORD access )
 226 {
 227     BOOL32 ret = FALSE;
 228
 229     SYSTEM_LOCK();
 230     if ((handle > 0) && (handle < pdb->handle_table->count))
 231     {
 232         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 233         if (entry->ptr)
 234         {
 235             *access = entry->access & ~RESERVED_ALL;
 236             ret = TRUE;
 237         }
 238     }
 239     SYSTEM_UNLOCK();
 240     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 241     return ret;
 242 }
 243
 244
 245 /*********************************************************************
 246  *           HANDLE_Close
 247  */
 248 static BOOL32 HANDLE_Close( PDB32 *pdb, HANDLE32 handle )
 249 {
 250     BOOL32 ret = FALSE;
 251     K32OBJ *ptr;
 252
 253     SYSTEM_LOCK();
 254     if ((handle > 0) && (handle < pdb->handle_table->count))
 255     {
 256         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 257         if ((ptr = entry->ptr))
 258         {
 259             if (!(entry->access & RESERVED_CLOSE_PROTECT))
 260             {
 261                 entry->access = 0;
 262                 entry->ptr    = NULL;
 263                 if (entry->server != -1)
 264                     CLIENT_CloseHandle( entry->server );
 265                 K32OBJ_DecCount( ptr );
 266                 ret = TRUE;
 267             }
 268             /* FIXME: else SetLastError */
 269         }
 270     }
 271     SYSTEM_UNLOCK();
 272     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 273     return ret;
 274 }
 275
 276
 277 /*********************************************************************
 278  *           HANDLE_CloseAll
 279  *
 280  * Close all handles pointing to a given object (or all handles of the
 281  * process if the object is NULL)
 282  */
 283 void HANDLE_CloseAll( PDB32 *pdb, K32OBJ *obj )
 284 {
 285     HANDLE_ENTRY *entry;
 286     K32OBJ *ptr;
 287     HANDLE32 handle;
 288
 289     SYSTEM_LOCK();
 290     entry = pdb->handle_table->entries;
 291     for (handle = 0; handle < pdb->handle_table->count; handle++, entry++)
 292     {
 293         if (!(ptr = entry->ptr)) continue;  /* empty slot */
 294         if (obj && (ptr != obj)) continue;  /* not the right object */
 295         entry->access = 0;
 296         entry->ptr    = NULL;
 297         if (entry->server != -1) CLIENT_CloseHandle( entry->server );
 298         K32OBJ_DecCount( ptr );
 299     }
 300     SYSTEM_UNLOCK();
 301 }
 302
 303
 304 /*********************************************************************
 305  *           CloseHandle   (KERNEL32.23)
 306  */
 307 BOOL32 WINAPI CloseHandle( HANDLE32 handle )
 308 {
 309     return HANDLE_Close( PROCESS_Current(), handle );
 310 }
 311
 312
 313 /*********************************************************************
 314  *           GetHandleInformation   (KERNEL32.336)
 315  */
 316 BOOL32 WINAPI GetHandleInformation( HANDLE32 handle, LPDWORD flags )
 317 {
 318     BOOL32 ret = FALSE;
 319     PDB32 *pdb = PROCESS_Current();
 320
 321     SYSTEM_LOCK();
 322     if ((handle > 0) && (handle < pdb->handle_table->count))
 323     {
 324         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 325         if (entry->ptr)
 326         {
 327             if (flags)
 328                 *flags = (entry->access & RESERVED_ALL) >> RESERVED_SHIFT;
 329             ret = TRUE;
 330         }
 331     }
 332     SYSTEM_UNLOCK();
 333     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 334     return ret;
 335 }
 336
 337
 338 /*********************************************************************
 339  *           SetHandleInformation   (KERNEL32.653)
 340  */
 341 BOOL32 WINAPI SetHandleInformation( HANDLE32 handle, DWORD mask, DWORD flags )
 342 {
 343     BOOL32 ret = FALSE;
 344     PDB32 *pdb = PROCESS_Current();
 345
 346     mask  = (mask << RESERVED_SHIFT) & RESERVED_ALL;
 347     flags = (flags << RESERVED_SHIFT) & RESERVED_ALL;
 348     SYSTEM_LOCK();
 349     if ((handle > 0) && (handle < pdb->handle_table->count))
 350     {
 351         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 352         if (entry->ptr)
 353         {
 354             entry->access = (entry->access & ~mask) | flags;
 355             ret = TRUE;
 356         }
 357     }
 358     SYSTEM_UNLOCK();
 359     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 360     return ret;
 361 }
 362
 363
 364 /*********************************************************************
 365  *           DuplicateHandle   (KERNEL32.192)
 366  */
 367 BOOL32 WINAPI DuplicateHandle( HANDLE32 source_process, HANDLE32 source,
 368                                HANDLE32 dest_process, HANDLE32 *dest,
 369                                DWORD access, BOOL32 inherit, DWORD options )
 370 {
 371     PDB32 *src_pdb = NULL, *dst_pdb = NULL;
 372     K32OBJ *obj = NULL;
 373     BOOL32 ret = FALSE;
 374     HANDLE32 handle;
 375     int src_process, src_handle, dst_process, dst_handle;
 376
 377     SYSTEM_LOCK();
 378
 379     if (!(src_pdb = PROCESS_GetPtr( source_process, PROCESS_DUP_HANDLE, &src_process )))
 380         goto done;
 381     if (!(obj = HANDLE_GetObjPtr( src_pdb, source, K32OBJ_UNKNOWN, 0, &src_handle )))
 382         goto done;
 383
 384     /* Now that we are sure the source is valid, handle the options */
 385
 386     if (options & DUPLICATE_SAME_ACCESS)
 387         HANDLE_GetAccess( src_pdb, source, &access );
 388     if (options & DUPLICATE_CLOSE_SOURCE)
 389         HANDLE_Close( src_pdb, source );
 390
 391     /* And duplicate the handle in the dest process */
 392
 393     if (!(dst_pdb = PROCESS_GetPtr( dest_process, PROCESS_DUP_HANDLE, &dst_process )))
 394         goto done;
 395
 396     if ((src_process != -1) && (src_handle != -1) && (dst_process != -1))
 397         dst_handle = CLIENT_DuplicateHandle( src_process, src_handle, dst_process, -1,
 398                                              access, inherit, options );
 399     else
 400         dst_handle = -1;
 401
 402     if ((handle = HANDLE_Alloc( dst_pdb, obj, access, inherit,
 403                                 dst_handle )) != INVALID_HANDLE_VALUE32)
 404     {
 405         if (dest) *dest = handle;
 406         ret = TRUE;
 407     }
 408
 409 done:
 410     if (dst_pdb) K32OBJ_DecCount( &dst_pdb->header );
 411     if (obj) K32OBJ_DecCount( obj );
 412     if (src_pdb) K32OBJ_DecCount( &src_pdb->header );
 413     SYSTEM_UNLOCK();
 414     return ret;
 415 }