modified base/applications/taskmgr/affinity.c
[reactos.git] / reactos / base / applications / taskmgr / dbgchnl.c
1 /*
2 * ReactOS Task Manager
3 *
4 * dbgchnl.c
5 *
6 * Copyright (C) 2003 - 2004 Eric Pouech
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include <precomp.h>
24
25 /* TODO:
26 * - the dialog box could be non modal
27 * - in that case,
28 * + could refresh channels from time to time
29 * - get a better UI (replace the 'x' by real tick boxes in list view)
30 * - implement a real solution around the get_symbol hack
31 * - enhance visual feedback: the list is large, and it's hard to get the
32 * right line when clicking on rightmost column (trace for example)
33 * - get rid of printfs (error reporting) and use real message boxes
34 * - include the column width settings in the full column management scheme
35 */
36
37 BOOL DebugChannelsAreSupported(void)
38 {
39 #ifdef WINE
40 return TRUE;
41 #endif
42 return FALSE;
43 }
44
45 static int list_channel_CB(HANDLE hProcess, void* addr, WCHAR* buffer, void* user)
46 {
47 int j;
48 WCHAR val[2];
49 LVITEM lvi;
50 int index;
51 HWND hChannelLV = (HWND)user;
52
53 memset(&lvi, 0, sizeof(lvi));
54
55 lvi.mask = LVIF_TEXT;
56 lvi.pszText = buffer + 1;
57
58 index = ListView_InsertItem(hChannelLV, &lvi);
59 if (index == -1) return 0;
60
61 val[1] = L'\0';
62 for (j = 0; j < 4; j++)
63 {
64 val[0] = (buffer[0] & (1 << j)) ? L'x' : L' ';
65 ListView_SetItemText(hChannelLV, index, j + 1, val);
66 }
67 return 1;
68 }
69
70 struct cce_user
71 {
72 LPCWSTR name; /* channel to look for */
73 unsigned value, mask; /* how to change channel */
74 unsigned done; /* number of successful changes */
75 unsigned notdone; /* number of unsuccessful changes */
76 };
77
78 /******************************************************************
79 * change_channel_CB
80 *
81 * Callback used for changing a given channel attributes
82 */
83 static int change_channel_CB(HANDLE hProcess, void* addr, WCHAR* buffer, void* pmt)
84 {
85 struct cce_user* user = (struct cce_user*)pmt;
86
87 if (!user->name || !wcscmp(buffer + 1, user->name))
88 {
89 buffer[0] = (buffer[0] & ~user->mask) | (user->value & user->mask);
90 if (WriteProcessMemory(hProcess, addr, buffer, 1, NULL))
91 user->done++;
92 else
93 user->notdone++;
94 }
95 return 1;
96 }
97
98 #ifdef WINE
99 /******************************************************************
100 * get_symbol
101 *
102 * Here it gets ugly :-(
103 * This is quick hack to get the address of first_dll in a running process
104 * We make the following assumptions:
105 * - libwine (lib) is loaded in all processes at the same address (or
106 * at least at the same address at this process)
107 * - we load the same libwine.so version in this process and in the
108 * examined process
109 * Final address is gotten by: 1/ querying the address of a known exported
110 * symbol out of libwine.so with dlsym, 2/ then querying nm on libwine.so to
111 * get the offset from the data segment of this known symbol and of first_dll,
112 * 3/ computing the actual address of first_dll by adding the result of 1/ and
113 * the delta of 2/.
114 * Ugly, yes, but it somehow works. We should replace that with debughlp
115 * library, that'd be way better. Exporting first_dll from libwine.so would make
116 * this code simpler, but still ugly.
117 */
118 /* FIXME: we only need those includes for the next function */
119 #include <dlfcn.h> /* for RTLD_LAZY */
120 #include <sys/types.h>
121 #include <sys/stat.h>
122 #include <unistd.h>
123 #include <stdio.h>
124 #include "wine/library.h"
125
126 void* get_symbol(HANDLE hProcess, const char* name, const char* lib)
127 {
128 char buffer[1024];
129 void* h;
130 DWORD addr = 0, tmp = 0;
131 FILE* f;
132 char* env;
133
134 if (!(h = wine_dlopen(lib, RTLD_LAZY, buffer, sizeof(buffer))))
135 {
136 printf("Couldn't load %s (%s)\n", lib, buffer);
137 return NULL;
138 }
139
140 env = getenv("LD_LIBRARY_PATH");
141 if (env)
142 {
143 char *next, *ptr;
144 struct stat s;
145
146 for (ptr = env = strdup(env); ptr; ptr = next)
147 {
148 next = strchr(ptr, ':');
149 if (next) *next++ = '\0';
150 sprintf(buffer, "nm %s", ptr);
151 if (buffer[strlen(buffer) - 1] != '/') strcat(buffer, "/");
152 strcat(buffer, lib);
153 if (stat(buffer + 3, &s) == 0) break;
154 }
155 free(env);
156 if (!ptr)
157 {
158 printf("Couldn't find %s in LD_LIBRARY_PATH\n", lib);
159 return NULL;
160 }
161 }
162 if (!(f = popen(buffer, "r")))
163 {
164 printf("Cannot execute '%s'\n", buffer);
165 return NULL;
166 }
167
168 while (fgets(buffer, sizeof(buffer), f))
169 {
170 char *p = buffer + strlen(buffer) - 1;
171 if (p < buffer) continue;
172 if (*p == '\n') *p-- = 0;
173 if (p - buffer < 11) continue;
174 buffer[8] = '\0';
175 if (!strcmp(&buffer[11], name)) addr += strtol(buffer, NULL, 16);
176 if (buffer[9] == 'D' && !tmp && (tmp = (DWORD)wine_dlsym(h, &buffer[11], NULL, 0)) != 0)
177 addr += tmp - strtol(buffer, NULL, 16);
178 }
179 pclose(f);
180 return (char*)addr;
181 }
182 #else
183 void* get_symbol(HANDLE hProcess, const char* name, const char* lib)
184 {
185 printf("get_symbol: not implemented on this platform\n");
186 return NULL;
187 }
188 #endif
189
190 struct dll_option_layout
191 {
192 void* next;
193 void* prev;
194 char* const* channels;
195 unsigned int nb_channels;
196 };
197
198 typedef int (*EnumChannelCB)(HANDLE, void*, WCHAR*, void*);
199
200 /******************************************************************
201 * enum_channel
202 *
203 * Enumerates all known channels on process hProcess through callback
204 * ce.
205 */
206 static int enum_channel(HANDLE hProcess, EnumChannelCB ce, void* user, unsigned unique)
207 {
208 struct dll_option_layout dol;
209 int ret = 1;
210 void* buf_addr;
211 WCHAR buffer[32];
212 void* addr;
213 WCHAR** cache = NULL;
214 unsigned i, j, num_cache, used_cache;
215
216 addr = get_symbol(hProcess, "first_dll", "libwine.so");
217 if (!addr) return -1;
218 if (unique)
219 cache = HeapAlloc(GetProcessHeap(), 0, (num_cache = 32) * sizeof(WCHAR*));
220 else
221 num_cache = 0;
222 used_cache = 0;
223
224 for (;
225 ret && addr && ReadProcessMemory(hProcess, addr, &dol, sizeof(dol), NULL);
226 addr = dol.next)
227 {
228 for (i = 0; i < dol.nb_channels; i++)
229 {
230 if (ReadProcessMemory(hProcess, (void*)(dol.channels + i), &buf_addr, sizeof(buf_addr), NULL) &&
231 ReadProcessMemory(hProcess, buf_addr, buffer, sizeof(buffer), NULL))
232 {
233 if (unique)
234 {
235 /* since some channels are defined in multiple compilation units,
236 * they will appear several times...
237 * so cache the channel's names we already reported and don't report
238 * them again
239 */
240 for (j = 0; j < used_cache; j++)
241 if (!wcscmp(cache[j], buffer + 1)) break;
242 if (j != used_cache) continue;
243 if (used_cache == num_cache)
244 cache = HeapReAlloc(GetProcessHeap(), 0, cache, (num_cache *= 2) * sizeof(WCHAR*));
245 cache[used_cache++] = wcscpy(HeapAlloc(GetProcessHeap(), 0, (wcslen(buffer + 1) + 1) * sizeof(WCHAR)),
246 buffer + 1);
247 }
248 ret = ce(hProcess, buf_addr, buffer, user);
249 }
250 }
251 }
252 if (unique)
253 {
254 for (j = 0; j < used_cache; j++) HeapFree(GetProcessHeap(), 0, (WCHAR*)cache[j]);
255 HeapFree(GetProcessHeap(), 0, cache);
256 }
257 return 0;
258 }
259
260 static void DebugChannels_FillList(HWND hChannelLV)
261 {
262 HANDLE hProcess;
263
264 (void)ListView_DeleteAllItems(hChannelLV);
265
266 hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ, FALSE, GetSelectedProcessId());
267 if (!hProcess) return; /* FIXME messagebox */
268 SendMessageW(hChannelLV, WM_SETREDRAW, FALSE, 0);
269 enum_channel(hProcess, list_channel_CB, (void*)hChannelLV, TRUE);
270 SendMessageW(hChannelLV, WM_SETREDRAW, TRUE, 0);
271 CloseHandle(hProcess);
272 }
273
274 static void DebugChannels_OnCreate(HWND hwndDlg)
275 {
276 HWND hLV = GetDlgItem(hwndDlg, IDC_DEBUG_CHANNELS_LIST);
277 LVCOLUMN lvc;
278
279 lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
280 lvc.fmt = LVCFMT_LEFT;
281 lvc.pszText = L"Debug Channel";
282 lvc.cx = 100;
283 (void)ListView_InsertColumn(hLV, 0, &lvc);
284
285 lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
286 lvc.fmt = LVCFMT_CENTER;
287 lvc.pszText = L"Fixme";
288 lvc.cx = 55;
289 (void)ListView_InsertColumn(hLV, 1, &lvc);
290
291 lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
292 lvc.fmt = LVCFMT_CENTER;
293 lvc.pszText = L"Err";
294 lvc.cx = 55;
295 (void)ListView_InsertColumn(hLV, 2, &lvc);
296
297 lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
298 lvc.fmt = LVCFMT_CENTER;
299 lvc.pszText = L"Warn";
300 lvc.cx = 55;
301 (void)ListView_InsertColumn(hLV, 3, &lvc);
302
303 lvc.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
304 lvc.fmt = LVCFMT_CENTER;
305 lvc.pszText = L"Trace";
306 lvc.cx = 55;
307 (void)ListView_InsertColumn(hLV, 4, &lvc);
308
309 DebugChannels_FillList(hLV);
310 }
311
312 static void DebugChannels_OnNotify(HWND hDlg, LPARAM lParam)
313 {
314 NMHDR* nmh = (NMHDR*)lParam;
315
316 switch (nmh->code)
317 {
318 case NM_CLICK:
319 if (nmh->idFrom == IDC_DEBUG_CHANNELS_LIST)
320 {
321 LVHITTESTINFO lhti;
322 HWND hChannelLV;
323 HANDLE hProcess;
324 NMITEMACTIVATE* nmia = (NMITEMACTIVATE*)lParam;
325
326 hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, GetSelectedProcessId());
327 if (!hProcess) return; /* FIXME message box */
328 lhti.pt = nmia->ptAction;
329 hChannelLV = GetDlgItem(hDlg, IDC_DEBUG_CHANNELS_LIST);
330 SendMessageW(hChannelLV, LVM_SUBITEMHITTEST, 0, (LPARAM)&lhti);
331 if (nmia->iSubItem >= 1 && nmia->iSubItem <= 4)
332 {
333 WCHAR val[2];
334 WCHAR name[32];
335 unsigned bitmask = 1 << (lhti.iSubItem - 1);
336 struct cce_user user;
337
338 ListView_GetItemText(hChannelLV, lhti.iItem, 0, name, sizeof(name) / sizeof(name[0]));
339 ListView_GetItemText(hChannelLV, lhti.iItem, lhti.iSubItem, val, sizeof(val) / sizeof(val[0]));
340 user.name = name;
341 user.value = (val[0] == L'x') ? 0 : bitmask;
342 user.mask = bitmask;
343 user.done = user.notdone = 0;
344 enum_channel(hProcess, change_channel_CB, &user, FALSE);
345 if (user.done)
346 {
347 val[0] ^= (L'x' ^ L' ');
348 ListView_SetItemText(hChannelLV, lhti.iItem, lhti.iSubItem, val);
349 }
350 if (user.notdone)
351 printf("Some channel instance weren't correctly set\n");
352 }
353 CloseHandle(hProcess);
354 }
355 break;
356 }
357 }
358
359 static INT_PTR CALLBACK DebugChannelsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
360 {
361 switch (message)
362 {
363 case WM_INITDIALOG:
364 DebugChannels_OnCreate(hDlg);
365 return TRUE;
366 case WM_COMMAND:
367 if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
368 EndDialog(hDlg, LOWORD(wParam));
369 return TRUE;
370 }
371 break;
372 case WM_NOTIFY:
373 DebugChannels_OnNotify(hDlg, lParam);
374 break;
375 }
376 return FALSE;
377 }
378
379 void ProcessPage_OnDebugChannels(void)
380 {
381 DialogBoxW(hInst, (LPCWSTR)IDD_DEBUG_CHANNELS_DIALOG, hMainWnd, DebugChannelsDlgProc);
382 }