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