win32/process.c

   1 /*
   2  * Win32 kernel functions
   3  *
   4  * Copyright 1995 Martin von Loewis
   5  */
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10 #include "windows.h"
  11 #include "winerror.h"
  12 #include "heap.h"
  13 #include "handle32.h"
  14 #include "task.h"
  15 #include "stddebug.h"
  16 #include "debug.h"
  17
  18 static HANDLE32 ProcessHeap = 0;  /* FIXME: should be in process database */
  19
  20 /***********************************************************************
  21  *           ExitProcess   (KERNEL32.100)
  22  */
  23
  24 void ExitProcess(DWORD status)
  25 {
  26     TASK_KillCurrentTask( status );
  27 }
  28
  29 /***********************************************************************
  30  *           CreateMutexA    (KERNEL32.52)
  31  */
  32 HANDLE32 CreateMutexA (SECURITY_ATTRIBUTES *sa, BOOL on, const char *a)
  33 {
  34         return 0;
  35 }
  36
  37 /***********************************************************************
  38  *           ReleaseMutex    (KERNEL32.435)
  39  */
  40 BOOL ReleaseMutex (HANDLE32 h)
  41 {
  42         return 0;
  43 }
  44
  45 /***********************************************************************
  46  *           CreateEventA    (KERNEL32.43)
  47  */
  48 HANDLE32 CreateEventA (SECURITY_ATTRIBUTES *sa, BOOL au, BOOL on, const char
  49 *name)
  50 {
  51         return 0;
  52 }
  53 /***********************************************************************
  54  *           SetEvent    (KERNEL32.487)
  55  */
  56 BOOL SetEvent (HANDLE32 h)
  57 {
  58         return 0;
  59 }
  60 /***********************************************************************
  61  *           ResetEvent    (KERNEL32.439)
  62  */
  63 BOOL ResetEvent (HANDLE32 h)
  64 {
  65         return 0;
  66 }
  67 /***********************************************************************
  68  *           WaitForSingleObject    (KERNEL32.561)
  69  */
  70 DWORD WaitForSingleObject(HANDLE32 h, DWORD a)
  71 {
  72         return 0;
  73 }
  74 /***********************************************************************
  75  *           DuplicateHandle    (KERNEL32.78)
  76  */
  77 BOOL DuplicateHandle(HANDLE32 a, HANDLE32 b, HANDLE32 c, HANDLE32 * d, DWORD e, BOOL f, DWORD g)
  78 {
  79         *d = b;
  80         return 1;
  81 }
  82 /***********************************************************************
  83  *           GetCurrentProcess    (KERNEL32.198)
  84  */
  85 HANDLE32 GetCurrentProcess(void)
  86 {
  87         return 0;
  88 }
  89
  90 /***********************************************************************
  91  *           GetProcessHeap    (KERNEL32.259)
  92  */
  93 HANDLE32 GetProcessHeap(void)
  94 {
  95     if (!ProcessHeap) ProcessHeap = HeapCreate( 0, 0x10000, 0 );
  96     return ProcessHeap;
  97 }
  98
  99 /***********************************************************************
 100  *           LoadLibraryA         (KERNEL32.365)
 101  * copied from LoadLibrary
 102  * This does not currently support built-in libraries
 103  */
 104 HINSTANCE32 LoadLibrary32A(LPCSTR libname)
 105 {
 106         HINSTANCE32 handle;
 107         dprintf_module( stddeb, "LoadLibrary: (%08x) %s\n", (int)libname, libname);
 108         handle = LoadModule( libname, (LPVOID)-1 );
 109         if (handle == (HINSTANCE32) -1)
 110         {
 111                 char buffer[256];
 112                 strcpy( buffer, libname );
 113                 strcat( buffer, ".dll" );
 114                 handle = LoadModule( buffer, (LPVOID)-1 );
 115         }
 116         /* Obtain module handle and call initialization function */
 117 #ifndef WINELIB
 118         if (handle >= (HINSTANCE32)32) PE_InitializeDLLs( GetExePtr(handle));
 119 #endif
 120         return handle;
 121 }
 122
 123 /***********************************************************************
 124  *           LoadLibrary32W         (KERNEL32.368)
 125  */
 126 HINSTANCE32 LoadLibrary32W(LPCWSTR libnameW)
 127 {
 128     LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW );
 129     HINSTANCE32 ret = LoadLibrary32A( libnameA );
 130     HeapFree( GetProcessHeap(), 0, libnameA );
 131     return ret;
 132 }
 133
 134 /***********************************************************************
 135  *           FreeLibrary
 136  */
 137 BOOL FreeLibrary32(HINSTANCE32 hLibModule)
 138 {
 139         fprintf(stderr,"FreeLibrary: empty stub\n");
 140         return TRUE;
 141 }
 142
 143 /**********************************************************************
 144  *          GetProcessAffinityMask
 145  */
 146 BOOL GetProcessAffinityMask(HANDLE32 hProcess, LPDWORD lpProcessAffinityMask,
 147   LPDWORD lpSystemAffinityMask)
 148 {
 149         dprintf_task(stddeb,"GetProcessAffinityMask(%x,%lx,%lx)\n",
 150                 hProcess,(lpProcessAffinityMask?*lpProcessAffinityMask:0),
 151                 (lpSystemAffinityMask?*lpSystemAffinityMask:0));
 152         /* It is definitely important for a process to know on what processor
 153            it is running :-) */
 154         if(lpProcessAffinityMask)
 155                 *lpProcessAffinityMask=1;
 156         if(lpSystemAffinityMask)
 157                 *lpSystemAffinityMask=1;
 158         return TRUE;
 159 }
 160
 161 /**********************************************************************
 162  *           SetThreadAffinityMask
 163  */
 164 BOOL SetThreadAffinityMask(HANDLE32 hThread, DWORD dwThreadAffinityMask)
 165 {
 166         dprintf_task(stddeb,"SetThreadAffinityMask(%x,%lx)\n",hThread,
 167                 dwThreadAffinityMask);
 168         /* FIXME: We let it fail */
 169         return 1;
 170 }