using uninitialized memory warning and else in cpp [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 4 months ago.
Improve this question
there is warnings in c++ i can't solve it
i have Visual Studio 2019
first i got error with #include "pch.h"
and 3 warnings
-using uninitialized memory : in processesSnapshot
`
while (Process32Next(processesSnapshot, &processInfo))
`
-argument conversion from 'unsigned __int64' to 'unsigned long', possible loss of data
-argument conversion from 'unsigned __int64' to 'DWORD', possible loss of data
`
MODULEENTRY32 module = GetModule("ac_client.exe", pid);
HANDLE phandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
`
`
#include "pch.h"
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>
DWORD GetPID(const char* ProcessName) {
PROCESSENTRY32 processInfo;
processInfo.dwSize = sizeof(processInfo);
HANDLE processesSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if (processesSnapshot == INVALID_HANDLE_VALUE)
return 0;
Process32First(processesSnapshot, &processInfo);
if (!strcmp(processInfo.szExeFile, ProcessName))
{
CloseHandle(processesSnapshot);
}
while (Process32Next(processesSnapshot, &processInfo))
{
if (!strcmp(processInfo.szExeFile, ProcessName))
{
CloseHandle(processesSnapshot);
}
}
CloseHandle(processesSnapshot);
return processInfo.th32ProcessID;
}
MODULEENTRY32 GetModule(const char* moduleName, unsigned long ProcessID)
{
MODULEENTRY32 modEntry = { 0 };
HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, ProcessID);
if (hSnapshot != INVALID_HANDLE_VALUE)
{
MODULEENTRY32 curr = { 0 };
curr.dwSize = sizeof(MODULEENTRY32);
if (Module32First(hSnapshot, &curr))
{
do
{
if (!strcmp(curr.szModule, moduleName))
{
modEntry = curr;
break;
}
} while (Module32Next(hSnapshot, &curr));
}
CloseHandle(hSnapshot);
}
return modEntry;
}
int main()
{
std::cout << "Hello World!\n";
unsigned long long pid = GetPID("ac_client.exe");
MODULEENTRY32 module = GetModule("ac_client.exe", pid);
HANDLE phandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
unsigned long long result;
int ammodesiredvalue = 999999;
ReadProcessMemory(phandle, (void*)((unsigned long long)module.modBaseAddr + 0x0010B1E0), &result, sizeof(result), 0);
ReadProcessMemory(phandle, (void*)((unsigned long long)result + 0x54), &result, sizeof(result), 0);
ReadProcessMemory(phandle, (void*)((unsigned long long)result + 0x14), &result, sizeof(result), 0);
//ReadProcessMemory(phandle, (void*)((unsigned long long)result + 0x14), &result, sizeof(result), 0);
WriteProcessMemory(phandle, (void*)((unsigned long long)result + 0x14), &ammodesiredvalue, sizeof(ammodesiredvalue), 0);
std::cout << "Your ammo value is " << result << std::endl;
system("pause");
}
`
i looking for fix this error and warnings

Answer 1

Your code has a number of problems. I'm going to look at one small section, and point out what look to me like obvious problems. Not sure if they're the source of the symptoms you're seeing, but ...
Process32First(processesSnapshot, &processInfo);
if (!strcmp(processInfo.szExeFile, ProcessName))
{
CloseHandle(processesSnapshot);
}
So here if we found the right process, we close the process snapshot, but then:
while (Process32Next(processesSnapshot, &processInfo))
{
...we try to continue using the process snapshot, even if it's already been closed. Then:
if (!strcmp(processInfo.szExeFile, ProcessName))
{
CloseHandle(processesSnapshot);
}
...we check whether we have the right process, and (again) close the snapshot if we found it. But we don't break out of the loop--so again, we try to continue using the snapshot, even if we've closed it. Then:
}
CloseHandle(processesSnapshot);
...when we exit the loop, we close the snapshot yet again. At this point, we've potentially closed our snapshot three times, and continued using it after it was closed in a couple of different places.
My personal inclination is that any time I see something that needs to be opened and later closed (or something along those lines) I think of using RAII/SBRM to deal with it. That means I'd create a class to manage the process snapshot. I'd create the snapshot in the class' constructor, and close it in the class' destructor, and add other member functions to obtain the contents of the current item, advance to the next item, and so on.
Given that this iterates things, it also makes sense (in my opinion) to have this class act as an actual iterator.
// warning: untested code.
class ProcessIterator {
HANDLE snapshot;
bool valid;
PROCESSENTRY32 processInfo;
public:
using iterator_category = std::input_iterator_tag;
using difference_type = std::ptrdiff_t; // not really, but it'll probably do for now.
using value_type = PROCESSENTRY32;
using pointer = PROCESSENTRY32 *;
using reference = PROCESSENTRY32 &;
ProcessIterator(DWORD ID) : snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, ID))
{
if (!snapshot)
throw std::runtime_error("Unable to open process snapshot");
valid = Process32First(snapshot, &processInfo);
}
ProcessIterator() : valid(false) {}
ProcessIterator operator++() {
valid = Process32Next(snapshot, &processInfo);
return *this;
}
PROCESSENTRY32 operator*() const { return processInfo; }
bool operator==(ProcessIterator other) {
// only invalid iterators are equal:
return (!valid) && (!other.valid);
}
~ProcessIterator() { CloseHandle(snapshot); }
};
Since this is a normal iterator, we can use it for normal iterator "stuff", such as finding an entry using std::find_if:
DWORD getPid(char const *filename) {
auto p = std::find_if(ProcessIterator(0), ProcessIterator(),
[&](PROCESSENTRY32 const &p) { return !std::strcmp(filename, p.szExeFile); });
return p->th32ProcessID;
}