dfhack/tools/incrementalsearch.cpp

// this will be an incremental search tool in the future. now it is just a memory region dump thing

#include <iostream>
#include <climits>
#include <integers.h>
#include <vector>
#include <map>
#include <ctime>
#include <string.h>
#include <stdio.h>
#include <algorithm>
using namespace std;

#ifndef LINUX_BUILD
    #define WINVER 0x0500
    // this one prevents windows from infecting the global namespace with filth
    #define NOMINMAX
    #define WIN32_LEAN_AND_MEAN
    #include <windows.h>
#endif

#include <DFTypes.h>
#include <DFHackAPI.h>
#include <DFProcessEnumerator.h>
#include <DFProcess.h>
#include <DFMemInfo.h>

//TODO: lots of optimization
void searchLoop(DFHack::API & DF, vector <DFHack::t_memrange>& ranges, int size, int alignment)
{
    int32_t test1;
    int32_t test2;
    vector <int64_t> found;
    vector <int64_t> newfound;
    found.reserve(100000);
    newfound.reserve(100000);
    
    //bool initial = 1;
    cout << "search ready - insert integers, 'p' for results" << endl;
    
    string select;
    while (1)
    {
        cout << ">>";
        DF.Detach();
        std::getline(cin, select);
        DF.Attach();
        if(select == "p")
        {
            cout << "Found addresses:" << endl;
            for(int i = 0; i < found.size();i++)
            {
                cout << hex << "0x" << found[i] << endl;
            }
        }
        else if(sscanf(select.c_str(),"%d", &test1) == 1)
        {
            newfound.clear();
            bool initial = found.empty();
            
            if(initial)
            {
                // for each range
                for (int i = 0; i < ranges.size();i++)
                {
                    // can't read? range is invalid to us
                    if(!ranges[i].read)
                        continue;
                    
                    //loop
                    for(uint64_t offset = ranges[i].start;offset <= ranges[i].end - size; offset+=alignment)
                    {
                        DF.ReadRaw(offset, size, (uint8_t *) &test2);
                        if(test1 == test2 )
                            found.push_back(offset);
                    }
                }
                cout << "found " << found.size() << " addresses" << endl;
            }
            else
            {
                for(int j = 0; j < found.size();j++)
                {
                    DF.ReadRaw(found[j], size, (uint8_t *) &test2);
                    if(test1 == test2)
                    {
                        newfound.push_back(found[j]);
                    }
                }
                
                cout << "matched " << newfound.size() << " addresses out of " << found.size() << endl;
                found = newfound;
            }
        }
        else break;
    }
}

int main (void)
{
    string select;
    DFHack::API DF("Memory.xml");
    if(!DF.Attach())
    {
        cerr << "DF not found" << endl;
        return 1;
    }
    DFHack::Process * p = DF.getProcess();
    vector <DFHack::t_memrange> ranges;
    vector <DFHack::t_memrange> selected_ranges;
    p->getMemRanges(ranges);
    cout << "Which range to search? (default is 1-4)" << endl;
    for(int i = 0; i< ranges.size();i++)
    {
        cout << dec << "(" << i << ") ";
        ranges[i].print();
    }

    try_again_ranges:
    cout << ">>";
    std::getline(cin, select);
    int start, end;
    if(select.empty())
    {
        // empty input, assume default. observe the length of the memory range vector
        // these are hardcoded values, intended for my convenience only
        if(p->getDescriptor()->getOS() == DFHack::memory_info::OS_WINDOWS)
        {
            start = min(11, (int)ranges.size());
            end = min(14, (int)ranges.size());
        }
        else if(p->getDescriptor()->getOS() == DFHack::memory_info::OS_LINUX)
        {
            start = min(11, (int)ranges.size());
            end = min(14, (int)ranges.size());
        }
        else
        {
            start = 1;
            end = 1;
        }
    }
    // I like the C variants here. much less object clutter
    else if(sscanf(select.c_str(), "%d-%d", &start, &end) == 2)
    {
        start = min(start, (int)ranges.size());
        end = min(end, (int)ranges.size());
    }
    else
    {
        goto try_again_ranges; // yes, this is a goto. bite me.
    }
    end++;
    cout << "selected ranges:" <<endl;
    selected_ranges.insert(selected_ranges.begin(),ranges.begin() + start, ranges.begin() + end);
    for(int i = 0; i< selected_ranges.size();i++)
    {
        selected_ranges[i].print();
    }
    
    // input / validation of variable size
    try_again_size:
    cout << "Select searched variable size (1,2,4 bytes, default is 4)" << endl;
    cout << ">>";
    std::getline(cin, select);
    int size;
    if(select.empty())
    {
        size = 4;
    }
    else if( sscanf(select.c_str(), "%d", &size) == 1 )
    {
        if(/*size != 8 &&*/ size != 4 && size != 2 && size != 1)
        {
            goto try_again_size;
        }
    }
    else
    {
        goto try_again_size;
    }

    // input / validation of variable alignment (default is to use the same alignment as size)
    try_again_align:
    cout << "Variable alignment (1,2,4 bytes, default is " << size << ")" << endl;
    cout << ">>";
    std::getline(cin, select);
    int alignment = size;
    if(select.empty())
    {
        alignment = size;
    }
    else if( sscanf(select.c_str(), "%d", &alignment) == 1 )
    {
        if(/*alignment != 8 &&*/ alignment != 4 && alignment != 2 && alignment != 1)
        {
            goto try_again_align;
        }
    }
    else
    {
        goto try_again_align;
    }
    
    searchLoop(DF,selected_ranges, size, alignment);

    // initial value
    // cycle until you get only a few offsets (~10?)
    
    if(!DF.Detach())
    {
        cerr << "Can't detach from DF" << endl;
        return 1;
    }
    #ifndef LINUX_BUILD
    cout << "Done. Press any key to continue" << endl;
    cin.ignore();
    #endif
    return 0;
}