toolhelp.c 11.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Toolhelp
 *
 * Copyright 2005 Eric Pouech
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 22 23 24 25 26
 */

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>

#include "windef.h"
#include "winbase.h"
27 28
#include "tlhelp32.h"
#include "wine/test.h"
29 30 31 32
#include "winuser.h"

static char     selfname[MAX_PATH];

33 34 35 36 37 38 39 40 41
/* Some functions are only in later versions of kernel32.dll */
static HANDLE (WINAPI *pCreateToolhelp32Snapshot)(DWORD, DWORD);
static BOOL (WINAPI *pModule32First)(HANDLE, LPMODULEENTRY32);
static BOOL (WINAPI *pModule32Next)(HANDLE, LPMODULEENTRY32);
static BOOL (WINAPI *pProcess32First)(HANDLE, LPPROCESSENTRY32);
static BOOL (WINAPI *pProcess32Next)(HANDLE, LPPROCESSENTRY32);
static BOOL (WINAPI *pThread32First)(HANDLE, LPTHREADENTRY32);
static BOOL (WINAPI *pThread32Next)(HANDLE, LPTHREADENTRY32);

42 43 44 45 46
/* 1 minute should be more than enough */
#define WAIT_TIME       (60 * 1000)

static DWORD WINAPI sub_thread(void* pmt)
{
47
    DWORD w = WaitForSingleObject(pmt, WAIT_TIME);
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
    return w;
}

/******************************************************************
 *		init
 *
 * generates basic information like:
 *      selfname:       the way to reinvoke ourselves
 * returns:
 *      -1      on error
 *      0       if parent
 *      doesn't return if child
 */
static int     init(void)
{
    int                 argc;
    char**              argv;
    HANDLE              ev1, ev2, ev3, hThread;
66
    DWORD               w, tid;
67 68 69 70 71 72 73 74 75

    argc = winetest_get_mainargs( &argv );
    strcpy(selfname, argv[0]);

    switch (argc)
    {
    case 2: /* the test program */
        return 0;
    case 4: /* the sub-process */
76 77
        ev1 = (HANDLE)(INT_PTR)atoi(argv[2]);
        ev2 = (HANDLE)(INT_PTR)atoi(argv[3]);
78 79 80
        ev3 = CreateEvent(NULL, FALSE, FALSE, NULL);

        if (ev3 == NULL) ExitProcess(WAIT_ABANDONED);
81
        hThread = CreateThread(NULL, 0, sub_thread, ev3, 0, &tid);
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
        if (hThread == NULL) ExitProcess(WAIT_ABANDONED);
        if (!LoadLibraryA("shell32.dll")) ExitProcess(WAIT_ABANDONED);
    
        /* signal init of sub-process is done */
        SetEvent(ev1);
        /* wait for parent to have done all its queries */
        w = WaitForSingleObject(ev2, WAIT_TIME);
        if (w != WAIT_OBJECT_0) ExitProcess(w);
        /* signal sub-thread to terminate */
        SetEvent(ev3);
        w = WaitForSingleObject(hThread, WAIT_TIME);
        if (w != WAIT_OBJECT_0) ExitProcess(w);
        GetExitCodeThread(hThread, &w);
        ExitProcess(w);
    default:
        return -1;
    }
}

static void test_process(DWORD curr_pid, DWORD sub_pcs_pid)
{
    HANDLE              hSnapshot;
    PROCESSENTRY32      pe;
    MODULEENTRY32       me;
    unsigned            found = 0;
    int                 num = 0;
108
    int			childpos = -1;
109

110
    hSnapshot = pCreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
111 112 113 114
    ok(hSnapshot != NULL, "Cannot create snapshot\n");

    /* check that this current process is enumerated */
    pe.dwSize = sizeof(pe);
115
    if (pProcess32First( hSnapshot, &pe ))
116 117 118 119
    {
        do
        {
            if (pe.th32ProcessID == curr_pid) found++;
120
            if (pe.th32ProcessID == sub_pcs_pid) { childpos = num; found++; }
121
            trace("PID=%x %s\n", pe.th32ProcessID, pe.szExeFile);
122
            num++;
123
        } while (pProcess32Next( hSnapshot, &pe ));
124 125 126 127 128
    }
    ok(found == 2, "couldn't find self and/or sub-process in process list\n");

    /* check that first really resets the enumeration */
    found = 0;
129
    if (pProcess32First( hSnapshot, &pe ))
130 131 132 133 134
    {
        do
        {
            if (pe.th32ProcessID == curr_pid) found++;
            if (pe.th32ProcessID == sub_pcs_pid) found++;
135
            trace("PID=%x %s\n", pe.th32ProcessID, pe.szExeFile);
136
            num--;
137
        } while (pProcess32Next( hSnapshot, &pe ));
138 139 140 141
    }
    ok(found == 2, "couldn't find self and/or sub-process in process list\n");
    ok(!num, "mismatch in counting\n");

142 143 144 145
    /* one broken program does Process32First() and does not expect anything
     * interesting to be there, especially not the just forked off child */
    ok (childpos !=0, "child is not expected to be at position 0.\n");

146
    me.dwSize = sizeof(me);
147
    ok(!pModule32First( hSnapshot, &me ), "shouldn't return a module\n");
148 149

    CloseHandle(hSnapshot);
150
    ok(!pProcess32First( hSnapshot, &pe ), "shouldn't return a process\n");
151 152 153 154 155 156 157 158 159 160 161
}

