dlls/kernel32/debugger.c

   1 /*
   2  * Win32 debugger functions
   3  *
   4  * Copyright (C) 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23
  24 #include "winerror.h"
  25 #include "wine/winbase16.h"
  26 #include "wine/server.h"
  27 #include "kernel_private.h"
  28 #include "kernel16_private.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(debugstr);
  32
  33
  34 /******************************************************************************
  35  *           WaitForDebugEvent   (KERNEL32.@)
  36  *
  37  *  Waits for a debugging event to occur in a process being debugged before
  38  *  filling out the debug event structure.
  39  *
  40  * PARAMS
  41  *  event   [O] Address of structure for event information.
  42  *  timeout [I] Number of milliseconds to wait for event.
  43  *
  44  * RETURNS
  45  *
  46  *  Returns true if a debug event occurred and false if the call timed out.
  47  */
  48 BOOL WINAPI WaitForDebugEvent(
  49     LPDEBUG_EVENT event,
  50     DWORD         timeout)
  51 {
  52     BOOL ret;
  53     DWORD i, res;
  54
  55     for (;;)
  56     {
  57         HANDLE wait = 0;
  58         debug_event_t data;
  59         SERVER_START_REQ( wait_debug_event )
  60         {
  61             req->get_handle = (timeout != 0);
  62             wine_server_set_reply( req, &data, sizeof(data) );
  63             if (!(ret = !wine_server_call_err( req ))) goto done;
  64
  65             if (!wine_server_reply_size(reply))  /* timeout */
  66             {
  67                 wait = wine_server_ptr_handle( reply->wait );
  68                 ret = FALSE;
  69                 goto done;
  70             }
  71             event->dwDebugEventCode = data.code;
  72             event->dwProcessId      = (DWORD)reply->pid;
  73             event->dwThreadId       = (DWORD)reply->tid;
  74             switch(data.code)
  75             {
  76             case EXCEPTION_DEBUG_EVENT:
  77                 event->u.Exception.dwFirstChance = data.exception.first;
  78                 event->u.Exception.ExceptionRecord.ExceptionCode    = data.exception.exc_code;
  79                 event->u.Exception.ExceptionRecord.ExceptionFlags   = data.exception.flags;
  80                 event->u.Exception.ExceptionRecord.ExceptionRecord  = wine_server_get_ptr( data.exception.record );
  81                 event->u.Exception.ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data.exception.address );
  82                 event->u.Exception.ExceptionRecord.NumberParameters = data.exception.nb_params;
  83                 for (i = 0; i < data.exception.nb_params; i++)
  84                     event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data.exception.params[i];
  85                 break;
  86             case CREATE_THREAD_DEBUG_EVENT:
  87                 event->u.CreateThread.hThread           = wine_server_ptr_handle( data.create_thread.handle );
  88                 event->u.CreateThread.lpThreadLocalBase = wine_server_get_ptr( data.create_thread.teb );
  89                 event->u.CreateThread.lpStartAddress    = wine_server_get_ptr( data.create_thread.start );
  90                 break;
  91             case CREATE_PROCESS_DEBUG_EVENT:
  92                 event->u.CreateProcessInfo.hFile                 = wine_server_ptr_handle( data.create_process.file );
  93                 event->u.CreateProcessInfo.hProcess              = wine_server_ptr_handle( data.create_process.process );
  94                 event->u.CreateProcessInfo.hThread               = wine_server_ptr_handle( data.create_process.thread );
  95                 event->u.CreateProcessInfo.lpBaseOfImage         = wine_server_get_ptr( data.create_process.base );
  96                 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.create_process.dbg_offset;
  97                 event->u.CreateProcessInfo.nDebugInfoSize        = data.create_process.dbg_size;
  98                 event->u.CreateProcessInfo.lpThreadLocalBase     = wine_server_get_ptr( data.create_process.teb );
  99                 event->u.CreateProcessInfo.lpStartAddress        = wine_server_get_ptr( data.create_process.start );
 100                 event->u.CreateProcessInfo.lpImageName           = wine_server_get_ptr( data.create_process.name );
 101                 event->u.CreateProcessInfo.fUnicode              = data.create_process.unicode;
 102                 break;
 103             case EXIT_THREAD_DEBUG_EVENT:
 104                 event->u.ExitThread.dwExitCode = data.exit.exit_code;
 105                 break;
 106             case EXIT_PROCESS_DEBUG_EVENT:
 107                 event->u.ExitProcess.dwExitCode = data.exit.exit_code;
 108                 break;
 109             case LOAD_DLL_DEBUG_EVENT:
 110                 event->u.LoadDll.hFile                 = wine_server_ptr_handle( data.load_dll.handle );
 111                 event->u.LoadDll.lpBaseOfDll           = wine_server_get_ptr( data.load_dll.base );
 112                 event->u.LoadDll.dwDebugInfoFileOffset = data.load_dll.dbg_offset;
 113                 event->u.LoadDll.nDebugInfoSize        = data.load_dll.dbg_size;
 114                 event->u.LoadDll.lpImageName           = wine_server_get_ptr( data.load_dll.name );
 115                 event->u.LoadDll.fUnicode              = data.load_dll.unicode;
 116                 break;
 117             case UNLOAD_DLL_DEBUG_EVENT:
 118                 event->u.UnloadDll.lpBaseOfDll = wine_server_get_ptr( data.unload_dll.base );
 119                 break;
 120             case OUTPUT_DEBUG_STRING_EVENT:
 121                 event->u.DebugString.lpDebugStringData  = wine_server_get_ptr( data.output_string.string );
 122                 event->u.DebugString.fUnicode           = data.output_string.unicode;
 123                 event->u.DebugString.nDebugStringLength = data.output_string.length;
 124                 break;
 125             case RIP_EVENT:
 126                 event->u.RipInfo.dwError = data.rip_info.error;
 127                 event->u.RipInfo.dwType  = data.rip_info.type;
 128                 break;
 129             }
 130         done:
 131             /* nothing */ ;
 132         }
 133         SERVER_END_REQ;
 134         if (ret) return TRUE;
 135         if (!wait) break;
 136         res = WaitForSingleObject( wait, timeout );
 137         CloseHandle( wait );
 138         if (res != STATUS_WAIT_0) break;
 139     }
 140     SetLastError( ERROR_SEM_TIMEOUT );
 141     return FALSE;
 142 }
 143
 144
 145 /**********************************************************************
 146  *           ContinueDebugEvent   (KERNEL32.@)
 147  *
 148  *  Enables a thread that previously produced a debug event to continue.
 149  *
 150  * PARAMS
 151  *  pid    [I] The id of the process to continue.
 152  *  tid    [I] The id of the thread to continue.
 153  *  status [I] The rule to apply to unhandled exeptions.
 154  *
 155  * RETURNS
 156  *
 157  *  True if the debugger is listed as the processes owner and the process
 158  *  and thread are valid.
 159  */
 160 BOOL WINAPI ContinueDebugEvent(
 161     DWORD pid,
 162     DWORD tid,
 163     DWORD status)
 164 {
 165     BOOL ret;
 166     SERVER_START_REQ( continue_debug_event )
 167     {
 168         req->pid    = pid;
 169         req->tid    = tid;
 170         req->status = status;
 171         ret = !wine_server_call_err( req );
 172     }
 173     SERVER_END_REQ;
 174     return ret;
 175 }
 176
 177
 178 /**********************************************************************
 179  *           DebugActiveProcess   (KERNEL32.@)
 180  *
 181  *  Attempts to attach the debugger to a process.
 182  *
 183  * PARAMS
 184  *  pid [I] The process to be debugged.
 185  *
 186  * RETURNS
 187  *
 188  *  True if the debugger was attached to process.
 189  */
 190 BOOL WINAPI DebugActiveProcess( DWORD pid )
 191 {
 192     BOOL ret;
 193     SERVER_START_REQ( debug_process )
 194     {
 195         req->pid = pid;
 196         req->attach = 1;
 197         ret = !wine_server_call_err( req );
 198     }
 199     SERVER_END_REQ;
 200     return ret;
 201 }
 202
 203 /**********************************************************************
 204  *           DebugActiveProcessStop   (KERNEL32.@)
 205  *
 206  *  Attempts to detach the debugger from a process.
 207  *
 208  * PARAMS
 209  *  pid [I] The process to be detached.
 210  *
 211  * RETURNS
 212  *
 213  *  True if the debugger was detached from the process.
 214  */
 215 BOOL WINAPI DebugActiveProcessStop( DWORD pid )
 216 {
 217     BOOL ret;
 218     SERVER_START_REQ( debug_process )
 219     {
 220         req->pid = pid;
 221         req->attach = 0;
 222         ret = !wine_server_call_err( req );
 223     }
 224     SERVER_END_REQ;
 225     return ret;
 226 }
 227
 228
 229 /***********************************************************************
 230  *           OutputDebugStringA   (KERNEL32.@)
 231  *
 232  *  Output by an application of an ascii string to a debugger (if attached)
 233  *  and program log.
 234  *
 235  * PARAMS
 236  *  str [I] The message to be logged and given to the debugger.
 237  *
 238  * RETURNS
 239  *
 240  *  Nothing.
 241  */
 242 void WINAPI OutputDebugStringA( LPCSTR str )
 243 {
 244     SERVER_START_REQ( output_debug_string )
 245     {
 246         req->string  = wine_server_client_ptr( str );
 247         req->unicode = 0;
 248         req->length  = strlen(str) + 1;
 249         wine_server_call( req );
 250     }
 251     SERVER_END_REQ;
 252     WARN("%s\n", str);
 253 }
 254
 255
 256 /***********************************************************************
 257  *           OutputDebugStringW   (KERNEL32.@)
 258  *
 259  *  Output by an application of a unicode string to a debugger (if attached)
 260  *  and program log.
 261  *
 262  * PARAMS
 263  *  str [I] The message to be logged and given to the debugger.
 264  *
 265  * RETURNS
 266  *
 267  *  Nothing.
 268  */
 269 void WINAPI OutputDebugStringW( LPCWSTR str )
 270 {
 271     SERVER_START_REQ( output_debug_string )
 272     {
 273         req->string  = wine_server_client_ptr( str );
 274         req->unicode = 1;
 275         req->length  = (lstrlenW(str) + 1) * sizeof(WCHAR);
 276         wine_server_call( req );
 277     }
 278     SERVER_END_REQ;
 279     WARN("%s\n", debugstr_w(str));
 280 }
 281
 282
 283 /***********************************************************************
 284  *           OutputDebugString   (KERNEL.115)
 285  *
 286  *  Output by a 16 bit application of an ascii string to a debugger (if attached)
 287  *  and program log.
 288  *
 289  * PARAMS
 290  *  str [I] The message to be logged and given to the debugger.
 291  *
 292  * RETURNS
 293  */
 294 void WINAPI OutputDebugString16( LPCSTR str )
 295 {
 296     OutputDebugStringA( str );
 297 }
 298
 299
 300 /***********************************************************************
 301  *           DebugBreak   (KERNEL32.@)
 302  *
 303  *  Raises an exception so that a debugger (if attached)
 304  *  can take some action.
 305  *
 306  * PARAMS
 307  *
 308  * RETURNS
 309  */
 310 void WINAPI DebugBreak(void)
 311 {
 312     DbgBreakPoint();
 313 }
 314
 315 /***********************************************************************
 316  *           DebugBreakProcess   (KERNEL32.@)
 317  *
 318  *  Raises an exception so that a debugger (if attached)
 319  *  can take some action. Same as DebugBreak, but applies to any process.
 320  *
 321  * PARAMS
 322  *  hProc [I] Process to break into.
 323  *
 324  * RETURNS
 325  *
 326  *  True if successful.
 327  */
 328 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
 329 {
 330     BOOL ret, self;
 331
 332     TRACE("(%p)\n", hProc);
 333
 334     SERVER_START_REQ( debug_break )
 335     {
 336         req->handle = wine_server_obj_handle( hProc );
 337         ret = !wine_server_call_err( req );
 338         self = ret && reply->self;
 339     }
 340     SERVER_END_REQ;
 341     if (self) DbgBreakPoint();
 342     return ret;
 343 }
 344
 345
 346 /***********************************************************************
 347  *           DebugBreak   (KERNEL.203)
 348  *
 349  *  Raises an exception in a 16 bit application so that a debugger (if attached)
 350  *  can take some action.
 351  *
 352  * PARAMS
 353  *
 354  * RETURNS
 355  *
 356  * BUGS
 357  *
 358  *  Only 386 compatible processors implemented.
 359  */
 360 void WINAPI DebugBreak16(
 361     CONTEXT86 *context) /* [in/out] A pointer to the 386 compatible processor state. */
 362 {
 363 #ifdef __i386__
 364     EXCEPTION_RECORD rec;
 365
 366     rec.ExceptionCode    = EXCEPTION_BREAKPOINT;
 367     rec.ExceptionFlags   = 0;
 368     rec.ExceptionRecord  = NULL;
 369     rec.ExceptionAddress = (LPVOID)context->Eip;
 370     rec.NumberParameters = 0;
 371     NtRaiseException( &rec, context, TRUE );
 372 #endif  /* defined(__i386__) */
 373 }
 374
 375
 376 /***********************************************************************
 377  *           IsDebuggerPresent   (KERNEL32.@)
 378  *
 379  *  Allows a process to determine if there is a debugger attached.
 380  *
 381  * PARAMS
 382  *
 383  * RETURNS
 384  *
 385  *  True if there is a debugger attached.
 386  */
 387 BOOL WINAPI IsDebuggerPresent(void)
 388 {
 389     return NtCurrentTeb()->Peb->BeingDebugged;
 390 }
 391
 392 /***********************************************************************
 393  *           CheckRemoteDebuggerPresent   (KERNEL32.@)
 394  *
 395  *  Allows a process to determine if there is a remote debugger
 396  *  attached.
 397  *
 398  * PARAMS
 399  *
 400  * RETURNS
 401  *
 402  *  TRUE because it is a stub.
 403  */
 404 BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE process, PBOOL DebuggerPresent)
 405 {
 406     FIXME("(%p)->(%p): Stub!\n", process, DebuggerPresent);
 407     *DebuggerPresent = FALSE;
 408     return TRUE;
 409 }
 410
 411 /***********************************************************************
 412  *           _DebugOutput                    (KERNEL.328)
 413  */
 414 void WINAPIV _DebugOutput( WORD flags, LPCSTR spec, VA_LIST16 valist )
 415 {
 416     char caller[101];
 417
 418     /* Decode caller address */
 419     if (!GetModuleName16( GetExePtr(CURRENT_STACK16->cs), caller, sizeof(caller) ))
 420         sprintf( caller, "%04X:%04X", CURRENT_STACK16->cs, CURRENT_STACK16->ip );
 421
 422     /* FIXME: cannot use wvsnprintf16 from kernel */
 423     /* wvsnprintf16( temp, sizeof(temp), spec, valist ); */
 424
 425     /* Output */
 426     FIXME("%s %04x %s\n", caller, flags, debugstr_a(spec) );
 427 }
 428
 429 /***********************************************************************
 430  *           DebugSetProcessKillOnExit                    (KERNEL32.@)
 431  *
 432  * Let a debugger decide whether a debuggee will be killed upon debugger
 433  * termination.
 434  *
 435  * PARAMS
 436  *  kill [I] If set to true then kill the process on exit.
 437  *
 438  * RETURNS
 439  *  True if successful, false otherwise.
 440  */
 441 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
 442 {
 443     BOOL ret = FALSE;
 444
 445     SERVER_START_REQ( set_debugger_kill_on_exit )
 446     {
 447         req->kill_on_exit = kill;
 448         ret = !wine_server_call_err( req );
 449     }
 450     SERVER_END_REQ;
 451     return ret;
 452 }