scheduler/process.c

   1 /*
   2  * Win32 processes
   3  *
   4  * Copyright 1996 Alexandre Julliard
   5  */
   6
   7 #include <assert.h>
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include "process.h"
  12 #include "module.h"
  13 #include "file.h"
  14 #include "heap.h"
  15 #include "task.h"
  16 #include "ldt.h"
  17 #include "thread.h"
  18 #include "winerror.h"
  19 #include "pe_image.h"
  20
  21 #define HTABLE_SIZE  0x30  /* Handle table initial size */
  22 #define HTABLE_INC   0x10  /* Handle table increment */
  23
  24 static BOOL32 PROCESS_Signaled( K32OBJ *obj, DWORD thread_id );
  25 static BOOL32 PROCESS_Satisfied( K32OBJ *obj, DWORD thread_id );
  26 static void PROCESS_AddWait( K32OBJ *obj, DWORD thread_id );
  27 static void PROCESS_RemoveWait( K32OBJ *obj, DWORD thread_id );
  28 static void PROCESS_Destroy( K32OBJ *obj );
  29
  30 const K32OBJ_OPS PROCESS_Ops =
  31 {
  32     PROCESS_Signaled,    /* signaled */
  33     PROCESS_Satisfied,   /* satisfied */
  34     PROCESS_AddWait,     /* add_wait */
  35     PROCESS_RemoveWait,  /* remove_wait */
  36     PROCESS_Destroy      /* destroy */
  37 };
  38
  39
  40 /***********************************************************************
  41  *           PROCESS_AllocHandleTable
  42  */
  43 static HANDLE_TABLE *PROCESS_AllocHandleTable( PDB32 *process )
  44 {
  45     HANDLE_TABLE *table = HeapAlloc( process->system_heap, HEAP_ZERO_MEMORY,
  46                                      sizeof(HANDLE_TABLE) +
  47                                      (HTABLE_SIZE-1) * sizeof(HANDLE_ENTRY) );
  48     if (!table) return NULL;
  49     table->count = HTABLE_SIZE;
  50     return table;
  51 }
  52
  53
  54 /***********************************************************************
  55  *           PROCESS_GrowHandleTable
  56  */
  57 static BOOL32 PROCESS_GrowHandleTable( PDB32 *process )
  58 {
  59     HANDLE_TABLE *table;
  60     SYSTEM_LOCK();
  61     table = process->handle_table;
  62     table = HeapReAlloc( process->system_heap,
  63                          HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE, table,
  64                          sizeof(HANDLE_TABLE) +
  65                          (table->count+HTABLE_INC-1) * sizeof(HANDLE_ENTRY) );
  66     if (table)
  67     {
  68         table->count += HTABLE_INC;
  69         process->handle_table = table;
  70     }
  71     SYSTEM_UNLOCK();
  72     return (table != NULL);
  73 }
  74
  75
  76 /***********************************************************************
  77  *           PROCESS_Current
  78  */
  79 PDB32 *PROCESS_Current(void)
  80 {
  81     return THREAD_Current()->process;
  82 }
  83
  84
  85 /***********************************************************************
  86  *           PROCESS_IdToPDB
  87  *
  88  * Convert a process id to a PDB, making sure it is valid.
  89  */
  90 PDB32 *PROCESS_IdToPDB( DWORD id )
  91 {
  92     PDB32 *pdb;
  93
  94     if (!id) return PROCESS_Current();
  95     pdb = PROCESS_ID_TO_PDB( id );
  96     if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS ))
  97     {
  98         SetLastError( ERROR_INVALID_PARAMETER );
  99         return NULL;
 100     }
 101     return pdb;
 102 }
 103
 104
 105 /***********************************************************************
 106  *           PROCESS_AllocHandle
 107  *
 108  * Allocate a handle for a kernel object and increment its refcount.
 109  */
 110 HANDLE32 PROCESS_AllocHandle( K32OBJ *ptr, DWORD flags )
 111 {
 112     HANDLE32 h;
 113     HANDLE_ENTRY *entry;
 114     PDB32 *pdb = PROCESS_Current();
 115
 116     assert( ptr );
 117     SYSTEM_LOCK();
 118     K32OBJ_IncCount( ptr );
 119     entry = pdb->handle_table->entries;
 120     for (h = 0; h < pdb->handle_table->count; h++, entry++)
 121         if (!entry->ptr) break;
 122     if ((h < pdb->handle_table->count) || PROCESS_GrowHandleTable( pdb ))
 123     {
 124         entry = &pdb->handle_table->entries[h];
 125         entry->flags = flags;
 126         entry->ptr   = ptr;
 127         SYSTEM_UNLOCK();
 128         return h + 1;  /* Avoid handle 0 */
 129     }
 130     K32OBJ_DecCount( ptr );
 131     SYSTEM_UNLOCK();
 132     SetLastError( ERROR_OUTOFMEMORY );
 133     return INVALID_HANDLE_VALUE32;
 134 }
 135
 136
 137 /***********************************************************************
 138  *           PROCESS_GetObjPtr
 139  *
 140  * Retrieve a pointer to a kernel object and increments its reference count.
 141  * The refcount must be decremented when the pointer is no longer used.
 142  */
 143 K32OBJ *PROCESS_GetObjPtr( HANDLE32 handle, K32OBJ_TYPE type )
 144 {
 145     K32OBJ *ptr = NULL;
 146     PDB32 *pdb = PROCESS_Current();
 147
 148     SYSTEM_LOCK();
 149
 150     if ((handle > 0) && (handle <= pdb->handle_table->count))
 151         ptr = pdb->handle_table->entries[handle - 1].ptr;
 152     else if (handle == 0x7fffffff) ptr = &pdb->header;
 153
 154     if (ptr && ((type == K32OBJ_UNKNOWN) || (ptr->type == type)))
 155         K32OBJ_IncCount( ptr );
 156     else ptr = NULL;
 157
 158     SYSTEM_UNLOCK();
 159     if (!ptr) SetLastError( ERROR_INVALID_HANDLE );
 160     return ptr;
 161 }
 162
 163
 164 /***********************************************************************
 165  *           PROCESS_SetObjPtr
 166  *
 167  * Change the object pointer of a handle, and increment the refcount.
 168  * Use with caution!
 169  */
 170 BOOL32 PROCESS_SetObjPtr( HANDLE32 handle, K32OBJ *ptr, DWORD flags )
 171 {
 172     BOOL32 ret = TRUE;
 173     K32OBJ *old_ptr = NULL;
 174     PDB32 *pdb = PROCESS_Current();
 175
 176     SYSTEM_LOCK();
 177     if ((handle > 0) && (handle <= pdb->handle_table->count))
 178     {
 179         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 180         old_ptr = entry->ptr;
 181         K32OBJ_IncCount( ptr );
 182         entry->flags = flags;
 183         entry->ptr   = ptr;
 184     }
 185     else
 186     {
 187         SetLastError( ERROR_INVALID_HANDLE );
 188         ret = FALSE;
 189     }
 190     if (old_ptr) K32OBJ_DecCount( old_ptr );
 191     SYSTEM_UNLOCK();
 192     return ret;
 193 }
 194
 195
 196 /*********************************************************************
 197  *           CloseHandle   (KERNEL32.23)
 198  */
 199 BOOL32 WINAPI CloseHandle( HANDLE32 handle )
 200 {
 201     BOOL32 ret = FALSE;
 202     K32OBJ *ptr = NULL;
 203     PDB32 *pdb = PROCESS_Current();
 204
 205     SYSTEM_LOCK();
 206     if ((handle > 0) && (handle <= pdb->handle_table->count))
 207     {
 208         HANDLE_ENTRY *entry = &pdb->handle_table->entries[handle-1];
 209         if ((ptr = entry->ptr))
 210         {
 211             entry->flags = 0;
 212             entry->ptr   = NULL;
 213             ret = TRUE;
 214         }
 215     }
 216     if (ptr) K32OBJ_DecCount( ptr );
 217     SYSTEM_UNLOCK();
 218     if (!ret) SetLastError( ERROR_INVALID_HANDLE );
 219     return ret;
 220 }
 221
 222
 223 static int pstr_cmp( const void *ps1, const void *ps2 )
 224 {
 225     return lstrcmpi32A( *(LPSTR *)ps1, *(LPSTR *)ps2 );
 226 }
 227
 228 /***********************************************************************
 229  *           PROCESS_FillEnvDB
 230  */
 231 static BOOL32 PROCESS_FillEnvDB( PDB32 *pdb, TDB *pTask, LPCSTR cmd_line )
 232 {
 233     LPSTR p, env;
 234     INT32 count = 0;
 235     LPSTR *pp, *array = NULL;
 236
 237     /* Copy the Win16 environment, sorting it in the process */
 238
 239     env = p = GlobalLock16( pTask->pdb.environment );
 240     for (p = env; *p; p += strlen(p) + 1) count++;
 241     pdb->env_db->env_size = (p - env) + 1;
 242     pdb->env_db->environ = HeapAlloc( pdb->heap, 0, pdb->env_db->env_size );
 243     if (!pdb->env_db->environ) goto error;
 244     if (!(array = HeapAlloc( pdb->heap, 0, count * sizeof(array[0]) )))
 245         goto error;
 246     for (p = env, pp = array; *p; p += strlen(p) + 1) *pp++ = p;
 247     qsort( array, count, sizeof(LPSTR), pstr_cmp );
 248     p = pdb->env_db->environ;
 249     for (pp = array; count; count--, pp++)
 250     {
 251         strcpy( p, *pp );
 252         p += strlen(p) + 1;
 253     }
 254     *p = '\0';
 255     HeapFree( pdb->heap, 0, array );
 256     array = NULL;
 257
 258     /* Copy the command line */
 259     /* Fixme: Here we rely on the hack that loader/module.c put's the unprocessed
 260        commandline after the processed one in Pascal notation.
 261        We may access Null data if we get called another way.
 262        If we have a real CreateProcess sometimes, the problem to get an unrestricted
 263        commandline will go away and we won't need that hack any longer
 264        */
 265     if (!(pdb->env_db->cmd_line =
 266           HEAP_strdupA( pdb->heap, 0, cmd_line + (unsigned char)cmd_line[0] + 2)))
 267         goto error;
 268
 269     return TRUE;
 270
 271 error:
 272     if (pdb->env_db->cmd_line) HeapFree( pdb->heap, 0, pdb->env_db->cmd_line );
 273     if (array) HeapFree( pdb->heap, 0, array );
 274     if (pdb->env_db->environ) HeapFree( pdb->heap, 0, pdb->env_db->environ );
 275     return FALSE;
 276 }
 277
 278
 279 /***********************************************************************
 280  *           PROCESS_FreePDB
 281  *
 282  * Free a PDB and all associated storage.
 283  */
 284 static void PROCESS_FreePDB( PDB32 *pdb )
 285 {
 286     pdb->header.type = K32OBJ_UNKNOWN;
 287     if (pdb->heap) HeapDestroy( pdb->heap );
 288     if (pdb->handle_table) HeapFree( pdb->system_heap, 0, pdb->handle_table );
 289     if (pdb->load_done_evt) K32OBJ_DecCount( pdb->load_done_evt );
 290     if (pdb->event) K32OBJ_DecCount( pdb->event );
 291     DeleteCriticalSection( &pdb->crit_section );
 292     HeapFree( SystemHeap, 0, pdb );
 293 }
 294
 295
 296 /***********************************************************************
 297  *           PROCESS_CreatePDB
 298  *
 299  * Allocate and fill a PDB structure.
 300  */
 301 static PDB32 *PROCESS_CreatePDB( PDB32 *parent )
 302 {
 303     PDB32 *pdb = HeapAlloc( SystemHeap, HEAP_ZERO_MEMORY, sizeof(PDB32) );
 304
 305     if (!pdb) return NULL;
 306     pdb->header.type     = K32OBJ_PROCESS;
 307     pdb->header.refcount = 1;
 308     pdb->exit_code       = 0x103; /* STILL_ACTIVE */
 309     pdb->threads         = 1;
 310     pdb->running_threads = 1;
 311     pdb->ring0_threads   = 1;
 312     pdb->system_heap     = SystemHeap;
 313     pdb->parent          = parent;
 314     pdb->group           = pdb;
 315     pdb->priority        = 8;  /* Normal */
 316
 317     InitializeCriticalSection( &pdb->crit_section );
 318
 319     /* Allocate the events */
 320
 321     if (!(pdb->event = EVENT_Create( TRUE, FALSE ))) goto error;
 322     if (!(pdb->load_done_evt = EVENT_Create( TRUE, FALSE ))) goto error;
 323
 324     /* Allocate the handle table */
 325
 326     if (!(pdb->handle_table = PROCESS_AllocHandleTable( pdb ))) goto error;
 327     return pdb;
 328
 329 error:
 330     PROCESS_FreePDB( pdb );
 331     return NULL;
 332 }
 333
 334
 335 /***********************************************************************
 336  *           PROCESS_Init
 337  */
 338 BOOL32 PROCESS_Init(void)
 339 {
 340     PDB32 *pdb;
 341     THDB *thdb;
 342
 343     if (!(pdb = PROCESS_CreatePDB( NULL ))) return FALSE;
 344     if (!(thdb = THREAD_Create( pdb, 0, NULL, NULL ))) return FALSE;
 345     SET_CUR_THREAD( thdb );
 346     return TRUE;
 347 }
 348
 349
 350 /***********************************************************************
 351  *           PROCESS_Create
 352  *
 353  * Create a new process database and associated info.
 354  */
 355 PDB32 *PROCESS_Create( TDB *pTask, LPCSTR cmd_line )
 356 {
 357     DWORD size, commit;
 358     NE_MODULE *pModule;
 359     PDB32 *pdb = PROCESS_CreatePDB( PROCESS_Current() );
 360
 361     if (!pdb) return NULL;
 362     if (!(pModule = MODULE_GetPtr( pTask->hModule ))) return 0;
 363
 364     /* Create the heap */
 365
 366     if (pModule->module32)
 367     {
 368         size  = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapReserve;
 369         commit = PE_HEADER(pModule->module32)->OptionalHeader.SizeOfHeapCommit;
 370     }
 371     else
 372     {
 373         size = 0x10000;
 374         commit = 0;
 375     }
 376     if (!(pdb->heap = HeapCreate( HEAP_GROWABLE, size, commit ))) goto error;
 377     pdb->heap_list = pdb->heap;
 378
 379     if (!(pdb->env_db = HeapAlloc(pdb->heap, HEAP_ZERO_MEMORY, sizeof(ENVDB))))
 380         goto error;
 381     if (!PROCESS_FillEnvDB( pdb, pTask, cmd_line )) goto error;
 382     return pdb;
 383
 384 error:
 385     PROCESS_FreePDB( pdb );
 386     return NULL;
 387 }
 388
 389
 390 /***********************************************************************
 391  *           PROCESS_Signaled
 392  */
 393 static BOOL32 PROCESS_Signaled( K32OBJ *obj, DWORD thread_id )
 394 {
 395     PDB32 *pdb = (PDB32 *)obj;
 396     assert( obj->type == K32OBJ_PROCESS );
 397     return K32OBJ_OPS( pdb->event )->signaled( pdb->event, thread_id );
 398 }
 399
 400
 401 /***********************************************************************
 402  *           PROCESS_Satisfied
 403  *
 404  * Wait on this object has been satisfied.
 405  */
 406 static BOOL32 PROCESS_Satisfied( K32OBJ *obj, DWORD thread_id )
 407 {
 408     PDB32 *pdb = (PDB32 *)obj;
 409     assert( obj->type == K32OBJ_PROCESS );
 410     return K32OBJ_OPS( pdb->event )->satisfied( pdb->event, thread_id );
 411 }
 412
 413
 414 /***********************************************************************
 415  *           PROCESS_AddWait
 416  *
 417  * Add thread to object wait queue.
 418  */
 419 static void PROCESS_AddWait( K32OBJ *obj, DWORD thread_id )
 420 {
 421     PDB32 *pdb = (PDB32 *)obj;
 422     assert( obj->type == K32OBJ_PROCESS );
 423     return K32OBJ_OPS( pdb->event )->add_wait( pdb->event, thread_id );
 424 }
 425
 426
 427 /***********************************************************************
 428  *           PROCESS_RemoveWait
 429  *
 430  * Remove thread from object wait queue.
 431  */
 432 static void PROCESS_RemoveWait( K32OBJ *obj, DWORD thread_id )
 433 {
 434     PDB32 *pdb = (PDB32 *)obj;
 435     assert( obj->type == K32OBJ_PROCESS );
 436     return K32OBJ_OPS( pdb->event )->remove_wait( pdb->event, thread_id );
 437 }
 438
 439
 440 /***********************************************************************
 441  *           PROCESS_Destroy
 442  */
 443 static void PROCESS_Destroy( K32OBJ *ptr )
 444 {
 445     PDB32 *pdb = (PDB32 *)ptr;
 446     HANDLE32 handle;
 447     assert( ptr->type == K32OBJ_PROCESS );
 448
 449     /* Close all handles */
 450     for (handle = 0; handle < pdb->handle_table->count; handle++)
 451         if (pdb->handle_table->entries[handle].ptr) CloseHandle( handle );
 452
 453     /* Free everything */
 454
 455     ptr->type = K32OBJ_UNKNOWN;
 456     PROCESS_FreePDB( pdb );
 457 }
 458
 459
 460 /***********************************************************************
 461  *           ExitProcess   (KERNEL32.100)
 462  */
 463 void WINAPI ExitProcess( DWORD status )
 464 {
 465     PDB32 *pdb = PROCESS_Current();
 466
 467     SYSTEM_LOCK();
 468     /* FIXME: should kill all running threads of this process */
 469     pdb->exit_code = status;
 470     EVENT_Set( pdb->event );
 471     SYSTEM_UNLOCK();
 472
 473     __RESTORE_ES;  /* Necessary for Pietrek's showseh example program */
 474     TASK_KillCurrentTask( status );
 475 }
 476
 477
 478 /***********************************************************************
 479  *           GetCurrentProcess   (KERNEL32.198)
 480  */
 481 HANDLE32 WINAPI GetCurrentProcess(void)
 482 {
 483     return 0x7fffffff;
 484 }
 485
 486
 487 /*********************************************************************
 488  *           OpenProcess   (KERNEL32.543)
 489  */
 490 HANDLE32 WINAPI OpenProcess( DWORD access, BOOL32 inherit, DWORD id )
 491 {
 492     PDB32 *pdb = PROCESS_ID_TO_PDB(id);
 493     if (!K32OBJ_IsValid( &pdb->header, K32OBJ_PROCESS ))
 494     {
 495         SetLastError( ERROR_INVALID_HANDLE );
 496         return 0;
 497     }
 498     return PROCESS_AllocHandle( &pdb->header, 0 );
 499 }
 500
 501
 502 /***********************************************************************
 503  *           GetCurrentProcessId   (KERNEL32.199)
 504  */
 505 DWORD WINAPI GetCurrentProcessId(void)
 506 {
 507     PDB32 *pdb = PROCESS_Current();
 508     return PDB_TO_PROCESS_ID( pdb );
 509 }
 510
 511
 512 /***********************************************************************
 513  *      GetEnvironmentStrings32A   (KERNEL32.210) (KERNEL32.211)
 514  */
 515 LPSTR WINAPI GetEnvironmentStrings32A(void)
 516 {
 517     PDB32 *pdb = PROCESS_Current();
 518     return pdb->env_db->environ;
 519 }
 520
 521
 522 /***********************************************************************
 523  *      GetEnvironmentStrings32W   (KERNEL32.212)
 524  */
 525 LPWSTR WINAPI GetEnvironmentStrings32W(void)
 526 {
 527     INT32 size;
 528     LPWSTR ret, pW;
 529     LPSTR pA;
 530     PDB32 *pdb = PROCESS_Current();
 531
 532     size = HeapSize( GetProcessHeap(), 0, pdb->env_db->environ );
 533     if (!(ret = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
 534         return NULL;
 535     pA = pdb->env_db->environ;
 536     pW = ret;
 537     while (*pA)
 538     {
 539         lstrcpyAtoW( pW, pA );
 540         size = strlen(pA);
 541         pA += size + 1;
 542         pW += size + 1;
 543     }
 544     *pW = 0;
 545     return ret;
 546 }
 547
 548
 549 /***********************************************************************
 550  *           FreeEnvironmentStrings32A   (KERNEL32.141)
 551  */
 552 BOOL32 WINAPI FreeEnvironmentStrings32A( LPSTR ptr )
 553 {
 554     PDB32 *pdb = PROCESS_Current();
 555     if (ptr != pdb->env_db->environ)
 556     {
 557         SetLastError( ERROR_INVALID_PARAMETER );
 558         return FALSE;
 559     }
 560     return TRUE;
 561 }
 562
 563
 564 /***********************************************************************
 565  *           FreeEnvironmentStrings32W   (KERNEL32.142)
 566  */
 567 BOOL32 WINAPI FreeEnvironmentStrings32W( LPWSTR ptr )
 568 {
 569     return HeapFree( GetProcessHeap(), 0, ptr );
 570 }
 571
 572
 573 /***********************************************************************
 574  *          GetEnvironmentVariable32A   (KERNEL32.213)
 575  */
 576 DWORD WINAPI GetEnvironmentVariable32A( LPCSTR name, LPSTR value, DWORD size )
 577 {
 578     LPSTR p;
 579     INT32 len, res;
 580
 581     p = PROCESS_Current()->env_db->environ;
 582     if (!name || !*name)
 583     {
 584         SetLastError( ERROR_INVALID_PARAMETER );
 585         return 0;
 586     }
 587     len = strlen(name);
 588     while (*p)
 589     {
 590         res = lstrncmpi32A( name, p, len );
 591         if (res < 0) goto not_found;
 592         if (!res && (p[len] == '=')) break;
 593         p += strlen(p) + 1;
 594     }
 595     if (!*p) goto not_found;
 596     if (value) lstrcpyn32A( value, p + len + 1, size );
 597     len = strlen(p);
 598     /* According to the Win32 docs, if there is not enough room, return
 599      * the size required to hold the string plus the terminating null
 600      */
 601     if (size <= len) len++;
 602     return len;
 603
 604 not_found:
 605     return 0;  /* FIXME: SetLastError */
 606 }
 607
 608
 609 /***********************************************************************
 610  *           GetEnvironmentVariable32W   (KERNEL32.214)
 611  */
 612 DWORD WINAPI GetEnvironmentVariable32W( LPCWSTR nameW, LPWSTR valW, DWORD size)
 613 {
 614     LPSTR name = HEAP_strdupWtoA( GetProcessHeap(), 0, nameW );
 615     LPSTR val  = HeapAlloc( GetProcessHeap(), 0, size );
 616     DWORD res  = GetEnvironmentVariable32A( name, val, size );
 617     HeapFree( GetProcessHeap(), 0, name );
 618     if (valW) lstrcpynAtoW( valW, val, size );
 619     HeapFree( GetProcessHeap(), 0, val );
 620     return res;
 621 }
 622
 623
 624 /***********************************************************************
 625  *           SetEnvironmentVariable32A   (KERNEL32.484)
 626  */
 627 BOOL32 WINAPI SetEnvironmentVariable32A( LPCSTR name, LPCSTR value )
 628 {
 629     INT32 size, len, res;
 630     LPSTR p, env, new_env;
 631     PDB32 *pdb = PROCESS_Current();
 632
 633     env = p = pdb->env_db->environ;
 634
 635     /* Find a place to insert the string */
 636
 637     res = -1;
 638     len = strlen(name);
 639     while (*p)
 640     {
 641         res = lstrncmpi32A( name, p, len );
 642         if (res < 0) break;
 643         if (!res && (p[len] == '=')) break;
 644         res = 1;
 645         p += strlen(p) + 1;
 646     }
 647     if (!value && res)  /* Value to remove doesn't exist already */
 648         return FALSE;
 649
 650     /* Realloc the buffer */
 651
 652     len = value ? strlen(name) + strlen(value) + 2 : 0;
 653     if (!res) len -= strlen(p) + 1;  /* The name already exists */
 654     size = pdb->env_db->env_size + len;
 655     if (len < 0)
 656     {
 657         LPSTR next = p + strlen(p) + 1;
 658         memmove( next + len, next, pdb->env_db->env_size - (next - env) );
 659     }
 660     if (!(new_env = HeapReAlloc( GetProcessHeap(), 0, env, size )))
 661         return FALSE;
 662     p = new_env + (p - env);
 663     if (len > 0) memmove( p + len, p, pdb->env_db->env_size - (p-new_env) );
 664
 665     /* Set the new string */
 666
 667     if (value)
 668     {
 669         strcpy( p, name );
 670         strcat( p, "=" );
 671         strcat( p, value );
 672     }
 673     pdb->env_db->env_size = size;
 674     pdb->env_db->environ  = new_env;
 675     return TRUE;
 676 }
 677
 678
 679 /***********************************************************************
 680  *           SetEnvironmentVariable32W   (KERNEL32.485)
 681  */
 682 BOOL32 WINAPI SetEnvironmentVariable32W( LPCWSTR name, LPCWSTR value )
 683 {
 684     LPSTR nameA  = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
 685     LPSTR valueA = HEAP_strdupWtoA( GetProcessHeap(), 0, value );
 686     BOOL32 ret = SetEnvironmentVariable32A( nameA, valueA );
 687     HeapFree( GetProcessHeap(), 0, nameA );
 688     HeapFree( GetProcessHeap(), 0, valueA );
 689     return ret;
 690 }
 691
 692
 693 /***********************************************************************
 694  *           ExpandEnvironmentVariablesA   (KERNEL32.103)
 695  */
 696 DWORD WINAPI ExpandEnvironmentStrings32A( LPCSTR src, LPSTR dst, DWORD len)
 697 {
 698         LPCSTR s;
 699         LPSTR d;
 700         HANDLE32        heap = GetProcessHeap();
 701         LPSTR           xdst = HeapAlloc(heap,0,10);
 702         DWORD           cursize = 10;
 703         DWORD           ret;
 704
 705         fprintf(stderr,"ExpandEnvironmentStrings32A(%s)\n",src);
 706         s=src;
 707         d=xdst;
 708         memset(dst,'\0',len);
 709 #define CHECK_FREE(n)  {                                \
 710         DWORD   _needed = (n);                          \
 711                                                         \
 712         while (cursize-(d-xdst)<_needed) {              \
 713                 DWORD   ind = d-xdst;                   \
 714                                                         \
 715                 cursize+=100;                           \
 716                 xdst=(LPSTR)HeapReAlloc(heap,0,xdst,cursize);\
 717                 d = xdst+ind;                           \
 718         }                                               \
 719 }
 720
 721         while (*s) {
 722                 if (*s=='%') {
 723                         LPCSTR end;
 724
 725                         end = s;do { end++; } while (*end && *end!='%');
 726                         if (*end=='%') {
 727                                 LPSTR   x = HeapAlloc(heap,0,end-s+1);
 728                                 char    buf[2];
 729
 730                                 lstrcpyn32A(x,s+1,end-s);
 731                                 x[end-s]=0;
 732
 733                                 /* put expanded variable directly into
 734                                  * destination string, so we don't have
 735                                  * to use temporary buffers.
 736                                  */
 737                                 ret = GetEnvironmentVariable32A(x,buf,2);
 738                                 CHECK_FREE(ret+2);
 739                                 ret = GetEnvironmentVariable32A(x,d,cursize-(d-xdst));
 740                                 if (ret) {
 741                                         d+=strlen(d);
 742                                         s=end;
 743                                 } else {
 744                                         CHECK_FREE(strlen(x)+2);
 745                                         *d++='%';
 746                                         lstrcpy32A(d,x);
 747                                         d+=strlen(x);
 748                                         *d++='%';
 749                                 }
 750                                 HeapFree(heap,0,x);
 751                         } else
 752                                 *d++=*s;
 753
 754                         s++;
 755                 } else {
 756                         CHECK_FREE(1);
 757                         *d++=*s++;
 758                 }
 759         }
 760         *d      = '\0';
 761         ret     = lstrlen32A(xdst)+1;
 762         if (d-xdst<len)
 763                 lstrcpy32A(dst,xdst);
 764         HeapFree(heap,0,xdst);
 765         return ret;
 766 }
 767
 768 /***********************************************************************
 769  *           ExpandEnvironmentVariablesA   (KERNEL32.104)
 770  */
 771 DWORD WINAPI ExpandEnvironmentStrings32W( LPCWSTR src, LPWSTR dst, DWORD len)
 772 {
 773         HANDLE32        heap = GetProcessHeap();
 774         LPSTR           srcA = HEAP_strdupWtoA(heap,0,src);
 775         LPSTR           dstA = HeapAlloc(heap,0,len);
 776         DWORD           ret = ExpandEnvironmentStrings32A(srcA,dstA,len);
 777
 778         lstrcpyAtoW(dst,dstA);
 779         HeapFree(heap,0,dstA);
 780         HeapFree(heap,0,srcA);
 781         return ret;
 782 }
 783
 784 /***********************************************************************
 785  *           GetProcessHeap    (KERNEL32.259)
 786  */
 787 HANDLE32 WINAPI GetProcessHeap(void)
 788 {
 789     PDB32 *pdb = PROCESS_Current();
 790     return pdb->heap ? pdb->heap : SystemHeap;
 791 }
 792
 793
 794 /***********************************************************************
 795  *           GetThreadLocale    (KERNEL32.295)
 796  */
 797 LCID WINAPI GetThreadLocale(void)
 798 {
 799     return PROCESS_Current()->locale;
 800 }
 801
 802
 803 /***********************************************************************
 804  *           SetPriorityClass   (KERNEL32.503)
 805  */
 806 BOOL32 WINAPI SetPriorityClass( HANDLE32 hprocess, DWORD priorityclass )
 807 {
 808     PDB32       *pdb;
 809
 810     pdb = (PDB32*)PROCESS_GetObjPtr(hprocess,K32OBJ_PROCESS);
 811     if (!pdb) return FALSE;
 812     switch (priorityclass)
 813     {
 814     case NORMAL_PRIORITY_CLASS:
 815         pdb->priority = 0x00000008;
 816         break;
 817     case IDLE_PRIORITY_CLASS:
 818         pdb->priority = 0x00000004;
 819         break;
 820     case HIGH_PRIORITY_CLASS:
 821         pdb->priority = 0x0000000d;
 822         break;
 823     case REALTIME_PRIORITY_CLASS:
 824         pdb->priority = 0x00000018;
 825         break;
 826     default:
 827         fprintf(stderr,"SetPriorityClass: unknown priority class %ld\n",priorityclass);
 828         break;
 829     }
 830     K32OBJ_DecCount((K32OBJ*)pdb);
 831     return TRUE;
 832 }
 833
 834
 835 /***********************************************************************
 836  *           GetPriorityClass   (KERNEL32.250)
 837  */
 838 DWORD WINAPI GetPriorityClass(HANDLE32 hprocess)
 839 {
 840     PDB32       *pdb;
 841     DWORD       ret;
 842
 843     pdb = (PDB32*)PROCESS_GetObjPtr(hprocess,K32OBJ_PROCESS);
 844     ret = 0;
 845     if (pdb)
 846     {
 847         switch (pdb->priority)
 848         {
 849         case 0x00000008:
 850             ret = NORMAL_PRIORITY_CLASS;
 851             break;
 852         case 0x00000004:
 853             ret = IDLE_PRIORITY_CLASS;
 854             break;
 855         case 0x0000000d:
 856             ret = HIGH_PRIORITY_CLASS;
 857             break;
 858         case 0x00000018:
 859             ret = REALTIME_PRIORITY_CLASS;
 860             break;
 861         default:
 862             fprintf(stderr,"GetPriorityClass: unknown priority %ld\n",pdb->priority);
 863         }
 864         K32OBJ_DecCount((K32OBJ*)pdb);
 865     }
 866     return ret;
 867 }
 868
 869
 870 /***********************************************************************
 871  *           GetStdHandle    (KERNEL32.276)
 872  *
 873  * FIXME: These should be allocated when a console is created, or inherited
 874  *        from the parent.
 875  */
 876 HANDLE32 WINAPI GetStdHandle( DWORD std_handle )
 877 {
 878     HFILE32 hFile;
 879     int fd;
 880     PDB32 *pdb = PROCESS_Current();
 881
 882     switch(std_handle)
 883     {
 884     case STD_INPUT_HANDLE:
 885         if (pdb->env_db->hStdin) return pdb->env_db->hStdin;
 886         fd = 0;
 887         break;
 888     case STD_OUTPUT_HANDLE:
 889         if (pdb->env_db->hStdout) return pdb->env_db->hStdout;
 890         fd = 1;
 891         break;
 892     case STD_ERROR_HANDLE:
 893         if (pdb->env_db->hStderr) return pdb->env_db->hStderr;
 894         fd = 2;
 895         break;
 896     default:
 897         SetLastError( ERROR_INVALID_PARAMETER );
 898         return INVALID_HANDLE_VALUE32;
 899     }
 900     hFile = FILE_DupUnixHandle( fd );
 901     if (hFile != HFILE_ERROR32)
 902     {
 903         FILE_SetFileType( hFile, FILE_TYPE_CHAR );
 904         switch(std_handle)
 905         {
 906         case STD_INPUT_HANDLE:  pdb->env_db->hStdin  = hFile; break;
 907         case STD_OUTPUT_HANDLE: pdb->env_db->hStdout = hFile; break;
 908         case STD_ERROR_HANDLE:  pdb->env_db->hStderr = hFile; break;
 909         }
 910     }
 911     return hFile;
 912 }
 913
 914
 915 /***********************************************************************
 916  *           SetStdHandle    (KERNEL32.506)
 917  */
 918 BOOL32 WINAPI SetStdHandle( DWORD std_handle, HANDLE32 handle )
 919 {
 920     PDB32 *pdb = PROCESS_Current();
 921     switch(std_handle)
 922     {
 923     case STD_INPUT_HANDLE:
 924         pdb->env_db->hStdin = handle;
 925         return TRUE;
 926     case STD_OUTPUT_HANDLE:
 927         pdb->env_db->hStdout = handle;
 928         return TRUE;
 929     case STD_ERROR_HANDLE:
 930         pdb->env_db->hStderr = handle;
 931         return TRUE;
 932     }
 933     SetLastError( ERROR_INVALID_PARAMETER );
 934     return FALSE;
 935 }
 936
 937 /***********************************************************************
 938  *           GetProcessVersion    (KERNEL32)
 939  */
 940 DWORD WINAPI GetProcessVersion( DWORD processid )
 941 {
 942     TDB *pTask;
 943     PDB32 *pdb = PROCESS_IdToPDB( processid );
 944
 945     if (!pdb) return 0;
 946     if (!(pTask = (TDB *)GlobalLock16( pdb->task ))) return 0;
 947     return (pTask->version&0xff) | (((pTask->version >>8) & 0xff)<<16);
 948 }
 949
 950 /***********************************************************************
 951  *           GetProcessFlags    (KERNEL32)
 952  */
 953 DWORD WINAPI GetProcessFlags( DWORD processid )
 954 {
 955     PDB32 *pdb = PROCESS_IdToPDB( processid );
 956     if (!pdb) return 0;
 957     return pdb->flags;
 958 }
 959
 960 /***********************************************************************
 961  *           SetProcessWorkingSetSize    (KERNEL32)
 962  */
 963 BOOL32 WINAPI SetProcessWorkingSetSize(HANDLE32 hProcess,DWORD minset,
 964                                        DWORD maxset)
 965 {
 966         fprintf(stderr,"SetProcessWorkingSetSize(0x%08x,%ld,%ld), STUB!\n",
 967                 hProcess,minset,maxset
 968         );
 969         return TRUE;
 970 }
 971
 972 /***********************************************************************
 973  *           GetProcessWorkingSetSize    (KERNEL32)
 974  */
 975 BOOL32 WINAPI GetProcessWorkingSetSize(HANDLE32 hProcess,LPDWORD minset,
 976                                        LPDWORD maxset)
 977 {
 978         fprintf(stderr,"SetProcessWorkingSetSize(0x%08x,%p,%p), STUB!\n",
 979                 hProcess,minset,maxset
 980         );
 981         /* 32 MB working set size */
 982         if (minset) *minset = 32*1024*1024;
 983         if (maxset) *maxset = 32*1024*1024;
 984         return TRUE;
 985 }
 986
 987 /***********************************************************************
 988  *           SetProcessShutdownParameters    (KERNEL32)
 989  */
 990 BOOL32 WINAPI SetProcessShutdownParameters(DWORD level,DWORD flags)
 991 {
 992         fprintf(stderr,"SetProcessShutdownParameters(%ld,0x%08lx), STUB!\n",
 993                 level,flags
 994         );
 995         return TRUE;
 996 }
 997
 998 /***********************************************************************
 999  *           ReadProcessMemory                  (KERNEL32)
1000  * FIXME: check this, if we ever run win32 binaries in different addressspaces
1001  *        ... and add a sizecheck
1002  */
1003 BOOL32 WINAPI ReadProcessMemory( HANDLE32 hProcess, LPCVOID lpBaseAddress,
1004                                  LPVOID lpBuffer, DWORD nSize,
1005                                  LPDWORD lpNumberOfBytesRead )
1006 {
1007         memcpy(lpBuffer,lpBaseAddress,nSize);
1008         if (lpNumberOfBytesRead) *lpNumberOfBytesRead = nSize;
1009         return TRUE;
1010 }
1011
1012 /***********************************************************************
1013  *           ConvertToGlobalHandle              (KERNEL32)
1014  * FIXME: this is not correctly implemented...
1015  */
1016 HANDLE32 WINAPI ConvertToGlobalHandle(HANDLE32 h)
1017 {
1018         fprintf(stderr,"ConvertToGlobalHandle(%d),stub!\n",h);
1019         return h;
1020 }
1021
1022 /***********************************************************************
1023  *           RegisterServiceProcess             (KERNEL32)
1024  *
1025  * A service process calls this function to ensure that it continues to run
1026  * even after a user logged off.
1027  */
1028 DWORD RegisterServiceProcess(DWORD dwProcessId, DWORD dwType)
1029 {
1030         /* I don't think that Wine needs to do anything in that function */
1031         return 1; /* success */
1032 }