static void test_thread(DWORD curr_pid, DWORD sub_pcs_pid)
{
    HANDLE              hSnapshot;
    THREADENTRY32       te;
    MODULEENTRY32       me;
    int                 num = 0;
    unsigned            curr_found = 0;
    unsigned            sub_found = 0;
    
162
    hSnapshot = pCreateToolhelp32Snapshot( TH32CS_SNAPTHREAD, 0 );
163 164 165 166
    ok(hSnapshot != NULL, "Cannot create snapshot\n");

    /* check that this current process is enumerated */
    te.dwSize = sizeof(te);
167
    if (pThread32First( hSnapshot, &te ))
168 169 170 171 172
    {
        do
        {
            if (te.th32OwnerProcessID == curr_pid) curr_found++;
            if (te.th32OwnerProcessID == sub_pcs_pid) sub_found++;
173 174
            if (winetest_debug > 1)
                trace("PID=%x TID=%x %d\n", te.th32OwnerProcessID, te.th32ThreadID, te.tpBasePri);
175
            num++;
176
        } while (pThread32Next( hSnapshot, &te ));
177 178 179 180 181 182 183
    }
    ok(curr_found == 1, "couldn't find self in thread list\n");
    ok(sub_found == 2, "couldn't find sub-process thread's in thread list\n");

    /* check that first really resets enumeration */
    curr_found = 0;
    sub_found = 0;
184
    if (pThread32First( hSnapshot, &te ))
185 186 187 188 189
    {
        do
        {
            if (te.th32OwnerProcessID == curr_pid) curr_found++;
            if (te.th32OwnerProcessID == sub_pcs_pid) sub_found++;
190 191
            if (winetest_debug > 1)
                trace("PID=%x TID=%x %d\n", te.th32OwnerProcessID, te.th32ThreadID, te.tpBasePri);
192
            num--;
193
        } while (pThread32Next( hSnapshot, &te ));
194 195 196 197 198
    }
    ok(curr_found == 1, "couldn't find self in thread list\n");
    ok(sub_found == 2, "couldn't find sub-process thread's in thread list\n");

    me.dwSize = sizeof(me);
199
    ok(!pModule32First( hSnapshot, &me ), "shouldn't return a module\n");
200 201

    CloseHandle(hSnapshot);
202
    ok(!pThread32First( hSnapshot, &te ), "shouldn't return a thread\n");
203 204 205 206 207
}

static const char* curr_expected_modules[] =
{
    "kernel32_test.exe"
208
    "kernel32.dll",
209 210 211 212 213
    /* FIXME: could test for ntdll on NT and Wine */
};
static const char* sub_expected_modules[] =
{
    "kernel32_test.exe",
214
    "kernel32.dll",
215 216 217 218 219 220 221 222 223 224 225 226
    "shell32.dll"
    /* FIXME: could test for ntdll on NT and Wine */
};
#define NUM_OF(x) (sizeof(x) / sizeof(x[0]))

