d97075c53fc71af44fe0fce5df843219a114ac32
[wincetools.git] / inspection / virtual-query.c
1 #include <stdio.h>
2 #include <windows.h>
3
4 FILE *fp;
5
6 void
7 dump_mbi_header ()
8 {
9   fprintf (fp, "alc-base   alc-prot address    size       state    protect  type     \n");
10
11
12
13 void
14 dump_protect_flags (DWORD flags)
15 {
16   DWORD pr = flags & (PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE
17                       | PAGE_EXECUTE_WRITECOPY | PAGE_READONLY
18                       | PAGE_READWRITE | PAGE_WRITECOPY);
19   DWORD pw = flags & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY
20                       | PAGE_READWRITE | PAGE_WRITECOPY);
21   DWORD pc = flags & (PAGE_EXECUTE_WRITECOPY | PAGE_WRITECOPY);
22   DWORD px = flags & (PAGE_EXECUTE | PAGE_EXECUTE_READ
23                       | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY);
24   
25   fprintf (fp, "%c%c%c %c%c%c  ",
26           pr ? 'r' : '-', pc ? 'c' : (pw ? 'w' : '-'), px ? 'x' : '-',
27           (flags & PAGE_GUARD) ? 'g' : '-',
28           (flags & PAGE_NOCACHE) ? 'n' : '-',
29 #ifdef PAGE_PHYSICAL
30           (flags & PAGE_PHYSICAL) ? 'p' : 
31 #endif
32           '-');
33 }
34
35
36 void
37 dump_state (DWORD state)
38 {
39   switch (state)
40     {
41     case MEM_COMMIT:
42       fprintf (fp, "commit   ");
43       return;
44     case MEM_FREE:
45       fprintf (fp, "free     ");
46       return;
47     case MEM_RESERVE:
48       fprintf (fp, "reserve  ");
49       return;
50     default:
51       fprintf (fp, "unknown  ");
52     }
53 }
54
55
56 void
57 dump_type (DWORD mtype)
58 {
59   switch (mtype)
60     {
61     case MEM_IMAGE:
62       fprintf (fp, "image    ");
63       return;
64     case MEM_MAPPED:
65       fprintf (fp, "mapped   ");
66       return;
67     case MEM_PRIVATE:
68       fprintf (fp, "private  ");
69       return;
70     default:
71       fprintf (fp, "unknown  ");
72     }
73 }
74
75
76 void
77 dump_mbi (PMEMORY_BASIC_INFORMATION mbi)
78 {
79   fprintf (fp, "0x%08x ", mbi->AllocationBase);
80   dump_protect_flags (mbi->AllocationProtect);
81   fprintf (fp, "0x%08x ", mbi->BaseAddress);
82   fprintf (fp, "0x%08x ", mbi->RegionSize);
83   dump_state (mbi->State);
84   dump_protect_flags (mbi->Protect);
85   dump_type (mbi->Type);
86   fprintf (fp, "\n");
87 }
88
89 #include <tlhelp32.h>
90 #include <windows.h>
91 #define MAX_PROCESSES 32
92
93 DWORD GetMaxProcessNameLength( PROCESSENTRY32 lppe[MAX_PROCESSES], DWORD ProcessCount )
94 {
95   DWORD index ;
96   DWORD MaxLength = 0;
97   DWORD CurrentLength;
98   for( index = 0; index < ProcessCount; index++ )
99     {
100       CurrentLength = wcslen( lppe[ index ].szExeFile );
101       if( MaxLength <  CurrentLength )
102         MaxLength = CurrentLength;
103     }
104   return MaxLength;
105 }
106
107 #define TH32CS_SNAPNOHEAPS 0x40000000
108
109 DWORD GetRunningProcesses( PROCESSENTRY32 *pProcess )
110 {
111   HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS|TH32CS_SNAPNOHEAPS, 0);
112   DWORD index = 0;
113   if(hSnapShot == (HANDLE)-1)
114     {
115 #if 1
116       fprintf (fp, "GetRunningProcesses: Failed CreateToolhelp32Snapshot Error: %d\n",
117                GetLastError());
118 #endif
119       return 0;
120     }
121
122   memset(pProcess,0,sizeof(PROCESSENTRY32));
123   index = 0;
124   pProcess->dwSize = sizeof(PROCESSENTRY32);
125   if(Process32First(hSnapShot, pProcess))
126     {
127       while(TRUE)
128         {
129           index += 1;
130           if( index < MAX_PROCESSES )
131             {
132               memcpy( pProcess + 1, pProcess, sizeof(PROCESSENTRY32));
133               pProcess++;
134               if(!Process32Next(hSnapShot, pProcess))
135                 {
136                   break;
137                 }
138             }
139           else
140             {
141               index = MAX_PROCESSES;
142               break;
143             }
144         }
145     }
146   CloseToolhelp32Snapshot (hSnapShot);
147   return index ;
148 }
149
150 int
151 main (int argc, char* argv[])
152 {
153   MEMORY_BASIC_INFORMATION mbi;
154   SYSTEM_INFO si;
155   void *addr;
156   int skipping = 0;
157
158   fp = fopen ("\\Speicherkarte\\vmemory.txt", "w");
159   {
160     PROCESSENTRY32 *CurrentProcess;
161     PROCESSENTRY32 Process[ MAX_PROCESSES ];
162     DWORD ProcessCount;
163     DWORD index ;
164     DWORD MaxProcessNameLength;
165     // Get the list of running processes
166     ProcessCount = GetRunningProcesses( Process );
167     // Get the length of the longest process name so that we can format
168     // the output to be pretty
169     MaxProcessNameLength = GetMaxProcessNameLength( Process, ProcessCount );
170     // Output a header to describe each column
171     fprintf (fp, "%-*s %8s %13s %9s %9s %10s\n",
172             MaxProcessNameLength, "Process", "PID", "Base Priority", "# Threads", "Base Addr", "Access Key");
173
174     // Output information for each running process
175     for( index = 0; index < ProcessCount; index++ )
176       {
177         CurrentProcess = &(Process[ index ] );
178         fprintf (fp, "%-*S %8X %13d %9d %9X %10X\n", 
179                  MaxProcessNameLength, CurrentProcess->szExeFile,
180                  CurrentProcess->th32ProcessID,
181                  CurrentProcess->pcPriClassBase,
182                  CurrentProcess->cntThreads,
183                  CurrentProcess->th32MemoryBase,
184                  CurrentProcess->th32AccessKey
185                  );
186       }
187   }
188   
189   memset (&si, '\0', sizeof (si));
190   GetSystemInfo (&si);
191   dump_mbi_header ();
192
193   addr = 0;
194   do
195     {
196       DWORD res;
197       void *new_addr;
198
199       memset (&mbi, '\0', sizeof (mbi));
200       res = VirtualQuery (addr, &mbi, sizeof (mbi));
201       if (res == 0)
202         {
203           if (!skipping)
204             fprintf (fp, "Skipping over %p...\n", addr);
205           skipping = 1;
206           new_addr = addr + si.dwPageSize;
207           if (new_addr < addr)
208             break;
209           addr = new_addr; 
210          continue;
211         }
212       if (res != sizeof (mbi))
213         {
214           fprintf (fp, "Unexpected return size: %i (expected %i)\n",
215                   res, sizeof (mbi));
216         }
217       skipping = 0;
218       dump_mbi (&mbi);
219       /* Check for overflow.  */
220       new_addr = addr + mbi.RegionSize;
221       if (new_addr < addr)
222         break;
223       addr = new_addr;
224     }
225   while (1);
226
227   /* Give ssh time to flush buffers.  */
228   fflush (fp);
229   fclose (fp);
230   Sleep (300);
231   return 0;
232 }