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 BOOL16 WINAPI NotifyRegister16( HTASK16 htask, FARPROC16 lpfnCallback,
  41                               WORD wFlags )
  42 {
  43     int i;
  44
  45     TRACE("(%x,%lx,%x) called.\n",
  46                       htask, (DWORD)lpfnCallback, wFlags );
  47     if (!htask) htask = GetCurrentTask();
  48     for (i=0;i<nrofnotifys;i++)
  49         if (notifys[i].htask==htask)
  50             break;
  51     if (i==nrofnotifys) {
  52         if (notifys==NULL)
  53             notifys=(struct notify*)HeapAlloc( GetProcessHeap(), 0,
  54                                                sizeof(struct notify) );
  55         else
  56             notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
  57                                         sizeof(struct notify)*(nrofnotifys+1));
  58         if (!notifys) return FALSE;
  59         nrofnotifys++;
  60     }
  61     notifys[i].htask=htask;
  62     notifys[i].lpfnCallback=lpfnCallback;
  63     notifys[i].wFlags=wFlags;
  64     return TRUE;
  65 }
  66
  67 BOOL16 WINAPI NotifyUnregister16( HTASK16 htask )
  68 {
  69     int i;
  70
  71     TRACE("(%x) called.\n", htask );
  72     if (!htask) htask = GetCurrentTask();
  73     for (i=nrofnotifys;i--;)
  74         if (notifys[i].htask==htask)
  75             break;
  76     if (i==-1)
  77         return FALSE;
  78     memcpy(notifys+i,notifys+(i+1),sizeof(struct notify)*(nrofnotifys-i-1));
  79     notifys=(struct notify*)HeapReAlloc( GetProcessHeap(), 0, notifys,
  80                                         (nrofnotifys-1)*sizeof(struct notify));
  81     nrofnotifys--;
  82     return TRUE;
  83 }
  84
  85 BOOL16 WINAPI StackTraceCSIPFirst16(STACKTRACEENTRY *ste, WORD wSS, WORD wCS, WORD wIP, WORD wBP)
  86 {
  87     return TRUE;
  88 }
  89
  90 BOOL16 WINAPI StackTraceFirst16(STACKTRACEENTRY *ste, HTASK16 Task)
  91 {
  92     return TRUE;
  93 }
  94
  95 BOOL16 WINAPI StackTraceNext16(STACKTRACEENTRY *ste)
  96 {
  97     return TRUE;
  98 }
  99
 100 BOOL16 WINAPI InterruptRegister16( HTASK16 task, FARPROC callback )
 101 {
 102     return TRUE;
 103 }
 104
 105 BOOL16 WINAPI InterruptUnRegister16( HTASK16 task )
 106 {
 107     return TRUE;
 108 }
 109
 110 /***********************************************************************
 111  *           ToolHelpHook                             (KERNEL.341)
 112  *      see "Undocumented Windows"
 113  */
 114 FARPROC16 WINAPI ToolHelpHook16(FARPROC16 lpfnNotifyHandler)
 115 {
 116 FARPROC16 tmp;
 117         tmp = HookNotify;
 118         HookNotify = lpfnNotifyHandler;
 119         /* just return previously installed notification function */
 120         return tmp;
 121 }
 122
 123
 124 /***********************************************************************
 125  *           CreateToolHelp32Snapshot                   (KERNEL32.179)
 126  */
 127 HANDLE WINAPI CreateToolhelp32Snapshot( DWORD flags, DWORD process )
 128 {
 129     struct create_snapshot_request *req = get_req_buffer();
 130
 131     TRACE("%lx,%lx\n", flags, process );
 132     if (flags & (TH32CS_SNAPHEAPLIST|TH32CS_SNAPMODULE|TH32CS_SNAPTHREAD))
 133         FIXME("flags %lx not implemented\n", flags );
 134     if (!(flags & TH32CS_SNAPPROCESS))
 135     {
 136         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 137         return INVALID_HANDLE_VALUE;
 138     }
 139
 140     /* Now do the snapshot */
 141     req->flags   = flags & ~TH32CS_INHERIT;
 142     req->inherit = (flags & TH32CS_INHERIT) != 0;
 143     server_call( REQ_CREATE_SNAPSHOT );
 144     return req->handle;
 145 }
 146
 147
 148 /***********************************************************************
 149  *              Thread32First    (KERNEL32.686)
 150  *
 151  * Return info about the first thread in a toolhelp32 snapshot
 152  */
 153 BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY lpte)
 154 {
 155     if (!lpte)
 156         return FALSE;
 157
 158     FIXME("(%d,%p),stub!\n",hSnapshot,lpte);
 159     return FALSE;
 160 }
 161
 162 /***********************************************************************
 163  *              Thread32Next   (KERNEL32.687)
 164  *
 165  * Return info about the "next" thread in a toolhelp32 snapshot
 166  */
 167 BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY lpte)
 168 {
 169     if (!lpte)
 170         return FALSE;
 171
 172     FIXME("(%d,%p),stub!\n",hSnapshot,lpte);
 173     return FALSE;
 174 }
 175
 176 /***********************************************************************
 177  *              TOOLHELP_Process32Next
 178  *
 179  * Implementation of Process32First/Next
 180  */
 181 static BOOL TOOLHELP_Process32Next( HANDLE handle, LPPROCESSENTRY lppe, BOOL first )
 182 {
 183     struct next_process_request *req = get_req_buffer();
 184
 185     if (lppe->dwSize < sizeof (PROCESSENTRY))
 186     {
 187         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 188         ERR("Result buffer too small\n");
 189         return FALSE;
 190     }
 191     req->handle = handle;
 192     req->reset = first;
 193     if (server_call( REQ_NEXT_PROCESS )) return FALSE;
 194     lppe->cntUsage            = 1;
 195     lppe->th32ProcessID       = (DWORD)req->pid;
 196     lppe->th32DefaultHeapID   = 0;  /* FIXME */
 197     lppe->th32ModuleID        = 0;  /* FIXME */
 198     lppe->cntThreads          = req->threads;
 199     lppe->th32ParentProcessID = 0;  /* FIXME */
 200     lppe->pcPriClassBase      = req->priority;
 201     lppe->dwFlags             = -1; /* FIXME */
 202     lppe->szExeFile[0]        = 0;  /* FIXME */
 203     return TRUE;
 204 }
 205
 206
 207 /***********************************************************************
 208  *              Process32First    (KERNEL32.555)
 209  *
 210  * Return info about the first process in a toolhelp32 snapshot
 211  */
 212 BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY lppe)
 213 {
 214     return TOOLHELP_Process32Next( hSnapshot, lppe, TRUE );
 215 }
 216
 217 /***********************************************************************
 218  *              Process32Next   (KERNEL32.556)
 219  *
 220  * Return info about the "next" process in a toolhelp32 snapshot
 221  */
 222 BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY lppe)
 223 {
 224     return TOOLHELP_Process32Next( hSnapshot, lppe, FALSE );
 225 }
 226
 227 /***********************************************************************
 228  *              Module32First   (KERNEL32.527)
 229  *
 230  * Return info about the "first" module in a toolhelp32 snapshot
 231  */
 232 BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY lpme)
 233 {
 234     FIXME("(%d,%p),stub!\n",hSnapshot,lpme);
 235     return FALSE;
 236 }
 237
 238 /***********************************************************************
 239  *              Module32Next   (KERNEL32.528)
 240  *
 241  * Return info about the "next" module in a toolhelp32 snapshot
 242  */
 243 BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY lpme)
 244 {
 245     FIXME("(%d,%p),stub!\n",hSnapshot,lpme);
 246     return FALSE;
 247 }
 248
 249 /************************************************************************
 250  *              GlobalMasterHandle16 (KERNEL.28)
 251  *
 252  *
 253  * Should return selector and handle of the information structure for
 254  * the global heap. selector and handle are stored in the THHOOK as
 255  * pGlobalHeap and hGlobalHeap.
 256  * As Wine doesn't have this structure, we return both values as zero
 257  * Applications should interpret this as "No Global Heap"
 258  */
 259 DWORD WINAPI GlobalMasterHandle16(void)
 260 {
 261     FIXME(": stub\n");
 262     return 0;
 263 }