d1601fcae771837fb6bbb548006d75e31b0b1736
[reactos.git] / dll / win32 / mscoree / cordebug.c
1 /*
2 *
3 * Copyright 2011 Alistair Leslie-Hughes
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "mscoree_private.h"
21
22 typedef struct DebugProcess
23 {
24 ICorDebugProcess ICorDebugProcess_iface;
25
26 CorDebug *cordebug;
27
28 DWORD dwProcessID;
29 HANDLE handle;
30 HANDLE thread;
31
32 LONG ref;
33 } DebugProcess;
34
35 static inline CorDebug *impl_from_ICorDebug( ICorDebug *iface )
36 {
37 return CONTAINING_RECORD(iface, CorDebug, ICorDebug_iface);
38 }
39
40 static inline CorDebug *impl_from_ICorDebugProcessEnum( ICorDebugProcessEnum *iface )
41 {
42 return CONTAINING_RECORD(iface, CorDebug, ICorDebugProcessEnum_iface);
43 }
44
45 static inline DebugProcess *impl_from_ICorDebugProcess( ICorDebugProcess *iface )
46 {
47 return CONTAINING_RECORD(iface, DebugProcess, ICorDebugProcess_iface);
48 }
49
50 /* ICorDebugProcess Interface */
51 static HRESULT WINAPI cordebugprocess_QueryInterface(ICorDebugProcess *iface,
52 REFIID riid, void **ppvObject)
53 {
54 DebugProcess *This = impl_from_ICorDebugProcess(iface);
55
56 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
57
58 if ( IsEqualGUID( riid, &IID_ICorDebugProcess ) ||
59 IsEqualGUID( riid, &IID_ICorDebugController ) ||
60 IsEqualGUID( riid, &IID_IUnknown ) )
61 {
62 *ppvObject = &This->ICorDebugProcess_iface;
63 }
64 else
65 {
66 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
67 return E_NOINTERFACE;
68 }
69
70 ICorDebug_AddRef(iface);
71
72 return S_OK;
73 }
74
75 static ULONG WINAPI cordebugprocess_AddRef(ICorDebugProcess *iface)
76 {
77 DebugProcess *This = impl_from_ICorDebugProcess(iface);
78 ULONG ref = InterlockedIncrement(&This->ref);
79
80 TRACE("%p ref=%u\n", This, ref);
81
82 return ref;
83 }
84
85 static ULONG WINAPI cordebugprocess_Release(ICorDebugProcess *iface)
86 {
87 DebugProcess *This = impl_from_ICorDebugProcess(iface);
88 ULONG ref = InterlockedDecrement(&This->ref);
89
90 TRACE("%p ref=%u\n", This, ref);
91
92 if (ref == 0)
93 {
94 if(This->handle)
95 CloseHandle(This->handle);
96
97 if(This->thread)
98 CloseHandle(This->thread);
99
100 if(This->cordebug)
101 ICorDebug_Release(&This->cordebug->ICorDebug_iface);
102
103 HeapFree(GetProcessHeap(), 0, This);
104 }
105
106 return ref;
107 }
108
109 static HRESULT WINAPI cordebugprocess_Stop(ICorDebugProcess *iface, DWORD dwTimeoutIgnored)
110 {
111 DebugProcess *This = impl_from_ICorDebugProcess(iface);
112 FIXME("stub %p\n", This);
113 return E_NOTIMPL;
114 }
115
116 static HRESULT WINAPI cordebugprocess_Continue(ICorDebugProcess *iface, BOOL fIsOutOfBand)
117 {
118 DebugProcess *This = impl_from_ICorDebugProcess(iface);
119 TRACE("%p\n", This);
120
121 if(This->thread)
122 ResumeThread(This->thread);
123
124 return S_OK;
125 }
126
127 static HRESULT WINAPI cordebugprocess_IsRunning(ICorDebugProcess *iface, BOOL *pbRunning)
128 {
129 DebugProcess *This = impl_from_ICorDebugProcess(iface);
130 FIXME("stub %p\n", This);
131 return E_NOTIMPL;
132 }
133
134 static HRESULT WINAPI cordebugprocess_HasQueuedCallbacks(ICorDebugProcess *iface,
135 ICorDebugThread *pThread, BOOL *pbQueued)
136 {
137 DebugProcess *This = impl_from_ICorDebugProcess(iface);
138 FIXME("stub %p\n", This);
139 return E_NOTIMPL;
140 }
141
142 static HRESULT WINAPI cordebugprocess_EnumerateThreads(ICorDebugProcess *iface,
143 ICorDebugThreadEnum **ppThreads)
144 {
145 DebugProcess *This = impl_from_ICorDebugProcess(iface);
146 FIXME("stub %p\n", This);
147 return E_NOTIMPL;
148 }
149
150 static HRESULT WINAPI cordebugprocess_SetAllThreadsDebugState(ICorDebugProcess *iface,
151 CorDebugThreadState state, ICorDebugThread *pExceptThisThread)
152 {
153 DebugProcess *This = impl_from_ICorDebugProcess(iface);
154 FIXME("stub %p\n", This);
155 return E_NOTIMPL;
156 }
157
158 static HRESULT WINAPI cordebugprocess_Detach(ICorDebugProcess *iface)
159 {
160 DebugProcess *This = impl_from_ICorDebugProcess(iface);
161 FIXME("stub %p\n", This);
162 return E_NOTIMPL;
163 }
164
165 static HRESULT WINAPI cordebugprocess_Terminate(ICorDebugProcess *iface, UINT exitCode)
166 {
167 DebugProcess *This = impl_from_ICorDebugProcess(iface);
168 BOOL ret = TRUE;
169
170 TRACE("%p\n", This);
171
172 if(This->handle)
173 {
174 ret = TerminateProcess(This->handle, exitCode);
175 CloseHandle(This->handle);
176 This->handle = NULL;
177 }
178 return ret ? S_OK : E_FAIL;
179 }
180
181 static HRESULT WINAPI cordebugprocess_CanCommitChanges(ICorDebugProcess *iface,
182 ULONG cSnapshots, ICorDebugEditAndContinueSnapshot * pSnapshots[],
183 ICorDebugErrorInfoEnum **pError)
184 {
185 DebugProcess *This = impl_from_ICorDebugProcess(iface);
186 FIXME("stub %p\n", This);
187 return E_NOTIMPL;
188 }
189
190 static HRESULT WINAPI cordebugprocess_CommitChanges(ICorDebugProcess *iface,
191 ULONG cSnapshots, ICorDebugEditAndContinueSnapshot * pSnapshots[],
192 ICorDebugErrorInfoEnum **pError)
193 {
194 DebugProcess *This = impl_from_ICorDebugProcess(iface);
195 FIXME("stub %p\n", This);
196 return E_NOTIMPL;
197 }
198
199 static HRESULT WINAPI cordebugprocess_GetID(ICorDebugProcess *iface, DWORD *pdwProcessId)
200 {
201 DebugProcess *This = impl_from_ICorDebugProcess(iface);
202 TRACE("%p\n", This);
203
204 if(!pdwProcessId)
205 return E_INVALIDARG;
206
207 *pdwProcessId = This->dwProcessID;
208
209 return S_OK;
210 }
211
212 static HRESULT WINAPI cordebugprocess_GetHandle(ICorDebugProcess *iface, HPROCESS *phProcessHandle)
213 {
214 DebugProcess *This = impl_from_ICorDebugProcess(iface);
215 TRACE("%p\n", This);
216
217 if(!phProcessHandle)
218 return E_INVALIDARG;
219
220 *phProcessHandle = This->handle;
221
222 return S_OK;
223 }
224
225 static HRESULT WINAPI cordebugprocess_GetThread(ICorDebugProcess *iface, DWORD dwThreadId,
226 ICorDebugThread **ppThread)
227 {
228 DebugProcess *This = impl_from_ICorDebugProcess(iface);
229 FIXME("stub %p\n", This);
230 return E_NOTIMPL;
231 }
232
233 static HRESULT WINAPI cordebugprocess_EnumerateObjects(ICorDebugProcess *iface,
234 ICorDebugObjectEnum **ppObjects)
235 {
236 DebugProcess *This = impl_from_ICorDebugProcess(iface);
237 FIXME("stub %p\n", This);
238 return E_NOTIMPL;
239 }
240
241 static HRESULT WINAPI cordebugprocess_IsTransitionStub(ICorDebugProcess *iface,
242 CORDB_ADDRESS address, BOOL *pbTransitionStub)
243 {
244 DebugProcess *This = impl_from_ICorDebugProcess(iface);
245 FIXME("stub %p\n", This);
246 return E_NOTIMPL;
247 }
248
249 static HRESULT WINAPI cordebugprocess_IsOSSuspended(ICorDebugProcess *iface,
250 DWORD threadID, BOOL *pbSuspended)
251 {
252 DebugProcess *This = impl_from_ICorDebugProcess(iface);
253 FIXME("stub %p\n", This);
254 return E_NOTIMPL;
255 }
256
257 static HRESULT WINAPI cordebugprocess_GetThreadContext(ICorDebugProcess *iface,
258 DWORD threadID, ULONG32 contextSize, BYTE context[])
259 {
260 DebugProcess *This = impl_from_ICorDebugProcess(iface);
261 FIXME("stub %p\n", This);
262 return E_NOTIMPL;
263 }
264
265 static HRESULT WINAPI cordebugprocess_SetThreadContext(ICorDebugProcess *iface,
266 DWORD threadID, ULONG32 contextSize, BYTE context[])
267 {
268 DebugProcess *This = impl_from_ICorDebugProcess(iface);
269 FIXME("stub %p\n", This);
270 return E_NOTIMPL;
271 }
272
273 static HRESULT WINAPI cordebugprocess_ReadMemory(ICorDebugProcess *iface,
274 CORDB_ADDRESS address, DWORD size, BYTE buffer[],
275 SIZE_T *read)
276 {
277 DebugProcess *This = impl_from_ICorDebugProcess(iface);
278 FIXME("stub %p\n", This);
279 return E_NOTIMPL;
280 }
281
282 static HRESULT WINAPI cordebugprocess_WriteMemory(ICorDebugProcess *iface,
283 CORDB_ADDRESS address, DWORD size, BYTE buffer[],
284 SIZE_T *written)
285 {
286 DebugProcess *This = impl_from_ICorDebugProcess(iface);
287 FIXME("stub %p\n", This);
288 return E_NOTIMPL;
289 }
290
291 static HRESULT WINAPI cordebugprocess_ClearCurrentException(ICorDebugProcess *iface,
292 DWORD threadID)
293 {
294 DebugProcess *This = impl_from_ICorDebugProcess(iface);
295 FIXME("stub %p\n", This);
296 return E_NOTIMPL;
297 }
298
299 static HRESULT WINAPI cordebugprocess_EnableLogMessages(ICorDebugProcess *iface,
300 BOOL fOnOff)
301 {
302 DebugProcess *This = impl_from_ICorDebugProcess(iface);
303 FIXME("stub %p\n", This);
304 return E_NOTIMPL;
305 }
306
307 static HRESULT WINAPI cordebugprocess_ModifyLogSwitch(ICorDebugProcess *iface,
308 WCHAR *pLogSwitchName, LONG lLevel)
309 {
310 DebugProcess *This = impl_from_ICorDebugProcess(iface);
311 FIXME("stub %p\n", This);
312 return E_NOTIMPL;
313 }
314
315 static HRESULT WINAPI cordebugprocess_EnumerateAppDomains(ICorDebugProcess *iface,
316 ICorDebugAppDomainEnum **ppAppDomains)
317 {
318 DebugProcess *This = impl_from_ICorDebugProcess(iface);
319 FIXME("stub %p\n", This);
320 return E_NOTIMPL;
321 }
322
323 static HRESULT WINAPI cordebugprocess_GetObject(ICorDebugProcess *iface,
324 ICorDebugValue **ppObject)
325 {
326 DebugProcess *This = impl_from_ICorDebugProcess(iface);
327 FIXME("stub %p\n", This);
328 return E_NOTIMPL;
329 }
330
331 static HRESULT WINAPI cordebugprocess_ThreadForFiberCookie(ICorDebugProcess *iface,
332 DWORD fiberCookie, ICorDebugThread **ppThread)
333 {
334 DebugProcess *This = impl_from_ICorDebugProcess(iface);
335 FIXME("stub %p\n", This);
336 return E_NOTIMPL;
337 }
338
339 static HRESULT WINAPI cordebugprocess_GetHelperThreadID(ICorDebugProcess *iface,
340 DWORD *pThreadID)
341 {
342 DebugProcess *This = impl_from_ICorDebugProcess(iface);
343 FIXME("stub %p\n", This);
344 return E_NOTIMPL;
345 }
346
347
348 /***************************************/
349 static const ICorDebugProcessVtbl cordebugprocessVtbl = {
350 cordebugprocess_QueryInterface,
351 cordebugprocess_AddRef,
352 cordebugprocess_Release,
353 cordebugprocess_Stop,
354 cordebugprocess_Continue,
355 cordebugprocess_IsRunning,
356 cordebugprocess_HasQueuedCallbacks,
357 cordebugprocess_EnumerateThreads,
358 cordebugprocess_SetAllThreadsDebugState,
359 cordebugprocess_Detach,
360 cordebugprocess_Terminate,
361 cordebugprocess_CanCommitChanges,
362 cordebugprocess_CommitChanges,
363 cordebugprocess_GetID,
364 cordebugprocess_GetHandle,
365 cordebugprocess_GetThread,
366 cordebugprocess_EnumerateObjects,
367 cordebugprocess_IsTransitionStub,
368 cordebugprocess_IsOSSuspended,
369 cordebugprocess_GetThreadContext,
370 cordebugprocess_SetThreadContext,
371 cordebugprocess_ReadMemory,
372 cordebugprocess_WriteMemory,
373 cordebugprocess_ClearCurrentException,
374 cordebugprocess_EnableLogMessages,
375 cordebugprocess_ModifyLogSwitch,
376 cordebugprocess_EnumerateAppDomains,
377 cordebugprocess_GetObject,
378 cordebugprocess_ThreadForFiberCookie,
379 cordebugprocess_GetHelperThreadID
380 };
381
382
383 static HRESULT CorDebugProcess_Create(CorDebug *cordebug, IUnknown** ppUnk, LPPROCESS_INFORMATION lpProcessInformation)
384 {
385 DebugProcess *This;
386
387 This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
388 if ( !This )
389 return E_OUTOFMEMORY;
390
391 if(!DuplicateHandle(GetCurrentProcess(), lpProcessInformation->hProcess,
392 GetCurrentProcess(), &This->handle, 0, FALSE, DUPLICATE_SAME_ACCESS))
393 {
394 ERR("Failed to duplicate process handle\n");
395 HeapFree(GetProcessHeap(), 0, This);
396 return E_FAIL;
397 }
398 if(!DuplicateHandle(GetCurrentProcess(), lpProcessInformation->hThread,
399 GetCurrentProcess(), &This->thread, 0, FALSE, DUPLICATE_SAME_ACCESS))
400 {
401 CloseHandle(This->handle);
402
403 ERR("Failed to duplicate thread handle\n");
404 HeapFree(GetProcessHeap(), 0, This);
405 return E_FAIL;
406 }
407
408 This->ICorDebugProcess_iface.lpVtbl = &cordebugprocessVtbl;
409 This->ref = 1;
410 This->cordebug = cordebug;
411 This->dwProcessID = lpProcessInformation->dwProcessId;
412
413 if(This->cordebug)
414 ICorDebug_AddRef(&This->cordebug->ICorDebug_iface);
415
416 *ppUnk = (IUnknown*)This;
417
418 return S_OK;
419 }
420
421 /* ICorDebugProcessEnum Interface */
422 static HRESULT WINAPI process_enum_QueryInterface(ICorDebugProcessEnum *iface, REFIID riid, void **ppvObject)
423 {
424 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
425
426 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
427
428 if ( IsEqualGUID( riid, &IID_ICorDebugProcessEnum ) ||
429 IsEqualGUID( riid, &IID_ICorDebugEnum ) ||
430 IsEqualGUID( riid, &IID_IUnknown ) )
431 {
432 *ppvObject = &This->ICorDebugProcessEnum_iface;
433 }
434 else
435 {
436 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
437 return E_NOINTERFACE;
438 }
439
440 ICorDebug_AddRef(iface);
441
442 return S_OK;
443 }
444
445 static ULONG WINAPI process_enum_AddRef(ICorDebugProcessEnum *iface)
446 {
447 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
448 TRACE("%p ref=%u\n", This, This->ref);
449
450 return ICorDebug_AddRef(&This->ICorDebug_iface);
451 }
452
453 static ULONG WINAPI process_enum_Release(ICorDebugProcessEnum *iface)
454 {
455 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
456 TRACE("%p ref=%u\n", This, This->ref);
457
458 return ICorDebug_Release(&This->ICorDebug_iface);
459 }
460
461 static HRESULT WINAPI process_enum_Skip(ICorDebugProcessEnum *iface, ULONG celt)
462 {
463 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
464 FIXME("stub %p\n", This);
465 return E_NOTIMPL;
466 }
467
468 static HRESULT WINAPI process_enum_Reset(ICorDebugProcessEnum *iface)
469 {
470 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
471 FIXME("stub %p\n", This);
472 return E_NOTIMPL;
473 }
474
475 static HRESULT WINAPI process_enum_Clone(ICorDebugProcessEnum *iface, ICorDebugEnum **ppEnum)
476 {
477 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
478 FIXME("stub %p %p\n", This, ppEnum);
479 return E_NOTIMPL;
480 }
481
482 static HRESULT WINAPI process_enum_GetCount(ICorDebugProcessEnum *iface, ULONG *pcelt)
483 {
484 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
485 TRACE("stub %p %p\n", This, pcelt);
486
487 if(!pcelt)
488 return E_INVALIDARG;
489
490 *pcelt = list_count(&This->processes);
491
492 return S_OK;
493 }
494
495 static HRESULT WINAPI process_enum_Next(ICorDebugProcessEnum *iface, ULONG celt,
496 ICorDebugProcess * processes[], ULONG *pceltFetched)
497 {
498 CorDebug *This = impl_from_ICorDebugProcessEnum(iface);
499 FIXME("stub %p %d %p %p\n", This, celt, processes, pceltFetched);
500 return E_NOTIMPL;
501 }
502
503 static const struct ICorDebugProcessEnumVtbl processenum_vtbl =
504 {
505 process_enum_QueryInterface,
506 process_enum_AddRef,
507 process_enum_Release,
508 process_enum_Skip,
509 process_enum_Reset,
510 process_enum_Clone,
511 process_enum_GetCount,
512 process_enum_Next
513 };
514
515 /*** IUnknown methods ***/
516 static HRESULT WINAPI CorDebug_QueryInterface(ICorDebug *iface, REFIID riid, void **ppvObject)
517 {
518 CorDebug *This = impl_from_ICorDebug( iface );
519
520 TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
521
522 if ( IsEqualGUID( riid, &IID_ICorDebug ) ||
523 IsEqualGUID( riid, &IID_IUnknown ) )
524 {
525 *ppvObject = &This->ICorDebug_iface;
526 }
527 else
528 {
529 FIXME("Unsupported interface %s\n", debugstr_guid(riid));
530 return E_NOINTERFACE;
531 }
532
533 ICorDebug_AddRef( iface );
534
535 return S_OK;
536 }
537
538 static ULONG WINAPI CorDebug_AddRef(ICorDebug *iface)
539 {
540 CorDebug *This = impl_from_ICorDebug( iface );
541 ULONG ref = InterlockedIncrement(&This->ref);
542
543 TRACE("%p ref=%u\n", This, ref);
544
545 return ref;
546 }
547
548 static ULONG WINAPI CorDebug_Release(ICorDebug *iface)
549 {
550 CorDebug *This = impl_from_ICorDebug( iface );
551 ULONG ref = InterlockedDecrement(&This->ref);
552
553 TRACE("%p ref=%u\n", This, ref);
554
555 if (ref == 0)
556 {
557 if(!list_empty(&This->processes))
558 ERR("Processes haven't been removed Correctly\n");
559
560 if(This->runtimehost)
561 ICLRRuntimeHost_Release(This->runtimehost);
562
563 if(This->pCallback)
564 ICorDebugManagedCallback2_Release(This->pCallback2);
565
566 if(This->pCallback)
567 ICorDebugManagedCallback_Release(This->pCallback);
568
569 HeapFree(GetProcessHeap(), 0, This);
570 }
571
572 return ref;
573 }
574
575 /*** ICorDebug methods ***/
576 static HRESULT WINAPI CorDebug_Initialize(ICorDebug *iface)
577 {
578 CorDebug *This = impl_from_ICorDebug( iface );
579 FIXME("stub %p\n", This);
580 return S_OK;
581 }
582
583 static HRESULT WINAPI CorDebug_Terminate(ICorDebug *iface)
584 {
585 struct CorProcess *cursor, *cursor2;
586 CorDebug *This = impl_from_ICorDebug( iface );
587 TRACE("stub %p\n", This);
588
589 LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &This->processes, struct CorProcess, entry)
590 {
591 if(cursor->pProcess)
592 {
593 ICorDebugProcess_Terminate(cursor->pProcess, 0);
594 ICorDebugProcess_Release(cursor->pProcess);
595 }
596
597 list_remove(&cursor->entry);
598 HeapFree(GetProcessHeap(), 0, cursor);
599 }
600
601 return S_OK;
602 }
603
604 static HRESULT WINAPI CorDebug_SetManagedHandler(ICorDebug *iface, ICorDebugManagedCallback *pCallback)
605 {
606 CorDebug *This = impl_from_ICorDebug( iface );
607 HRESULT hr;
608 ICorDebugManagedCallback2 *pCallback2;
609
610 TRACE("%p (%p)\n", This, pCallback);
611
612 if(!pCallback)
613 return E_INVALIDARG;
614
615 hr = ICorDebugManagedCallback_QueryInterface(pCallback, &IID_ICorDebugManagedCallback2, (void**)&pCallback2);
616 if(hr == S_OK)
617 {
618 if(This->pCallback2)
619 ICorDebugManagedCallback2_Release(This->pCallback2);
620
621 if(This->pCallback)
622 ICorDebugManagedCallback_Release(This->pCallback);
623
624 This->pCallback = pCallback;
625 This->pCallback2 = pCallback2;
626
627 ICorDebugManagedCallback_AddRef(This->pCallback);
628 }
629 else
630 {
631 WARN("Debugging without interface ICorDebugManagedCallback2 is currently not supported.\n");
632 }
633
634 return hr;
635 }
636
637 static HRESULT WINAPI CorDebug_SetUnmanagedHandler(ICorDebug *iface, ICorDebugUnmanagedCallback *pCallback)
638 {
639 CorDebug *This = impl_from_ICorDebug( iface );
640 FIXME("stub %p %p\n", This, pCallback);
641 return E_NOTIMPL;
642 }
643
644 static HRESULT WINAPI CorDebug_CreateProcess(ICorDebug *iface, LPCWSTR lpApplicationName,
645 LPWSTR lpCommandLine, LPSECURITY_ATTRIBUTES lpProcessAttributes,
646 LPSECURITY_ATTRIBUTES lpThreadAttributes, BOOL bInheritHandles,
647 DWORD dwCreationFlags, PVOID lpEnvironment,LPCWSTR lpCurrentDirectory,
648 LPSTARTUPINFOW lpStartupInfo, LPPROCESS_INFORMATION lpProcessInformation,
649 CorDebugCreateProcessFlags debuggingFlags, ICorDebugProcess **ppProcess)
650 {
651 CorDebug *This = impl_from_ICorDebug( iface );
652 ICorDebugProcess *pDebugProcess;
653 HRESULT hr;
654
655 TRACE("stub %p %s %s %p %p %d %d %p %s %p %p %d %p\n", This, debugstr_w(lpApplicationName),
656 debugstr_w(lpCommandLine), lpProcessAttributes, lpThreadAttributes,
657 bInheritHandles, dwCreationFlags, lpEnvironment, debugstr_w(lpCurrentDirectory),
658 lpStartupInfo, lpProcessInformation, debuggingFlags, ppProcess);
659
660 if(CreateProcessW(lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes,
661 bInheritHandles, dwCreationFlags | CREATE_SUSPENDED, lpEnvironment, lpCurrentDirectory,
662 lpStartupInfo, lpProcessInformation))
663 {
664 hr = CorDebugProcess_Create(This, (IUnknown**)&pDebugProcess, lpProcessInformation);
665 if(hr == S_OK)
666 {
667 struct CorProcess *new_process = HeapAlloc( GetProcessHeap(), 0, sizeof(CorProcess) );
668
669 new_process->pProcess = pDebugProcess;
670 list_add_tail(&This->processes, &new_process->entry);
671
672 ICorDebugProcess_AddRef(pDebugProcess);
673 *ppProcess = pDebugProcess;
674
675 if(This->pCallback)
676 ICorDebugManagedCallback_CreateProcess(This->pCallback, pDebugProcess);
677 }
678 else
679 {
680 TerminateProcess(lpProcessInformation->hProcess, 0);
681 }
682 }
683 else
684 hr = E_FAIL;
685
686 return hr;
687 }
688
689 static HRESULT WINAPI CorDebug_DebugActiveProcess(ICorDebug *iface, DWORD id, BOOL win32Attach,
690 ICorDebugProcess **ppProcess)
691 {
692 CorDebug *This = impl_from_ICorDebug( iface );
693 FIXME("stub %p %d %d %p\n", This, id, win32Attach, ppProcess);
694 return E_NOTIMPL;
695 }
696
697 static HRESULT WINAPI CorDebug_EnumerateProcesses( ICorDebug *iface, ICorDebugProcessEnum **ppProcess)
698 {
699 CorDebug *This = impl_from_ICorDebug( iface );
700 TRACE("stub %p %p\n", This, ppProcess);
701
702 if(!ppProcess)
703 return E_INVALIDARG;
704
705 *ppProcess = &This->ICorDebugProcessEnum_iface;
706 ICorDebugProcessEnum_AddRef(*ppProcess);
707
708 return S_OK;
709 }
710
711 static HRESULT WINAPI CorDebug_GetProcess(ICorDebug *iface, DWORD dwProcessId, ICorDebugProcess **ppProcess)
712 {
713 CorDebug *This = impl_from_ICorDebug( iface );
714 FIXME("stub %p %d %p\n", This, dwProcessId, ppProcess);
715 return E_NOTIMPL;
716 }
717
718 static HRESULT WINAPI CorDebug_CanLaunchOrAttach(ICorDebug *iface, DWORD dwProcessId,
719 BOOL win32DebuggingEnabled)
720 {
721 CorDebug *This = impl_from_ICorDebug( iface );
722 FIXME("stub %p %d %d\n", This, dwProcessId, win32DebuggingEnabled);
723 return S_OK;
724 }
725
726 static const struct ICorDebugVtbl cordebug_vtbl =
727 {
728 CorDebug_QueryInterface,
729 CorDebug_AddRef,
730 CorDebug_Release,
731 CorDebug_Initialize,
732 CorDebug_Terminate,
733 CorDebug_SetManagedHandler,
734 CorDebug_SetUnmanagedHandler,
735 CorDebug_CreateProcess,
736 CorDebug_DebugActiveProcess,
737 CorDebug_EnumerateProcesses,
738 CorDebug_GetProcess,
739 CorDebug_CanLaunchOrAttach
740 };
741
742 HRESULT CorDebug_Create(ICLRRuntimeHost *runtimehost, IUnknown** ppUnk)
743 {
744 CorDebug *This;
745
746 This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
747 if ( !This )
748 return E_OUTOFMEMORY;
749
750 This->ICorDebug_iface.lpVtbl = &cordebug_vtbl;
751 This->ICorDebugProcessEnum_iface.lpVtbl = &processenum_vtbl;
752 This->ref = 1;
753 This->pCallback = NULL;
754 This->pCallback2 = NULL;
755 This->runtimehost = runtimehost;
756
757 list_init(&This->processes);
758
759 if(This->runtimehost)
760 ICLRRuntimeHost_AddRef(This->runtimehost);
761
762 *ppUnk = (IUnknown*)This;
763
764 return S_OK;
765 }