misc/toolhelp.c

   1 /*
   2  * Misc Toolhelp functions
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10 #include <ctype.h>
  11 #include <assert.h>
  12 #include "winbase.h"
  13 #include "wine/winbase16.h"
  14 #include "winerror.h"
  15 #include "process.h"
  16 #include "tlhelp32.h"
  17 #include "toolhelp.h"
  18 #include "heap.h"
  19 #include "server.h"
  20 #include "debugtools.h"
  21
  22 DEFAULT_DEBUG_CHANNEL(toolhelp);
  23
  24
  25 /* FIXME: to make this working, we have to callback all these registered
  26  * functions from all over the WINE code. Someone with more knowledge than
  27  * me please do that. -Marcus
  28  */
  29 static struct notify
  30 {
  31     HTASK16   htask;
  32     FARPROC16 lpfnCallback;
  33     WORD     wFlags;
  34 } *notifys = NULL;
  35
  36 static int nrofnotifys = 0;
  37
  38 static FARPROC16 HookNotify = NULL;
  39
  40 /***********************************************************************
  41  *              NotifyRegister16
  42  */
  43 BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback,
  44                               WORD wFlags )
  45 {
  46     int i;
  47
  48     TRACE("(%x,%lx,%x) called.\n",
  49                       htask, (DWORD)lpfnCallback, wFlags );
  50     if (!htask) htask = GetCurrentTask();
  51     for (i=0;i<nrofnotifys;i++)
  52         if (notifys[i].htask==htask)
  53             break;
  54     if (i==nrofnotifys) {
  55         if (notifys==NULL)
  56             notifys=(struct notify*)HeapAlloc( GetProcessHeap(), 0,
  57                                                sizeof(struct notify) );
  58         else
  59             notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
  60                                         sizeof(struct notify)*(nrofnotifys+1));
  61         if (!notifys) return FALSE;
  62         nrofnotifys++;
  63     }
  64     notifys[i].htask=htask;
  65     notifys[i].lpfnCallback=lpfnCallback;
  66     notifys[i].wFlags=wFlags;
  67     return TRUE;
  68 }
  69
  70 /***********************************************************************
  71  *              NotifyUnregister16
  72  */
  73 BOOL16 WINAPI NotifyUnregister16( HTASK16 htask )
  74 {
  75     int i;
  76
  77     TRACE("(%x) called.\n", htask );
  78     if (!htask) htask = GetCurrentTask();
  79     for (i=nrofnotifys;i--;)
  80         if (notifys[i].htask==htask)
  81             break;
  82     if (i==-1)
  83         return FALSE;
  84     memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1));
  85     notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
  86                                         (nrofnotifys-1)*sizeof(struct notify));
  87     nrofnotifys--;
  88     return TRUE;
  89 }
  90
  91 /***********************************************************************
  92  *              StackTraceCSIPFirst16
  93  */
  94 BOOL16 WINAPI StackTraceCSIPFirst16(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP)
  95 {
  96     return TRUE;
  97 }
  98
  99 /***********************************************************************
 100  *              StackTraceFirst16
 101  */
 102 BOOL16 WINAPI StackTraceFirst16(STACKTRACEENTRY *ste, HTASK16 Task)
 103 {
 104     return TRUE;
 105 }
 106
 107 /***********************************************************************
 108  *              StackTraceNext16
 109  */
 110 BOOL16 WINAPI StackTraceNext16(STACKTRACEENTRY *ste)
 111 {
 112     return TRUE;
 113 }
 114
 115 /***********************************************************************
 116  *              InterruptRegister16
 117  */
 118 BOOL16 WINAPI InterruptRegister16( HTASK16 task, FARPROC callback )
 119 {
 120     return TRUE;
 121 }
 122
 123 /***********************************************************************
 124  *              InterruptUnRegister16
 125  */
 126 BOOL16 WINAPI InterruptUnRegister16( HTASK16 task )
 127 {
 128     return TRUE;
 129 }
 130
 131 /***********************************************************************
 132  *           ToolHelpHook                             (KERNEL.341)
 133  *      see "Undocumented Windows"
 134  */
 135 FARPROC16 WINAPI ToolHelpHook16(FARPROC16 lpfnNotifyHandler)
 136 {
 137 FARPROC16 tmp;
 138         tmp = HookNotify;
 139         HookNotify = lpfnNotifyHandler;
 140         /* just return previously installed notification function */
 141         return tmp;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           CreateToolhelp32Snapshot                   (KERNEL32.179)
 147  */
 148 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
 149 {
 150     struct create_snapshot_request *req = get_req_buffer();
 151
 152     TRACE("%lx,%lx\n", flags, process );
 153     if (!(flags & (TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD|TH32CS_SNAPMODULE)))
 154     {
 155         FIXME("flags %lx not implemented\n", flags );
 156         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 157         return INVALID_HANDLE_VALUE;
 158     }
 159
 160     /* Now do the snapshot */
 161     req->flags   = flags & ~TH32CS_INHERIT;
 162     req->inherit = (flags & TH32CS_INHERIT) != 0;
 163     req->pid     = (void *)process;
 164     server_call( REQ_CREATE_SNAPSHOT );
 165     return req->handle;
 166 }
 167
 168
 169 /***********************************************************************
 170  *              TOOLHELP_Thread32Next
 171  *
 172  * Implementation of Thread32First/Next
 173  */
 174 static BOOL TOOLHELP_Thread32Next( HANDLE handle, LPTHREADENTRY32 lpte, BOOL first )
 175 {
 176     struct next_thread_request *req = get_req_buffer();
 177
 178     if (lpte->dwSize < sizeof(THREADENTRY32))
 179     {
 180         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 181         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(THREADENTRY32), lpte->dwSize);
 182         return FALSE;
 183     }
 184     req->handle = handle;
 185     req->reset = first;
 186     if (server_call( REQ_NEXT_THREAD )) return FALSE;
 187     lpte->cntUsage           = req->count;
 188     lpte->th32ThreadID       = (DWORD)req->tid;
 189     lpte->th32OwnerProcessID = (DWORD)req->pid;
 190     lpte->tbBasePri          = req->base_pri;
 191     lpte->tbDeltaPri         = req->delta_pri;
 192     lpte->dwFlags            = 0;  /* SDK: "reserved; do not use" */
 193     return TRUE;
 194 }
 195
 196 /***********************************************************************
 197  *              Thread32First    (KERNEL32.686)
 198  *
 199  * Return info about the first thread in a toolhelp32 snapshot
 200  */
 201 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 202 {
 203     return TOOLHELP_Thread32Next(hSnapshot, lpte, TRUE);
 204 }
 205
 206 /***********************************************************************
 207  *              Thread32Next   (KERNEL32.687)
 208  *
 209  * Return info about the "next" thread in a toolhelp32 snapshot
 210  */
 211 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte)
 212 {
 213     return TOOLHELP_Thread32Next(hSnapshot, lpte, FALSE);
 214 }
 215
 216 /***********************************************************************
 217  *              TOOLHELP_Process32Next
 218  *
 219  * Implementation of Process32First/Next
 220  */
 221 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY32 lppe, BOOL first )
 222 {
 223     struct next_process_request *req = get_req_buffer();
 224
 225     if (lppe->dwSize < sizeof(PROCESSENTRY32))
 226     {
 227         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 228         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(PROCESSENTRY32), lppe->dwSize);
 229         return FALSE;
 230     }
 231     req->handle = handle;
 232     req->reset = first;
 233     if (server_call( REQ_NEXT_PROCESS )) return FALSE;
 234     lppe->cntUsage            = req->count;
 235     lppe->th32ProcessID       = (DWORD)req->pid;
 236     lppe->th32DefaultHeapID   = 0;  /* FIXME */
 237     lppe->th32ModuleID        = 0;  /* FIXME */
 238     lppe->cntThreads          = req->threads;
 239     lppe->th32ParentProcessID = 0;  /* FIXME */
 240     lppe->pcPriClassBase      = req->priority;
 241     lppe->dwFlags             = -1; /* FIXME */
 242     lppe->szExeFile[0]        = 0;  /* FIXME */
 243     return TRUE;
 244 }
 245
 246
 247 /***********************************************************************
 248  *              Process32First    (KERNEL32.555)
 249  *
 250  * Return info about the first process in a toolhelp32 snapshot
 251  */
 252 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 253 {
 254     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE );
 255 }
 256
 257 /***********************************************************************
 258  *              Process32Next   (KERNEL32.556)
 259  *
 260  * Return info about the "next" process in a toolhelp32 snapshot
 261  */
 262 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
 263 {
 264     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE );
 265 }
 266
 267
 268 /***********************************************************************
 269  *              TOOLHELP_Module32Next
 270  *
 271  * Implementation of Module32First/Next
 272  */
 273 static BOOL TOOLHELP_Module32Next( HANDLE handle, LPMODULEENTRY32 lpme, BOOL first )
 274 {
 275     struct next_module_request *req = get_req_buffer();
 276
 277     if (lpme->dwSize < sizeof (MODULEENTRY32))
 278     {
 279         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 280         ERR("Result buffer too small (req: %d, was: %ld)\n", sizeof(MODULEENTRY32), lpme->dwSize);
 281         return FALSE;
 282     }
 283     req->handle = handle;
 284     req->reset = first;
 285     if (server_call( REQ_NEXT_MODULE )) return FALSE;
 286     lpme->th32ModuleID   = 0;  /* toolhelp internal id, never used */
 287     lpme->th32ProcessID  = (DWORD)req->pid;
 288     lpme->GlblcntUsage   = 0; /* FIXME */
 289     lpme->ProccntUsage   = 0; /* FIXME */
 290     lpme->modBaseAddr    = req->base;
 291     lpme->modBaseSize    = 0; /* FIXME */
 292     lpme->hModule        = (DWORD)req->base;
 293     lpme->szModule[0]    = 0;  /* FIXME */
 294     lpme->szExePath[0]   = 0;  /* FIXME */
 295     return TRUE;
 296 }
 297
 298 /***********************************************************************
 299  *              Module32First   (KERNEL32.527)
 300  *
 301  * Return info about the "first" module in a toolhelp32 snapshot
 302  */
 303 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 304 {
 305     return TOOLHELP_Module32Next( hSnapshot, lpme, TRUE );
 306 }
 307
 308 /***********************************************************************
 309  *              Module32Next   (KERNEL32.528)
 310  *
 311  * Return info about the "next" module in a toolhelp32 snapshot
 312  */
 313 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme)
 314 {
 315     return TOOLHELP_Module32Next( hSnapshot, lpme, FALSE );
 316 }
 317
 318 /************************************************************************
 319  *              GlobalMasterHandle16 (KERNEL.28)
 320  *
 321  *
 322  * Should return selector and handle of the information structure for
 323  * the global heap. selector and handle are stored in the THHOOK as
 324  * pGlobalHeap and hGlobalHeap.
 325  * As Wine doesn't have this structure, we return both values as zero
 326  * Applications should interpret this as "No Global Heap"
 327  */
 328 DWORD WINAPI GlobalMasterHandle16(void)
 329 {
 330     FIXME(": stub\n");
 331     return 0;
 332 }