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 "ntstatus.h"
25 #define WIN32_NO_STATUS
26 #include "winerror.h"
27 #include "wine/server.h"
28 #include "kernel_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 = FALSE;
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 static HANDLE DBWinMutex = NULL;
245 static BOOL mutex_inited = FALSE;
246
247 /* send string to attached debugger */
248 SERVER_START_REQ( output_debug_string )
249 {
250 req->string = wine_server_client_ptr( str );
251 req->length = strlen(str) + 1;
252 wine_server_call( req );
253 }
254 SERVER_END_REQ;
255
256 WARN("%s\n", str);
257
258 /* send string to a system-wide monitor */
259 /* FIXME should only send to monitor if no debuggers are attached */
260
261 if (!mutex_inited)
262 {
263 /* first call to OutputDebugString, initialize mutex handle */
264 static const WCHAR mutexname[] = {'D','B','W','i','n','M','u','t','e','x',0};
265 HANDLE mutex = CreateMutexExW( NULL, mutexname, 0, SYNCHRONIZE );
266 if (mutex)
267 {
268 if (InterlockedCompareExchangePointer( &DBWinMutex, mutex, 0 ) != 0)
269 {
270 /* someone beat us here... */
271 CloseHandle( mutex );
272 }
273 }
274 mutex_inited = TRUE;
275 }
276
277 if (DBWinMutex)
278 {
279 static const WCHAR shmname[] = {'D','B','W','I','N','_','B','U','F','F','E','R',0};
280 static const WCHAR eventbuffername[] = {'D','B','W','I','N','_','B','U','F','F','E','R','_','R','E','A','D','Y',0};
281 static const WCHAR eventdataname[] = {'D','B','W','I','N','_','D','A','T','A','_','R','E','A','D','Y',0};
282 HANDLE mapping;
283
284 mapping = OpenFileMappingW( FILE_MAP_WRITE, FALSE, shmname );
285 if (mapping)
286 {
287 LPVOID buffer;
288 HANDLE eventbuffer, eventdata;
289
290 buffer = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
291 eventbuffer = OpenEventW( SYNCHRONIZE, FALSE, eventbuffername );
292 eventdata = OpenEventW( EVENT_MODIFY_STATE, FALSE, eventdataname );
293
294 if (buffer && eventbuffer && eventdata)
295 {
296 /* monitor is present, synchronize with other OutputDebugString invokations */
297 WaitForSingleObject( DBWinMutex, INFINITE );
298
299 /* acquire control over the buffer */
300 if (WaitForSingleObject( eventbuffer, 10000 ) == WAIT_OBJECT_0)
301 {
302 int str_len;
303 struct _mon_buffer_t {
304 DWORD pid;
305 char buffer[1];
306 } *mon_buffer = (struct _mon_buffer_t*) buffer;
307
308 str_len = strlen( str );
309 if (str_len > (4096 - sizeof(DWORD) - 1))
310 str_len = 4096 - sizeof(DWORD) - 1;
311
312 mon_buffer->pid = GetCurrentProcessId();
313 memcpy( mon_buffer->buffer, str, str_len );
314 mon_buffer->buffer[str_len] = 0;
315
316 /* signal data ready */
317 SetEvent( eventdata );
318 }
319 ReleaseMutex( DBWinMutex );
320 }
321
322 if (buffer)
323 UnmapViewOfFile( buffer );
324 if (eventbuffer)
325 CloseHandle( eventbuffer );
326 if (eventdata)
327 CloseHandle( eventdata );
328 CloseHandle( mapping );
329 }
330 }
331 }
332
333
334 /***********************************************************************
335 * OutputDebugStringW (KERNEL32.@)
336 *
337 * Output by an application of a unicode string to a debugger (if attached)
338 * and program log.
339 *
340 * PARAMS
341 * str [I] The message to be logged and given to the debugger.
342 *
343 * RETURNS
344 *
345 * Nothing.
346 */
347 void WINAPI OutputDebugStringW( LPCWSTR str )
348 {
349 UNICODE_STRING strW;
350 STRING strA;
351
352 RtlInitUnicodeString( &strW, str );
353 if (!RtlUnicodeStringToAnsiString( &strA, &strW, TRUE ))
354 {
355 OutputDebugStringA( strA.Buffer );
356 RtlFreeAnsiString( &strA );
357 }
358 }
359
360
361 /***********************************************************************
362 * DebugBreak (KERNEL32.@)
363 *
364 * Raises an exception so that a debugger (if attached)
365 * can take some action.
366 *
367 * PARAMS
368 *
369 * RETURNS
370 */
371 void WINAPI DebugBreak(void)
372 {
373 DbgBreakPoint();
374 }
375
376 /***********************************************************************
377 * DebugBreakProcess (KERNEL32.@)
378 *
379 * Raises an exception so that a debugger (if attached)
380 * can take some action. Same as DebugBreak, but applies to any process.
381 *
382 * PARAMS
383 * hProc [I] Process to break into.
384 *
385 * RETURNS
386 *
387 * True if successful.
388 */
389 BOOL WINAPI DebugBreakProcess(HANDLE hProc)
390 {
391 BOOL ret, self;
392
393 TRACE("(%p)\n", hProc);
394
395 SERVER_START_REQ( debug_break )
396 {
397 req->handle = wine_server_obj_handle( hProc );
398 ret = !wine_server_call_err( req );
399 self = ret && reply->self;
400 }
401 SERVER_END_REQ;
402 if (self) DbgBreakPoint();
403 return ret;
404 }
405
406
407 /***********************************************************************
408 * IsDebuggerPresent (KERNEL32.@)
409 *
410 * Allows a process to determine if there is a debugger attached.
411 *
412 * PARAMS
413 *
414 * RETURNS
415 *
416 * True if there is a debugger attached.
417 */
418 BOOL WINAPI IsDebuggerPresent(void)
419 {
420 return NtCurrentTeb()->Peb->BeingDebugged;
421 }
422
423 /***********************************************************************
424 * CheckRemoteDebuggerPresent (KERNEL32.@)
425 *
426 * Allows a process to determine if there is a remote debugger
427 * attached.
428 *
429 * PARAMS
430 *
431 * RETURNS
432 *
433 * TRUE because it is a stub.
434 */
435 BOOL WINAPI CheckRemoteDebuggerPresent(HANDLE process, PBOOL DebuggerPresent)
436 {
437 NTSTATUS status;
438 DWORD_PTR port;
439
440 if(!process || !DebuggerPresent)
441 {
442 SetLastError(ERROR_INVALID_PARAMETER);
443 return FALSE;
444 }
445
446 status = NtQueryInformationProcess(process, ProcessDebugPort, &port, sizeof(port), NULL);
447 if (status != STATUS_SUCCESS)
448 {
449 SetLastError(RtlNtStatusToDosError(status));
450 return FALSE;
451 }
452
453 *DebuggerPresent = !!port;
454 return TRUE;
455 }
456
457 /***********************************************************************
458 * DebugSetProcessKillOnExit (KERNEL32.@)
459 *
460 * Let a debugger decide whether a debuggee will be killed upon debugger
461 * termination.
462 *
463 * PARAMS
464 * kill [I] If set to true then kill the process on exit.
465 *
466 * RETURNS
467 * True if successful, false otherwise.
468 */
469 BOOL WINAPI DebugSetProcessKillOnExit(BOOL kill)
470 {
471 BOOL ret = FALSE;
472
473 SERVER_START_REQ( set_debugger_kill_on_exit )
474 {
475 req->kill_on_exit = kill;
476 ret = !wine_server_call_err( req );
477 }
478 SERVER_END_REQ;
479 return ret;
480 }
481
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.