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 "config.h"
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "winerror.h"
  28 #include "wine/server.h"
  29 #include "kernel_private.h"
  30 #include "wine/asm.h"
  31 #include "wine/debug.h"
  32 #include "wine/exception.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(debugstr);
  35
  36 static LONG WINAPI debug_exception_handler( EXCEPTION_POINTERS *eptr )
  37 {
  38     EXCEPTION_RECORD *rec = eptr->ExceptionRecord;
  39     return (rec->ExceptionCode == DBG_PRINTEXCEPTION_C) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
  40 }
  41
  42 /***********************************************************************
  43  *           OutputDebugStringA   (KERNEL32.@)
  44  *
  45  * Duplicate since IMVU doesn't like it if we call kernelbase.OutputDebugStringA.
  46  */
  47 void WINAPI DECLSPEC_HOTPATCH OutputDebugStringA( LPCSTR str )
  48 {
  49     static HANDLE DBWinMutex = NULL;
  50     static BOOL mutex_inited = FALSE;
  51     BOOL caught_by_dbg = TRUE;
  52
  53     if (!str) str = "";
  54     WARN( "%s\n", debugstr_a(str) );
  55
  56     /* raise exception, WaitForDebugEvent() will generate a corresponding debug event */
  57     __TRY
  58     {
  59         ULONG_PTR args[2];
  60         args[0] = strlen(str) + 1;
  61         args[1] = (ULONG_PTR)str;
  62         RaiseException( DBG_PRINTEXCEPTION_C, 0, 2, args );
  63     }
  64     __EXCEPT(debug_exception_handler)
  65     {
  66         caught_by_dbg = FALSE;
  67     }
  68     __ENDTRY
  69     if (caught_by_dbg) return;
  70
  71     /* send string to a system-wide monitor */
  72     if (!mutex_inited)
  73     {
  74         /* first call to OutputDebugString, initialize mutex handle */
  75         static const WCHAR mutexname[] = {'D','B','W','i','n','M','u','t','e','x',0};
  76         HANDLE mutex = CreateMutexExW( NULL, mutexname, 0, SYNCHRONIZE );
  77         if (mutex)
  78         {
  79             if (InterlockedCompareExchangePointer( &DBWinMutex, mutex, 0 ) != 0)
  80                 /* someone beat us here... */
  81                 CloseHandle( mutex );
  82         }
  83         mutex_inited = TRUE;
  84     }
  85
  86     if (DBWinMutex)
  87     {
  88         static const WCHAR shmname[] = {'D','B','W','I','N','_','B','U','F','F','E','R',0};
  89         static const WCHAR eventbuffername[] = {'D','B','W','I','N','_','B','U','F','F','E','R','_','R','E','A','D','Y',0};
  90         static const WCHAR eventdataname[] = {'D','B','W','I','N','_','D','A','T','A','_','R','E','A','D','Y',0};
  91         HANDLE mapping;
  92
  93         mapping = OpenFileMappingW( FILE_MAP_WRITE, FALSE, shmname );
  94         if (mapping)
  95         {
  96             LPVOID buffer;
  97             HANDLE eventbuffer, eventdata;
  98
  99             buffer = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
 100             eventbuffer = OpenEventW( SYNCHRONIZE, FALSE, eventbuffername );
 101             eventdata = OpenEventW( EVENT_MODIFY_STATE, FALSE, eventdataname );
 102
 103             if (buffer && eventbuffer && eventdata)
 104             {
 105                 /* monitor is present, synchronize with other OutputDebugString invocations */
 106                 WaitForSingleObject( DBWinMutex, INFINITE );
 107
 108                 /* acquire control over the buffer */
 109                 if (WaitForSingleObject( eventbuffer, 10000 ) == WAIT_OBJECT_0)
 110                 {
 111                     int str_len = strlen( str );
 112                     struct _mon_buffer_t
 113                     {
 114                         DWORD pid;
 115                         char buffer[1];
 116                     } *mon_buffer = (struct _mon_buffer_t*) buffer;
 117
 118                     if (str_len > (4096 - sizeof(DWORD) - 1)) str_len = 4096 - sizeof(DWORD) - 1;
 119                     mon_buffer->pid = GetCurrentProcessId();
 120                     memcpy( mon_buffer->buffer, str, str_len );
 121                     mon_buffer->buffer[str_len] = 0;
 122
 123                     /* signal data ready */
 124                     SetEvent( eventdata );
 125                 }
 126                 ReleaseMutex( DBWinMutex );
 127             }
 128
 129             if (buffer) UnmapViewOfFile( buffer );
 130             if (eventbuffer) CloseHandle( eventbuffer );
 131             if (eventdata) CloseHandle( eventdata );
 132             CloseHandle( mapping );
 133         }
 134     }
 135 }
 136
 137
 138 /***********************************************************************
 139  *           DebugBreakProcess   (KERNEL32.@)
 140  *
 141  *  Raises an exception so that a debugger (if attached)
 142  *  can take some action. Same as DebugBreak, but applies to any process.
 143  *
 144  * PARAMS
 145  *  hProc [I] Process to break into.
 146  *
 147  * RETURNS
 148  *
 149  *  True if successful.
 150  */
 151 BOOL WINAPI DebugBreakProcess(HANDLE process)
 152 {
 153     NTSTATUS status;
 154
 155     TRACE("(%p)\n", process);
 156
 157     status = DbgUiIssueRemoteBreakin(process);
 158     if (status) SetLastError(RtlNtStatusToDosError(status));
 159     return !status;
 160 }
 161
 162
 163 /***********************************************************************
 164  *           DebugSetProcessKillOnExit                    (KERNEL32.@)
 165  *
 166  * Let a debugger decide whether a debuggee will be killed upon debugger
 167  * termination.
 168  *
 169  * PARAMS
 170  *  kill [I] If set to true then kill the process on exit.
 171  *
 172  * RETURNS
 173  *  True if successful, false otherwise.
 174  */
 175 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
 176 {
 177     BOOL ret = FALSE;
 178
 179     SERVER_START_REQ( set_debugger_kill_on_exit )
 180     {
 181         req->kill_on_exit = kill;
 182         ret = !wine_server_call_err( req );
 183     }
 184     SERVER_END_REQ;
 185     return ret;
 186 }