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 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.ExceptionRecord = data.info.exception.record;
  78                 event->u.Exception.dwFirstChance   = data.info.exception.first;
  79                 break;
  80             case CREATE_THREAD_DEBUG_EVENT:
  81                 event->u.CreateThread.hThread           = wine_server_ptr_handle( data.info.create_thread.handle );
  82                 event->u.CreateThread.lpThreadLocalBase = data.info.create_thread.teb;
  83                 event->u.CreateThread.lpStartAddress    = data.info.create_thread.start;
  84                 break;
  85             case CREATE_PROCESS_DEBUG_EVENT:
  86                 event->u.CreateProcessInfo.hFile                 = wine_server_ptr_handle( data.info.create_process.file );
  87                 event->u.CreateProcessInfo.hProcess              = wine_server_ptr_handle( data.info.create_process.process );
  88                 event->u.CreateProcessInfo.hThread               = wine_server_ptr_handle( data.info.create_process.thread );
  89                 event->u.CreateProcessInfo.lpBaseOfImage         = data.info.create_process.base;
  90                 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.info.create_process.dbg_offset;
  91                 event->u.CreateProcessInfo.nDebugInfoSize        = data.info.create_process.dbg_size;
  92                 event->u.CreateProcessInfo.lpThreadLocalBase     = data.info.create_process.teb;
  93                 event->u.CreateProcessInfo.lpStartAddress        = data.info.create_process.start;
  94                 event->u.CreateProcessInfo.lpImageName           = data.info.create_process.name;
  95                 event->u.CreateProcessInfo.fUnicode              = data.info.create_process.unicode;
  96                 break;
  97             case EXIT_THREAD_DEBUG_EVENT:
  98                 event->u.ExitThread.dwExitCode = data.info.exit.exit_code;
  99                 break;
 100             case EXIT_PROCESS_DEBUG_EVENT:
 101                 event->u.ExitProcess.dwExitCode = data.info.exit.exit_code;
 102                 break;
 103             case LOAD_DLL_DEBUG_EVENT:
 104                 event->u.LoadDll.hFile                 = wine_server_ptr_handle( data.info.load_dll.handle );
 105                 event->u.LoadDll.lpBaseOfDll           = data.info.load_dll.base;
 106                 event->u.LoadDll.dwDebugInfoFileOffset = data.info.load_dll.dbg_offset;
 107                 event->u.LoadDll.nDebugInfoSize        = data.info.load_dll.dbg_size;
 108                 event->u.LoadDll.lpImageName           = data.info.load_dll.name;
 109                 event->u.LoadDll.fUnicode              = data.info.load_dll.unicode;
 110                 break;
 111             case UNLOAD_DLL_DEBUG_EVENT:
 112                 event->u.UnloadDll.lpBaseOfDll = data.info.unload_dll.base;
 113                 break;
 114             case OUTPUT_DEBUG_STRING_EVENT:
 115                 event->u.DebugString.lpDebugStringData  = data.info.output_string.string;
 116                 event->u.DebugString.fUnicode           = data.info.output_string.unicode;
 117                 event->u.DebugString.nDebugStringLength = data.info.output_string.length;
 118                 break;
 119             case RIP_EVENT:
 120                 event->u.RipInfo.dwError = data.info.rip_info.error;
 121                 event->u.RipInfo.dwType  = data.info.rip_info.type;
 122                 break;
 123             }
 124         done:
 125             /* nothing */ ;
 126         }
 127         SERVER_END_REQ;
 128         if (ret) return TRUE;
 129         if (!wait) break;
 130         res = WaitForSingleObject( wait, timeout );
 131         CloseHandle( wait );
 132         if (res != STATUS_WAIT_0) break;
 133     }
 134     SetLastError( ERROR_SEM_TIMEOUT );
 135     return FALSE;
 136 }
 137
 138
 139 /**********************************************************************
 140  *           ContinueDebugEvent   (KERNEL32.@)
 141  *
 142  *  Enables a thread that previously produced a debug event to continue.
 143  *
 144  * PARAMS
 145  *  pid    [I] The id of the process to continue.
 146  *  tid    [I] The id of the thread to continue.
 147  *  status [I] The rule to apply to unhandled exeptions.
 148  *
 149  * RETURNS
 150  *
 151  *  True if the debugger is listed as the processes owner and the process
 152  *  and thread are valid.
 153  */
 154 BOOL WINAPI ContinueDebugEvent(
 155     DWORD pid,
 156     DWORD tid,
 157     DWORD status)
 158 {
 159     BOOL ret;
 160     SERVER_START_REQ( continue_debug_event )
 161     {
 162         req->pid    = pid;
 163         req->tid    = tid;
 164         req->status = status;
 165         ret = !wine_server_call_err( req );
 166     }
 167     SERVER_END_REQ;
 168     return ret;
 169 }
 170
 171
 172 /**********************************************************************
 173  *           DebugActiveProcess   (KERNEL32.@)
 174  *
 175  *  Attempts to attach the debugger to a process.
 176  *
 177  * PARAMS
 178  *  pid [I] The process to be debugged.
 179  *
 180  * RETURNS
 181  *
 182  *  True if the debugger was attached to process.
 183  */
 184 BOOL WINAPI DebugActiveProcess( DWORD pid )
 185 {
 186     BOOL ret;
 187     SERVER_START_REQ( debug_process )
 188     {
 189         req->pid = pid;
 190         req->attach = 1;
 191         ret = !wine_server_call_err( req );
 192     }
 193     SERVER_END_REQ;
 194     return ret;
 195 }
 196
 197 /**********************************************************************
 198  *           DebugActiveProcessStop   (KERNEL32.@)
 199  *
 200  *  Attempts to detach the debugger from a process.
 201  *
 202  * PARAMS
 203  *  pid [I] The process to be detached.
 204  *
 205  * RETURNS
 206  *
 207  *  True if the debugger was detached from the process.
 208  */
 209 BOOL WINAPI DebugActiveProcessStop( DWORD pid )
 210 {
 211     BOOL ret;
 212     SERVER_START_REQ( debug_process )
 213     {
 214         req->pid = pid;
 215         req->attach = 0;
 216         ret = !wine_server_call_err( req );
 217     }
 218     SERVER_END_REQ;
 219     return ret;
 220 }
 221
 222
 223 /***********************************************************************
 224  *           OutputDebugStringA   (KERNEL32.@)
 225  *
 226  *  Output by an application of an ascii string to a debugger (if attached)
 227  *  and program log.
 228  *
 229  * PARAMS
 230  *  str [I] The message to be logged and given to the debugger.
 231  *
 232  * RETURNS
 233  *
 234  *  Nothing.
 235  */
 236 void WINAPI OutputDebugStringA( LPCSTR str )
 237 {
 238     SERVER_START_REQ( output_debug_string )
 239     {
 240         req->string  = (void *)str;
 241         req->unicode = 0;
 242         req->length  = strlen(str) + 1;
 243         wine_server_call( req );
 244     }
 245     SERVER_END_REQ;
 246     WARN("%s\n", str);
 247 }
 248
 249
 250 /***********************************************************************
 251  *           OutputDebugStringW   (KERNEL32.@)
 252  *
 253  *  Output by an application of a unicode string to a debugger (if attached)
 254  *  and program log.
 255  *
 256  * PARAMS
 257  *  str [I] The message to be logged and given to the debugger.
 258  *
 259  * RETURNS
 260  *
 261  *  Nothing.
 262  */
 263 void WINAPI OutputDebugStringW( LPCWSTR str )
 264 {
 265     SERVER_START_REQ( output_debug_string )
 266     {
 267         req->string  = (void *)str;
 268         req->unicode = 1;
 269         req->length  = (lstrlenW(str) + 1) * sizeof(WCHAR);
 270         wine_server_call( req );
 271     }
 272     SERVER_END_REQ;
 273     WARN("%s\n", debugstr_w(str));
 274 }
 275
 276
 277 /***********************************************************************
 278  *           OutputDebugString   (KERNEL.115)
 279  *
 280  *  Output by a 16 bit application of an ascii string to a debugger (if attached)
 281  *  and program log.
 282  *
 283  * PARAMS
 284  *  str [I] The message to be logged and given to the debugger.
 285  *
 286  * RETURNS
 287  */
 288 void WINAPI OutputDebugString16( LPCSTR str )
 289 {
 290     OutputDebugStringA( str );
 291 }
 292
 293
 294 /***********************************************************************
 295  *           DebugBreak   (KERNEL32.@)
 296  *
 297  *  Raises an exception so that a debugger (if attached)
 298  *  can take some action.
 299  *
 300  * PARAMS
 301  *
 302  * RETURNS
 303  */
 304 void WINAPI DebugBreak(void)
 305 {
 306     DbgBreakPoint();
 307 }
 308
 309 /***********************************************************************
 310  *           DebugBreakProcess   (KERNEL32.@)
 311  *
 312  *  Raises an exception so that a debugger (if attached)
 313  *  can take some action. Same as DebugBreak, but applies to any process.
 314  *
 315  * PARAMS
 316  *  hProc [I] Process to break into.
 317  *
 318  * RETURNS
 319  *
 320  *  True if successful.
 321  */
 322 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
 323 {
 324     BOOL ret, self;
 325
 326     TRACE("(%p)\n", hProc);
 327
 328     SERVER_START_REQ( debug_break )
 329     {
 330         req->handle = wine_server_obj_handle( hProc );
 331         ret = !wine_server_call_err( req );
 332         self = ret && reply->self;
 333     }
 334     SERVER_END_REQ;
 335     if (self) DbgBreakPoint();
 336     return ret;
 337 }
 338
 339
 340 /***********************************************************************
 341  *           DebugBreak   (KERNEL.203)
 342  *
 343  *  Raises an exception in a 16 bit application so that a debugger (if attached)
 344  *  can take some action.
 345  *
 346  * PARAMS
 347  *
 348  * RETURNS
 349  *
 350  * BUGS
 351  *
 352  *  Only 386 compatible processors implemented.
 353  */
 354 void WINAPI DebugBreak16(
 355     CONTEXT86 *context) /* [in/out] A pointer to the 386 compatible processor state. */
 356 {
 357 #ifdef __i386__
 358     EXCEPTION_RECORD rec;
 359
 360     rec.ExceptionCode    = EXCEPTION_BREAKPOINT;
 361     rec.ExceptionFlags   = 0;
 362     rec.ExceptionRecord  = NULL;
 363     rec.ExceptionAddress = (LPVOID)context->Eip;
 364     rec.NumberParameters = 0;
 365     NtRaiseException( &rec, context, TRUE );
 366 #endif  /* defined(__i386__) */
 367 }
 368
 369
 370 /***********************************************************************
 371  *           IsDebuggerPresent   (KERNEL32.@)
 372  *
 373  *  Allows a process to determine if there is a debugger attached.
 374  *
 375  * PARAMS
 376  *
 377  * RETURNS
 378  *
 379  *  True if there is a debugger attached.
 380  */
 381 BOOL WINAPI IsDebuggerPresent(void)
 382 {
 383     return NtCurrentTeb()->Peb->BeingDebugged;
 384 }
 385
 386 /***********************************************************************
 387  *           CheckRemoteDebuggerPresent   (KERNEL32.@)
 388  *
 389  *  Allows a process to determine if there is a remote debugger
 390  *  attached.
 391  *
 392  * PARAMS
 393  *
 394  * RETURNS
 395  *
 396  *  TRUE because it is a stub.
 397  */
 398 BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE process, PBOOL DebuggerPresent)
 399 {
 400     FIXME("(%p)->(%p): Stub!\n", process, DebuggerPresent);
 401     *DebuggerPresent = FALSE;
 402     return TRUE;
 403 }
 404
 405 /***********************************************************************
 406  *           _DebugOutput                    (KERNEL.328)
 407  */
 408 void WINAPIV _DebugOutput( WORD flags, LPCSTR spec, VA_LIST16 valist )
 409 {
 410     char caller[101];
 411
 412     /* Decode caller address */
 413     if (!GetModuleName16( GetExePtr(CURRENT_STACK16->cs), caller, sizeof(caller) ))
 414         sprintf( caller, "%04X:%04X", CURRENT_STACK16->cs, CURRENT_STACK16->ip );
 415
 416     /* FIXME: cannot use wvsnprintf16 from kernel */
 417     /* wvsnprintf16( temp, sizeof(temp), spec, valist ); */
 418
 419     /* Output */
 420     FIXME("%s %04x %s\n", caller, flags, debugstr_a(spec) );
 421 }
 422
 423 /***********************************************************************
 424  *           DebugSetProcessKillOnExit                    (KERNEL32.@)
 425  *
 426  * Let a debugger decide whether a debuggee will be killed upon debugger
 427  * termination.
 428  *
 429  * PARAMS
 430  *  kill [I] If set to true then kill the process on exit.
 431  *
 432  * RETURNS
 433  *  True if successful, false otherwise.
 434  */
 435 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
 436 {
 437     BOOL ret = FALSE;
 438
 439     SERVER_START_REQ( set_debugger_kill_on_exit )
 440     {
 441         req->kill_on_exit = kill;
 442         ret = !wine_server_call_err( req );
 443     }
 444     SERVER_END_REQ;
 445     return ret;
 446 }