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_GetServerHandle
 196  *
 197  * Retrieve the server handle associated to an object.
 198  */
 199 int HANDLE_GetServerHandle( PDB32 *pdb, HANDLE32 handle,
 200                             K32OBJ_TYPE type, DWORD access )
 201 {
 202     int server_handle;
 203     K32OBJ *obj;
 204
 205     SYSTEM_LOCK();
 206     if ((obj = HANDLE_GetObjPtr( pdb, handle, type, access, &server_handle )))
 207         K32OBJ_DecCount( obj );
 208     else
 209         server_handle = -1;
 210     SYSTEM_UNLOCK();
 211     return server_handle;
 212 }
 213
 214
 215 /***********************************************************************
 216  *           HANDLE_SetObjPtr
 217  *
 218  * Change the object pointer of a handle, and increment the refcount.
 219  * Use with caution!
 220  */
 221 BOOL32 HANDLE_SetObjPtr( PDB32 *pdb, HANDLE32 handle, K32OBJ *ptr,
 222                          DWORD access )
 223 {
 224     BOOL32 ret = FALSE;
 225
 226     SYSTEM_LOCK();
 227     if ((handle > 0) && (handle < pdb->handle_table->count))
 228     {
 229         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 230         K32OBJ *old_ptr = entry->ptr;
 231         K32OBJ_IncCount( ptr );
 232         entry->access = access;
 233         entry->ptr    = ptr;
 234         if (old_ptr) K32OBJ_DecCount( old_ptr );
 235         ret = TRUE;
 236     }
 237     SYSTEM_UNLOCK();
 238     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 239     return ret;
 240 }
 241
 242
 243 /*********************************************************************
 244  *           HANDLE_GetAccess
 245  */
 246 static BOOL32 HANDLE_GetAccess( PDB32 *pdb, HANDLE32 handle, LPDWORD access )
 247 {
 248     BOOL32 ret = FALSE;
 249
 250     SYSTEM_LOCK();
 251     if ((handle > 0) && (handle < pdb->handle_table->count))
 252     {
 253         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 254         if (entry->ptr)
 255         {
 256             *access = entry->access & ~RESERVED_ALL;
 257             ret = TRUE;
 258         }
 259     }
 260     SYSTEM_UNLOCK();
 261     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 262     return ret;
 263 }
 264
 265
 266 /*********************************************************************
 267  *           HANDLE_Close
 268  */
 269 static BOOL32 HANDLE_Close( PDB32 *pdb, HANDLE32 handle )
 270 {
 271     BOOL32 ret = FALSE;
 272     K32OBJ *ptr;
 273
 274     if (HANDLE_IS_GLOBAL( handle ))
 275     {
 276         handle = HANDLE_GLOBAL_TO_LOCAL( handle );
 277         pdb = PROCESS_Initial();
 278     }
 279     SYSTEM_LOCK();
 280     if ((handle > 0) && (handle < pdb->handle_table->count))
 281     {
 282         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 283         if ((ptr = entry->ptr))
 284         {
 285             if (!(entry->access & RESERVED_CLOSE_PROTECT))
 286             {
 287                 entry->access = 0;
 288                 entry->ptr    = NULL;
 289                 if (entry->server != -1)
 290                     CLIENT_CloseHandle( entry->server );
 291                 K32OBJ_DecCount( ptr );
 292                 ret = TRUE;
 293             }
 294             /* FIXME: else SetLastError */
 295         }
 296     }
 297     SYSTEM_UNLOCK();
 298     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 299     return ret;
 300 }
 301
 302
 303 /*********************************************************************
 304  *           HANDLE_CloseAll
 305  *
 306  * Close all handles pointing to a given object (or all handles of the
 307  * process if the object is NULL)
 308  */
 309 void HANDLE_CloseAll( PDB32 *pdb, K32OBJ *obj )
 310 {
 311     HANDLE_ENTRY *entry;
 312     K32OBJ *ptr;
 313     HANDLE32 handle;
 314
 315     SYSTEM_LOCK();
 316     entry = pdb->handle_table->entries;
 317     for (handle = 0; handle < pdb->handle_table->count; handle++, entry++)
 318     {
 319         if (!(ptr = entry->ptr)) continue;  /* empty slot */
 320         if (obj && (ptr != obj)) continue;  /* not the right object */
 321         entry->access = 0;
 322         entry->ptr    = NULL;
 323         if (entry->server != -1) CLIENT_CloseHandle( entry->server );
 324         K32OBJ_DecCount( ptr );
 325     }
 326     SYSTEM_UNLOCK();
 327 }
 328
 329
 330 /*********************************************************************
 331  *           CloseHandle   (KERNEL32.23)
 332  */
 333 BOOL32 WINAPI CloseHandle( HANDLE32 handle )
 334 {
 335     return HANDLE_Close( PROCESS_Current(), handle );
 336 }
 337
 338
 339 /*********************************************************************
 340  *           GetHandleInformation   (KERNEL32.336)
 341  */
 342 BOOL32 WINAPI GetHandleInformation( HANDLE32 handle, LPDWORD flags )
 343 {
 344     BOOL32 ret = FALSE;
 345     PDB32 *pdb = PROCESS_Current();
 346
 347     SYSTEM_LOCK();
 348     if ((handle > 0) && (handle < pdb->handle_table->count))
 349     {
 350         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 351         if (entry->ptr)
 352         {
 353             if (flags)
 354                 *flags = (entry->access & RESERVED_ALL) >> RESERVED_SHIFT;
 355             ret = TRUE;
 356         }
 357     }
 358     SYSTEM_UNLOCK();
 359     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 360     return ret;
 361 }
 362
 363
 364 /*********************************************************************
 365  *           SetHandleInformation   (KERNEL32.653)
 366  */
 367 BOOL32 WINAPI SetHandleInformation( HANDLE32 handle, DWORD mask, DWORD flags )
 368 {
 369     BOOL32 ret = FALSE;
 370     PDB32 *pdb = PROCESS_Current();
 371
 372     mask  = (mask << RESERVED_SHIFT) & RESERVED_ALL;
 373     flags = (flags << RESERVED_SHIFT) & RESERVED_ALL;
 374     SYSTEM_LOCK();
 375     if ((handle > 0) && (handle < pdb->handle_table->count))
 376     {
 377         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle];
 378         if (entry->ptr)
 379         {
 380             entry->access = (entry->access & ~mask) | flags;
 381             ret = TRUE;
 382         }
 383     }
 384     SYSTEM_UNLOCK();
 385     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 386     return ret;
 387 }
 388
 389
 390 /*********************************************************************
 391  *           DuplicateHandle   (KERNEL32.192)
 392  */
 393 BOOL32 WINAPI DuplicateHandle( HANDLE32 source_process, HANDLE32 source,
 394                                HANDLE32 dest_process, HANDLE32 *dest,
 395                                DWORD access, BOOL32 inherit, DWORD options )
 396 {
 397     PDB32 *src_pdb = NULL, *dst_pdb = NULL;
 398     K32OBJ *obj = NULL;
 399     BOOL32 ret = FALSE;
 400     HANDLE32 handle;
 401     int src_process, src_handle, dst_process, dst_handle;
 402
 403     SYSTEM_LOCK();
 404
 405     if (!(src_pdb = PROCESS_GetPtr( source_process, PROCESS_DUP_HANDLE, &src_process )))
 406         goto done;
 407     if (!(obj = HANDLE_GetObjPtr( src_pdb, source, K32OBJ_UNKNOWN, 0, &src_handle )))
 408         goto done;
 409
 410     /* Now that we are sure the source is valid, handle the options */
 411
 412     if (options & DUPLICATE_SAME_ACCESS)
 413         HANDLE_GetAccess( src_pdb, source, &access );
 414     if (options & DUPLICATE_CLOSE_SOURCE)
 415         HANDLE_Close( src_pdb, source );
 416
 417     /* And duplicate the handle in the dest process */
 418
 419     if (!(dst_pdb = PROCESS_GetPtr( dest_process, PROCESS_DUP_HANDLE, &dst_process )))
 420         goto done;
 421
 422     if ((src_process != -1) && (src_handle != -1) && (dst_process != -1))
 423         dst_handle = CLIENT_DuplicateHandle( src_process, src_handle, dst_process, -1,
 424                                              access, inherit, options );
 425     else
 426         dst_handle = -1;
 427
 428     if ((handle = HANDLE_Alloc( dst_pdb, obj, access, inherit,
 429                                 dst_handle )) != INVALID_HANDLE_VALUE32)
 430     {
 431         if (dest) *dest = handle;
 432         ret = TRUE;
 433     }
 434
 435 done:
 436     if (dst_pdb) K32OBJ_DecCount( &dst_pdb->header );
 437     if (obj) K32OBJ_DecCount( obj );
 438     if (src_pdb) K32OBJ_DecCount( &src_pdb->header );
 439     SYSTEM_UNLOCK();
 440     return ret;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           ConvertToGlobalHandle              (KERNEL32)
 446  */
 447 HANDLE32 WINAPI ConvertToGlobalHandle(HANDLE32 hSrc)
 448 {
 449     int src_handle, dst_handle;
 450     HANDLE32 handle;
 451     K32OBJ *obj = NULL;
 452     DWORD access;
 453
 454     if (HANDLE_IS_GLOBAL(hSrc))
 455         return hSrc;
 456
 457     if (!(obj = HANDLE_GetObjPtr( PROCESS_Current(), hSrc, K32OBJ_UNKNOWN, 0, &src_handle )))
 458         return 0;
 459
 460     HANDLE_GetAccess( PROCESS_Current(), hSrc, &access );
 461
 462     if (src_handle != -1)
 463         dst_handle = CLIENT_DuplicateHandle( GetCurrentProcess(), src_handle, -1, -1, 0, FALSE,
 464                                              DUP_HANDLE_MAKE_GLOBAL | DUP_HANDLE_SAME_ACCESS );
 465     else
 466         dst_handle = -1;
 467
 468     if ((handle = HANDLE_Alloc( PROCESS_Initial(), obj, access, FALSE,
 469                                 dst_handle )) != INVALID_HANDLE_VALUE32)
 470         handle = HANDLE_LOCAL_TO_GLOBAL(handle);
 471     else
 472         handle = 0;
 473
 474     CloseHandle( hSrc );
 475     return handle;
 476 }