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