static void test_module(DWORD pid, const char* expected[], unsigned num_expected)
{
    HANDLE              hSnapshot;
    PROCESSENTRY32      pe;
    THREADENTRY32       te;
    MODULEENTRY32       me;
    unsigned            found[32];
227 228
    unsigned            i;
    int                 num = 0;
229 230 231

    ok(NUM_OF(found) >= num_expected, "Internal: bump found[] size\n");

232
    hSnapshot = pCreateToolhelp32Snapshot( TH32CS_SNAPMODULE, pid );
233 234 235 236
    ok(hSnapshot != NULL, "Cannot create snapshot\n");

    for (i = 0; i < num_expected; i++) found[i] = 0;
    me.dwSize = sizeof(me);
237
    if (pModule32First( hSnapshot, &me ))
238 239 240
    {
        do
        {
241
            trace("PID=%x base=%p size=%x %s %s\n",
242
                  me.th32ProcessID, me.modBaseAddr, me.modBaseSize, me.szExePath, me.szModule);
Francois Gouget's avatar
Francois Gouget committed
243
            ok(me.th32ProcessID == pid, "wrong returned process id\n");
244
            for (i = 0; i < num_expected; i++)
245
                if (!lstrcmpi(expected[i], me.szModule)) found[i]++;
246
            num++;
247
        } while (pModule32Next( hSnapshot, &me ));
248 249 250 251 252 253 254 255
    }
    for (i = 0; i < num_expected; i++)
        ok(found[i] == 1, "Module %s is %s\n",
           expected[i], found[i] ? "listed more than once" : "not listed");

    /* check that first really resets the enumeration */
    for (i = 0; i < num_expected; i++) found[i] = 0;
    me.dwSize = sizeof(me);
256
    if (pModule32First( hSnapshot, &me ))
257 258 259
    {
        do
        {
260
            trace("PID=%x base=%p size=%x %s %s\n",
261 262
                  me.th32ProcessID, me.modBaseAddr, me.modBaseSize, me.szExePath, me.szModule);
            for (i = 0; i < num_expected; i++)
263
                if (!lstrcmpi(expected[i], me.szModule)) found[i]++;
264
            num--;
265
        } while (pModule32Next( hSnapshot, &me ));
266 267 268 269 270 271 272
    }
    for (i = 0; i < num_expected; i++)
        ok(found[i] == 1, "Module %s is %s\n",
           expected[i], found[i] ? "listed more than once" : "not listed");
    ok(!num, "mismatch in counting\n");

    pe.dwSize = sizeof(pe);
273
    ok(!pProcess32First( hSnapshot, &pe ), "shouldn't return a process\n");
274

Huw Davies's avatar
Huw Davies committed
275
    te.dwSize = sizeof(te);
276
    ok(!pThread32First( hSnapshot, &te ), "shouldn't return a thread\n");
277 278

    CloseHandle(hSnapshot);
279
    ok(!pModule32First( hSnapshot, &me ), "shouldn't return a module\n");
280 281 282 283 284 285
}

START_TEST(toolhelp)
{
    DWORD               pid = GetCurrentProcessId();
    int                 r;
286
    char                *p, module[MAX_PATH];
287 288 289 290 291 292
    char                buffer[MAX_PATH];
    SECURITY_ATTRIBUTES sa;
    PROCESS_INFORMATION	info;
    STARTUPINFOA	startup;
    HANDLE              ev1, ev2;
    DWORD               w;
293 294 295 296 297 298 299 300 301 302 303 304 305
    HANDLE              hkernel32 = GetModuleHandleA("kernel32");

    pCreateToolhelp32Snapshot = (VOID *) GetProcAddress(hkernel32, "CreateToolhelp32Snapshot");
    pModule32First = (VOID *) GetProcAddress(hkernel32, "Module32First");
    pModule32Next = (VOID *) GetProcAddress(hkernel32, "Module32Next");
    pProcess32First = (VOID *) GetProcAddress(hkernel32, "Process32First");
    pProcess32Next = (VOID *) GetProcAddress(hkernel32, "Process32Next");
    pThread32First = (VOID *) GetProcAddress(hkernel32, "Thread32First");
    pThread32Next = (VOID *) GetProcAddress(hkernel32, "Thread32Next");

    if (!pCreateToolhelp32Snapshot || 
        !pModule32First || !pModule32Next ||
        !pProcess32First || !pProcess32Next ||
306 307
        !pThread32First || !pThread32Next)
    {
308
        win_skip("Needed functions are not available, most likely running on Windows NT\n");
309 310
        return;
    }
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327

    r = init();
    ok(r == 0, "Basic init of sub-process test\n");
    if (r != 0) return;

    sa.nLength = sizeof(sa);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;

    ev1 = CreateEvent(&sa, FALSE, FALSE, NULL);
    ev2 = CreateEvent(&sa, FALSE, FALSE, NULL);
    ok (ev1 != NULL && ev2 != NULL, "Couldn't create events\n");
    memset(&startup, 0, sizeof(startup));
    startup.cb = sizeof(startup);
    startup.dwFlags = STARTF_USESHOWWINDOW;
    startup.wShowWindow = SW_SHOWNORMAL;

328
    sprintf(buffer, "%s tests/toolhelp.c %lu %lu", selfname, (DWORD_PTR)ev1, (DWORD_PTR)ev2);
329 330 331 332 333
    ok(CreateProcessA(NULL, buffer, NULL, NULL, TRUE, 0, NULL, NULL, &startup, &info), "CreateProcess\n");
    /* wait for child to be initialized */
    w = WaitForSingleObject(ev1, WAIT_TIME);
    ok(w == WAIT_OBJECT_0, "Failed to wait on sub-process startup\n");

334 335 336 337 338 339
    GetModuleFileNameA( 0, module, sizeof(module) );
    if (!(p = strrchr( module, '\\' ))) p = module;
    else p++;
    curr_expected_modules[0] = p;
    sub_expected_modules[0] = p;

340 341 342 343 344 345
    test_process(pid, info.dwProcessId);
    test_thread(pid, info.dwProcessId);
    test_module(pid, curr_expected_modules, NUM_OF(curr_expected_modules));
    test_module(info.dwProcessId, sub_expected_modules, NUM_OF(sub_expected_modules));

    SetEvent(ev2);
346
    winetest_wait_child_process( info.hProcess );
347
}