[CSRSRV]: Fix two DPRINTs.
[reactos.git] / reactos / dll / ntdll / dbg / dbgui.c
1 /*
2 * PROJECT: ReactOS NT Layer/System API
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: dll/ntdll/dbg/dbgui.c
5 * PURPOSE: Native Wrappers for the NT Debug Implementation
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #include <ntdll.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* FUNCTIONS *****************************************************************/
16
17 /*
18 * @implemented
19 */
20 NTSTATUS
21 NTAPI
22 DbgUiConnectToDbg(VOID)
23 {
24 OBJECT_ATTRIBUTES ObjectAttributes;
25
26 /* Don't connect twice */
27 if (NtCurrentTeb()->DbgSsReserved[1]) return STATUS_SUCCESS;
28
29 /* Setup the Attributes */
30 InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, 0);
31
32 /* Create the object */
33 return ZwCreateDebugObject(&NtCurrentTeb()->DbgSsReserved[1],
34 DEBUG_OBJECT_ALL_ACCESS,
35 &ObjectAttributes,
36 DBGK_KILL_PROCESS_ON_EXIT);
37 }
38
39 /*
40 * @implemented
41 */
42 NTSTATUS
43 NTAPI
44 DbgUiContinue(IN PCLIENT_ID ClientId,
45 IN NTSTATUS ContinueStatus)
46 {
47 /* Tell the kernel object to continue */
48 return ZwDebugContinue(NtCurrentTeb()->DbgSsReserved[1],
49 ClientId,
50 ContinueStatus);
51 }
52
53 /*
54 * @implemented
55 */
56 NTSTATUS
57 NTAPI
58 DbgUiConvertStateChangeStructure(IN PDBGUI_WAIT_STATE_CHANGE WaitStateChange,
59 OUT PVOID Win32DebugEvent)
60 {
61 NTSTATUS Status;
62 OBJECT_ATTRIBUTES ObjectAttributes;
63 THREAD_BASIC_INFORMATION ThreadBasicInfo;
64 LPDEBUG_EVENT DebugEvent = Win32DebugEvent;
65 HANDLE ThreadHandle;
66
67 /* Write common data */
68 DebugEvent->dwProcessId = (DWORD)WaitStateChange->
69 AppClientId.UniqueProcess;
70 DebugEvent->dwThreadId = (DWORD)WaitStateChange->AppClientId.UniqueThread;
71
72 /* Check what kind of even this is */
73 switch (WaitStateChange->NewState)
74 {
75 /* New thread */
76 case DbgCreateThreadStateChange:
77
78 /* Setup Win32 code */
79 DebugEvent->dwDebugEventCode = CREATE_THREAD_DEBUG_EVENT;
80
81 /* Copy data over */
82 DebugEvent->u.CreateThread.hThread =
83 WaitStateChange->StateInfo.CreateThread.HandleToThread;
84 DebugEvent->u.CreateThread.lpStartAddress =
85 WaitStateChange->StateInfo.CreateThread.NewThread.StartAddress;
86
87 /* Query the TEB */
88 Status = NtQueryInformationThread(WaitStateChange->StateInfo.
89 CreateThread.HandleToThread,
90 ThreadBasicInformation,
91 &ThreadBasicInfo,
92 sizeof(ThreadBasicInfo),
93 NULL);
94 if (!NT_SUCCESS(Status))
95 {
96 /* Failed to get PEB address */
97 DebugEvent->u.CreateThread.lpThreadLocalBase = NULL;
98 }
99 else
100 {
101 /* Write PEB Address */
102 DebugEvent->u.CreateThread.lpThreadLocalBase =
103 ThreadBasicInfo.TebBaseAddress;
104 }
105 break;
106
107 /* New process */
108 case DbgCreateProcessStateChange:
109
110 /* Write Win32 debug code */
111 DebugEvent->dwDebugEventCode = CREATE_PROCESS_DEBUG_EVENT;
112
113 /* Copy data over */
114 DebugEvent->u.CreateProcessInfo.hProcess =
115 WaitStateChange->StateInfo.CreateProcessInfo.HandleToProcess;
116 DebugEvent->u.CreateProcessInfo.hThread =
117 WaitStateChange->StateInfo.CreateProcessInfo.HandleToThread;
118 DebugEvent->u.CreateProcessInfo.hFile =
119 WaitStateChange->StateInfo.CreateProcessInfo.NewProcess.
120 FileHandle;
121 DebugEvent->u.CreateProcessInfo.lpBaseOfImage =
122 WaitStateChange->StateInfo.CreateProcessInfo.NewProcess.
123 BaseOfImage;
124 DebugEvent->u.CreateProcessInfo.dwDebugInfoFileOffset =
125 WaitStateChange->StateInfo.CreateProcessInfo.NewProcess.
126 DebugInfoFileOffset;
127 DebugEvent->u.CreateProcessInfo.nDebugInfoSize =
128 WaitStateChange->StateInfo.CreateProcessInfo.NewProcess.
129 DebugInfoSize;
130 DebugEvent->u.CreateProcessInfo.lpStartAddress =
131 WaitStateChange->StateInfo.CreateProcessInfo.NewProcess.
132 InitialThread.StartAddress;
133
134 /* Query TEB address */
135 Status = NtQueryInformationThread(WaitStateChange->StateInfo.
136 CreateProcessInfo.HandleToThread,
137 ThreadBasicInformation,
138 &ThreadBasicInfo,
139 sizeof(ThreadBasicInfo),
140 NULL);
141 if (!NT_SUCCESS(Status))
142 {
143 /* Failed to get PEB address */
144 DebugEvent->u.CreateProcessInfo.lpThreadLocalBase = NULL;
145 }
146 else
147 {
148 /* Write PEB Address */
149 DebugEvent->u.CreateProcessInfo.lpThreadLocalBase =
150 ThreadBasicInfo.TebBaseAddress;
151 }
152
153 /* Clear image name */
154 DebugEvent->u.CreateProcessInfo.lpImageName = NULL;
155 DebugEvent->u.CreateProcessInfo.fUnicode = TRUE;
156 break;
157
158 /* Thread exited */
159 case DbgExitThreadStateChange:
160
161 /* Write the Win32 debug code and the exit status */
162 DebugEvent->dwDebugEventCode = EXIT_THREAD_DEBUG_EVENT;
163 DebugEvent->u.ExitThread.dwExitCode =
164 WaitStateChange->StateInfo.ExitThread.ExitStatus;
165 break;
166
167 /* Process exited */
168 case DbgExitProcessStateChange:
169
170 /* Write the Win32 debug code and the exit status */
171 DebugEvent->dwDebugEventCode = EXIT_PROCESS_DEBUG_EVENT;
172 DebugEvent->u.ExitProcess.dwExitCode =
173 WaitStateChange->StateInfo.ExitProcess.ExitStatus;
174 break;
175
176 /* Any sort of exception */
177 case DbgExceptionStateChange:
178 case DbgBreakpointStateChange:
179 case DbgSingleStepStateChange:
180
181 /* Check if this was a debug print */
182 if (WaitStateChange->StateInfo.Exception.ExceptionRecord.
183 ExceptionCode == DBG_PRINTEXCEPTION_C)
184 {
185 /* Set the Win32 code */
186 DebugEvent->dwDebugEventCode = OUTPUT_DEBUG_STRING_EVENT;
187
188 /* Copy debug string information */
189 DebugEvent->u.DebugString.lpDebugStringData =
190 (PVOID)WaitStateChange->
191 StateInfo.Exception.ExceptionRecord.
192 ExceptionInformation[1];
193 DebugEvent->u.DebugString.nDebugStringLength =
194 WaitStateChange->StateInfo.Exception.ExceptionRecord.
195 ExceptionInformation[0];
196 DebugEvent->u.DebugString.fUnicode = FALSE;
197 }
198 else if (WaitStateChange->StateInfo.Exception.ExceptionRecord.
199 ExceptionCode == DBG_RIPEXCEPTION)
200 {
201 /* Set the Win32 code */
202 DebugEvent->dwDebugEventCode = RIP_EVENT;
203
204 /* Set exception information */
205 DebugEvent->u.RipInfo.dwType =
206 WaitStateChange->StateInfo.Exception.ExceptionRecord.
207 ExceptionInformation[1];
208 DebugEvent->u.RipInfo.dwError =
209 WaitStateChange->StateInfo.Exception.ExceptionRecord.
210 ExceptionInformation[0];
211 }
212 else
213 {
214 /* Otherwise, this is a debug event, copy info over */
215 DebugEvent->dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
216 DebugEvent->u.Exception.ExceptionRecord =
217 WaitStateChange->StateInfo.Exception.ExceptionRecord;
218 DebugEvent->u.Exception.dwFirstChance =
219 WaitStateChange->StateInfo.Exception.FirstChance;
220 }
221 break;
222
223 /* DLL Load */
224 case DbgLoadDllStateChange:
225
226 /* Set the Win32 debug code */
227 DebugEvent->dwDebugEventCode = LOAD_DLL_DEBUG_EVENT;
228
229 /* Copy the rest of the data */
230 DebugEvent->u.LoadDll.lpBaseOfDll =
231 WaitStateChange->StateInfo.LoadDll.BaseOfDll;
232 DebugEvent->u.LoadDll.hFile =
233 WaitStateChange->StateInfo.LoadDll.FileHandle;
234 DebugEvent->u.LoadDll.dwDebugInfoFileOffset =
235 WaitStateChange->StateInfo.LoadDll.DebugInfoFileOffset;
236 DebugEvent->u.LoadDll.nDebugInfoSize =
237 WaitStateChange->StateInfo.LoadDll.DebugInfoSize;
238
239 /* Open the thread */
240 InitializeObjectAttributes(&ObjectAttributes, NULL, 0, NULL, NULL);
241 Status = NtOpenThread(&ThreadHandle,
242 THREAD_QUERY_INFORMATION,
243 &ObjectAttributes,
244 &WaitStateChange->AppClientId);
245 if (NT_SUCCESS(Status))
246 {
247 /* Query thread information */
248 Status = NtQueryInformationThread(ThreadHandle,
249 ThreadBasicInformation,
250 &ThreadBasicInfo,
251 sizeof(ThreadBasicInfo),
252 NULL);
253 NtClose(ThreadHandle);
254 }
255
256 /* Check if we got thread information */
257 if (NT_SUCCESS(Status))
258 {
259 /* Save the image name from the TIB */
260 DebugEvent->u.LoadDll.lpImageName =
261 ((PTEB)ThreadBasicInfo.TebBaseAddress)->
262 NtTib.ArbitraryUserPointer;
263 }
264 else
265 {
266 /* Otherwise, no name */
267 DebugEvent->u.LoadDll.lpImageName = NULL;
268 }
269
270 /* It's Unicode */
271 DebugEvent->u.LoadDll.fUnicode = TRUE;
272 break;
273
274 /* DLL Unload */
275 case DbgUnloadDllStateChange:
276
277 /* Set Win32 code and DLL Base */
278 DebugEvent->dwDebugEventCode = UNLOAD_DLL_DEBUG_EVENT;
279 DebugEvent->u.UnloadDll.lpBaseOfDll =
280 WaitStateChange->StateInfo.UnloadDll.BaseAddress;
281 break;
282
283 /* Anything else, fail */
284 default: return STATUS_UNSUCCESSFUL;
285 }
286
287 /* Return success */
288 return STATUS_SUCCESS;
289 }
290
291 /*
292 * @implemented
293 */
294 NTSTATUS
295 NTAPI
296 DbgUiWaitStateChange(OUT PDBGUI_WAIT_STATE_CHANGE DbgUiWaitStateCange,
297 IN PLARGE_INTEGER TimeOut OPTIONAL)
298 {
299 /* Tell the kernel to wait */
300 return NtWaitForDebugEvent(NtCurrentTeb()->DbgSsReserved[1],
301 TRUE,
302 TimeOut,
303 DbgUiWaitStateCange);
304 }
305
306 /*
307 * @implemented
308 */
309 VOID
310 NTAPI
311 DbgUiRemoteBreakin(VOID)
312 {
313 /* Make sure a debugger is enabled; if so, breakpoint */
314 if (NtCurrentPeb()->BeingDebugged) DbgBreakPoint();
315
316 /* Exit the thread */
317 RtlExitUserThread(STATUS_SUCCESS);
318 }
319
320 /*
321 * @implemented
322 */
323 NTSTATUS
324 NTAPI
325 DbgUiIssueRemoteBreakin(IN HANDLE Process)
326 {
327 HANDLE hThread;
328 CLIENT_ID ClientId;
329 NTSTATUS Status;
330
331 /* Create the thread that will do the breakin */
332 Status = RtlCreateUserThread(Process,
333 NULL,
334 FALSE,
335 0,
336 0,
337 PAGE_SIZE,
338 (PVOID)DbgUiRemoteBreakin,
339 NULL,
340 &hThread,
341 &ClientId);
342
343 /* Close the handle on success */
344 if(NT_SUCCESS(Status)) NtClose(hThread);
345
346 /* Return status */
347 return Status;
348 }
349
350 /*
351 * @implemented
352 */
353 HANDLE
354 NTAPI
355 DbgUiGetThreadDebugObject(VOID)
356 {
357 /* Just return the handle from the TEB */
358 return NtCurrentTeb()->DbgSsReserved[1];
359 }
360
361 /*
362 * @implemented
363 */
364 VOID
365 NTAPI
366 DbgUiSetThreadDebugObject(HANDLE DebugObject)
367 {
368 /* Just set the handle in the TEB */
369 NtCurrentTeb()->DbgSsReserved[1] = DebugObject;
370 }
371
372 /*
373 * @implemented
374 */
375 NTSTATUS
376 NTAPI
377 DbgUiDebugActiveProcess(IN HANDLE Process)
378 {
379 NTSTATUS Status;
380
381 /* Tell the kernel to start debugging */
382 Status = NtDebugActiveProcess(Process, NtCurrentTeb()->DbgSsReserved[1]);
383 if (NT_SUCCESS(Status))
384 {
385 /* Now break-in the process */
386 Status = DbgUiIssueRemoteBreakin(Process);
387 if (!NT_SUCCESS(Status))
388 {
389 /* We couldn't break-in, cancel debugging */
390 DbgUiStopDebugging(Process);
391 }
392 }
393
394 /* Return status */
395 return Status;
396 }
397
398 /*
399 * @implemented
400 */
401 NTSTATUS
402 NTAPI
403 DbgUiStopDebugging(IN HANDLE Process)
404 {
405 /* Call the kernel to remove the debug object */
406 return NtRemoveProcessDebug(Process, NtCurrentTeb()->DbgSsReserved[1]);
407 }
408
409 /* EOF */