stricmp doesn't work in my code

Question

I'm cycling through a process snapshot of TlHelp32 and then comparing the names with stricmp to get the process handle. The problem is even though both values seem to be the same, they apparently are not since it doesn't return 0 . I don't know why though, I have tried writing the process name into the function as well.

HANDLE GetProcessValues(std::string ProcName)
{
   const char* ProcNameChar = ProcName.c_str();
   HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
   PROCESSENTRY32 process;
   ZeroMemory(&process, sizeof(process));
   process.dwSize = sizeof(process);
   if (Process32First(snapshot, &process))
   {
       do
       {
           if (_stricmp((char*)process.szExeFile,ProcNameChar)==0)
           {
               HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process.th32ProcessID);
               return hProc;
           }
       }while (Process32Next(snapshot,&process));
   }
   return 0;
}

I debugged it to see if the values fit:

Answer 1

The problem is that you are using the TCHAR versions of Process32First()/Process32Next(), and your debugger screnshot clearly shows that you are compiling your project for Unicode, so TCHAR maps to WCHAR and thus process.szExeFile is a WCHAR[] array. You are incorrectly type-casting that array to a char* pointer. You cannot directly compare a Unicode string to an Ansi string. You need to convert one string to the encoding of the other string before then comparing them.

You are also leaking the HANDLE returned by CreateToolhelp32Snapshot().

Since you are passing an Ansi std::string as input to your GetProcessValues() function, the easiest solution would be to use the Ansi versions of Process32First()/Process32Next() instead, so process.szExeFile is now a CHAR[] array, and thus no conversion is needed:

HANDLE GetProcessValues(std::string ProcName)
{
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE)
        return NULL;

    PROCESSENTRY32A process;
    ZeroMemory(&process, sizeof(process));
    process.dwSize = sizeof(process);

    const char* ProcNameChar = ProcName.c_str();
    HANDLE hProc = NULL;

    if (Process32FirstA(snapshot, &process))
    {
        do
        {
            if (_stricmp(process.szExeFile, ProcNameChar) == 0)
            {
                hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process.th32ProcessID);
                break;
            }
        }
        while (Process32NextA(snapshot, &process));
    }

    CloseHandle(snapshot);
    return hProc;
}

However, you really should stay away from using Ansi APIs. Windows is a Unicode-based OS, and has been for a long time. Use Unicode APIs instead:

HANDLE GetProcessValues(std::wstring ProcName)
{
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE)
        return NULL;

    PROCESSENTRY32W process;
    ZeroMemory(&process, sizeof(process));
    process.dwSize = sizeof(process);

    const wchar_t* ProcNameChar = ProcName.c_str();
    HANDLE hProc = NULL;

    if (Process32FirstW(snapshot, &process))
    {
        do
        {
            if (_wcsicmp(process.szExeFile, ProcNameChar) == 0)
            {
                hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process.th32ProcessID);
                break;
            }
        }
        while (Process32NextW(snapshot, &process));
    }

    CloseHandle(snapshot);
    return hProc;
}

If your ProcName parameter absolutely must be a std::string, then you can either:

1. convert ProcName to Unicode using MultiByteToWideChar(), std::wstring_convert, etc, and then compare that result to the strings returned by the Unicode API.

2. convert strings from the Unicode API to Ansi using WideCharToMultiByte(), std::wstring_convert, etc, and then compare those results to ProcName.

Answer 2

when dealing with wchar* data type, use _wcsicmp for comparison, and - if necessary - convert any involved char* data type into a wchar*-equivalent, e.g. using CStringW class. Confer microsoft _wcsicmp, and be also aware of using a correct locale. A similar problem, yet with wchar* constants, has been described at stack overflow