kdlibcpp

1
#include "stdafx.h"
2

3
#include <vector>
4

5
#include "kdlib/memaccess.h"
6
#include "kdlib/exceptions.h"
7

8
namespace kdlib {
9

10

11
///////////////////////////////////////////////////////////////////////////////
12

13
template<typename T>
14
T
15
readPtr( MEMOFFSET_64 offset )
16
{
17
    T val = 0;
18
    readMemory( offset, &val, sizeof(T), false );
19
    return val;
20
}
21

22
///////////////////////////////////////////////////////////////////////////////
23

24
unsigned char ptrByte( MEMOFFSET_64 offset )
25
{
26
    return readPtr<unsigned char>(offset);
27
}
28

29
///////////////////////////////////////////////////////////////////////////////
30

31
unsigned short ptrWord( MEMOFFSET_64 offset )
32
{
33
    return readPtr<unsigned short>(offset);
34
}
35

36
///////////////////////////////////////////////////////////////////////////////
37

38
unsigned long  ptrDWord( MEMOFFSET_64 offset )
39
{
40
    return readPtr<unsigned long>(offset);
41
}
42

43
///////////////////////////////////////////////////////////////////////////////
44

45
unsigned long long  ptrQWord( MEMOFFSET_64 offset )
46
{
47
    return readPtr<unsigned long long>(offset);
48
}
49

50
///////////////////////////////////////////////////////////////////////////////
51

52
unsigned long long ptrMWord( MEMOFFSET_64 offset )
53
{
54
    return ptrSize() == 8 ? ptrQWord( offset ) : ptrDWord( offset );
55
}
56

57
///////////////////////////////////////////////////////////////////////////////
58

59
char ptrSignByte( MEMOFFSET_64 offset )
60
{
61
    return readPtr<char>(offset);
62
}
63

64
///////////////////////////////////////////////////////////////////////////////
65

66
short ptrSignWord( MEMOFFSET_64 offset )
67
{
68
    return readPtr<short>(offset);
69
}
70

71
///////////////////////////////////////////////////////////////////////////////
72

73
long ptrSignDWord( MEMOFFSET_64 offset )
74
{
75
    return readPtr<long>(offset);
76
}
77

78
///////////////////////////////////////////////////////////////////////////////
79

80
long long ptrSignQWord( MEMOFFSET_64 offset )
81
{
82
    return readPtr<long long>(offset);
83
}
84

85
///////////////////////////////////////////////////////////////////////////////
86

87
long long ptrSignMWord( MEMOFFSET_64 offset )
88
{
89
    return ptrSize() == 8 ? ptrSignQWord( offset ) : ptrSignDWord( offset );
90
}
91

92
///////////////////////////////////////////////////////////////////////////////
93

94
float ptrSingleFloat( MEMOFFSET_64 offset )
95
{
96
    return readPtr<float>(offset);
97
}
98

99
///////////////////////////////////////////////////////////////////////////////
100

101
double ptrDoubleFloat( MEMOFFSET_64 offset )
102
{
103
    return readPtr<double>(offset);
104
}
105

106
///////////////////////////////////////////////////////////////////////////////
107

108
template<typename T>
109
void setImpl( MEMOFFSET_64 offset, T value )
110
{
111
    writeMemory( offset, &value, sizeof(value), false );
112
}
113

114
///////////////////////////////////////////////////////////////////////////////
115

116
void setByte( MEMOFFSET_64 offset, unsigned char value )
117
{
118
    setImpl(offset, value);
119
}
120

121
///////////////////////////////////////////////////////////////////////////////
122

123
void setWord( MEMOFFSET_64 offset, unsigned short value )
124
{
125
    setImpl(offset, value);
126
}
127

128
///////////////////////////////////////////////////////////////////////////////
129

130

131
void setDWord( MEMOFFSET_64 offset, unsigned long value )
132
{
133
    setImpl(offset, value);
134
}
135

136
///////////////////////////////////////////////////////////////////////////////
137

138

139
void setQWord( MEMOFFSET_64 offset, unsigned long long value )
140
{
141
    setImpl(offset, value);
142
}
143

144
///////////////////////////////////////////////////////////////////////////////
145

146

147
void setSignByte( MEMOFFSET_64 offset, char value )
148
{
149
    setImpl(offset, value);
150
}
151

152
///////////////////////////////////////////////////////////////////////////////
153

154

155
void setSignWord( MEMOFFSET_64 offset, short value )
156
{
157
    setImpl(offset, value);
158
}
159

160
///////////////////////////////////////////////////////////////////////////////
161

162

163
void setSignDWord( MEMOFFSET_64 offset, long value )
164
{
165
    setImpl(offset, value);
166
}
167

168
///////////////////////////////////////////////////////////////////////////////
169

170

171
void setSignQWord( MEMOFFSET_64 offset, long long value )
172
{
173
    setImpl(offset, value);
174
}
175

176
///////////////////////////////////////////////////////////////////////////////
177

178

179
void setSingleFloat( MEMOFFSET_64 offset, float value )
180
{
181
    setImpl(offset, value);
182
}
183

184
///////////////////////////////////////////////////////////////////////////////
185

186

187
void setDoubleFloat( MEMOFFSET_64 offset, double value )
188
{
189
    setImpl(offset, value);
190
}
191

192
///////////////////////////////////////////////////////////////////////////////
193

194
template<typename T>
195
std::vector<T>
196
loadArray( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
197
{
198
    if (!phyAddr && !isVaRegionValid(offset, number*sizeof(T)))
199
        throw MemoryException(offset);
200

201
    std::vector<T>   buffer(number);
202

203
    if (number)
204
        readMemory( offset, &buffer[0], number*sizeof(T), phyAddr );
205

206
    return buffer;
207
}
208

209
/////////////////////////////////////////////////////////////////////////////////////
210

211
std::vector<unsigned char> loadBytes( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
212
{
213
    return loadArray<unsigned char>( offset, number, phyAddr );
214
}
215

216
/////////////////////////////////////////////////////////////////////////////////////
217

218
std::vector<unsigned short> loadWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
219
{
220
    return loadArray<unsigned short>( offset, number, phyAddr );
221
}
222

223
///////////////////////////////////////////////////////////////////////////////
224

225
std::vector<unsigned long> loadDWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
226
{
227
    return loadArray<unsigned long>( offset, number, phyAddr );
228
}
229

230
///////////////////////////////////////////////////////////////////////////////
231

232
std::vector<unsigned long long> loadQWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
233
{
234
    return loadArray<unsigned long long>( offset, number, phyAddr );
235
}
236

237
/////////////////////////////////////////////////////////////////////////////////////
238

239
std::vector<char> loadSignBytes( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
240
{
241
    return loadArray<char>( offset, number, phyAddr );
242
}
243

244
///////////////////////////////////////////////////////////////////////////////
245

246
std::vector<short> loadSignWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
247
{
248
    return loadArray<short>( offset, number, phyAddr );
249
}
250

251
///////////////////////////////////////////////////////////////////////////////
252

253
std::vector<long> loadSignDWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
254
{
255
    return loadArray<long>( offset, number, phyAddr );
256
}
257

258
///////////////////////////////////////////////////////////////////////////////
259

260
std::vector<long long> loadSignQWords( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
261
{
262
    return loadArray<long long>( offset, number, phyAddr );
263
}
264

265
///////////////////////////////////////////////////////////////////////////////
266

267
std::vector<float> loadFloats( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
268
{
269
    return loadArray<float>( offset, number, phyAddr );
270
}
271

272
///////////////////////////////////////////////////////////////////////////////
273

274
std::vector<double> loadDoubles( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
275
{
276
    return loadArray<double>( offset, number, phyAddr );
277
}
278

279
///////////////////////////////////////////////////////////////////////////////
280

281
template<typename T>
282
void writeArray( MEMOFFSET_64 offset, const std::vector<T> &values, bool phyAddr )
283
{
284
    if (values.empty())
285
        return;
286

287
    const auto length = values.size() * sizeof(T);
288

289
    if (!phyAddr && !isVaRegionValid(offset, length))
290
        throw MemoryException(offset);
291

292
    writeMemory( offset, &values[0], length, phyAddr );
293
}
294

295
///////////////////////////////////////////////////////////////////////////////
296

297
void writeBytes(MEMOFFSET_64 offset, const std::vector<unsigned char> &values, bool phyAddr )
298
{
299
    writeArray(offset, values, phyAddr);
300
}
301

302
///////////////////////////////////////////////////////////////////////////////
303

304
void writeWords( MEMOFFSET_64 offset, const std::vector<unsigned short> &values, bool phyAddr )
305
{
306
    writeArray(offset, values, phyAddr);
307
}
308

309
///////////////////////////////////////////////////////////////////////////////
310

311
void writeDWords( MEMOFFSET_64 offset, const std::vector<unsigned long> &values, bool phyAddr )
312
{
313
    writeArray(offset, values, phyAddr);
314
}
315

316
///////////////////////////////////////////////////////////////////////////////
317

318

319
void writeQWords( MEMOFFSET_64 offset, std::vector<unsigned long long> const &values, bool phyAddr )
320
{
321
    writeArray(offset, values, phyAddr);
322
}
323

324
///////////////////////////////////////////////////////////////////////////////
325

326

327
void writeSignBytes( MEMOFFSET_64 offset, const std::vector<char> &values, bool phyAddr )
328
{
329
    writeArray(offset, values, phyAddr);
330
}
331

332
///////////////////////////////////////////////////////////////////////////////
333

334

335
void writeSignWords( MEMOFFSET_64 offset, const std::vector<short> &values, bool phyAddr )
336
{
337
    writeArray(offset, values, phyAddr);
338
}
339

340
///////////////////////////////////////////////////////////////////////////////
341

342

343
void writeSignDWords( MEMOFFSET_64 offset, const std::vector<long> &values, bool phyAddr )
344
{
345
    writeArray(offset, values, phyAddr);
346
}
347

348
///////////////////////////////////////////////////////////////////////////////
349

350

351
void writeSignQWords( MEMOFFSET_64 offset, std::vector<long long> const &values, bool phyAddr )
352
{
353
    writeArray(offset, values, phyAddr);
354
}
355

356
///////////////////////////////////////////////////////////////////////////////
357

358

359
void writeFloats( MEMOFFSET_64 offset, const std::vector<float> &values, bool phyAddr )
360
{
361
    writeArray(offset, values, phyAddr);
362
}
363

364
///////////////////////////////////////////////////////////////////////////////
365

366

367
void writeDoubles( MEMOFFSET_64 offset, const std::vector<double> &values, bool phyAddr )
368
{
369
    writeArray(offset, values, phyAddr);
370
}
371

372
///////////////////////////////////////////////////////////////////////////////
373

374
std::string loadChars( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
375
{
376
    unsigned long  bufferSize = (unsigned long)(sizeof(std::vector<char>::value_type)*number);
377

378
    if (!phyAddr && !isVaRegionValid(offset, bufferSize))
379
        throw MemoryException(offset);
380

381
    std::vector<char>   buffer(number);
382
    
383
    if (number)
384
        readMemory( offset, &buffer[0], bufferSize, phyAddr );
385

386
    return std::string( buffer.begin(), buffer.end() );
387
}
388

389
///////////////////////////////////////////////////////////////////////////////
390

391
std::wstring loadWChars( MEMOFFSET_64 offset, unsigned long number, bool phyAddr )
392
{
393
    unsigned long   bufferSize = (unsigned long)(sizeof(std::vector<wchar_t>::value_type)*number);
394

395
    if (!phyAddr && !isVaRegionValid(offset, bufferSize))
396
        throw MemoryException(offset);
397

398
    std::vector<wchar_t>   buffer(number);
399

400
    if (number)
401
        readMemory( offset, &buffer[0], bufferSize, phyAddr );
402

403
    return std::wstring( buffer.begin(), buffer.end() );
404
}
405

406
///////////////////////////////////////////////////////////////////////////////
407

408
MEMOFFSET_64 ptrPtr( MEMOFFSET_64 offset, size_t psize)
409
{
410
    psize = psize == 0 ? ptrSize() : psize;
411

412
    if ( psize == 4 )
413
        return addr64(ptrDWord(offset) );
414

415
    if ( psize == 8 )
416
        return addr64(ptrQWord(offset) );
417

418
    throw DbgException("unknown pointer size");
419
}
420

421
///////////////////////////////////////////////////////////////////////////////
422

423
std::vector<MEMOFFSET_64> loadPtrs( MEMOFFSET_64 offset, unsigned long number, size_t psize )
424
{
425
    offset = addr64( offset );
426

427
    psize = psize == 0 ? ptrSize() : psize;
428

429
    if (!isVaRegionValid(offset, psize*number))
430
        throw MemoryException(offset);
431

432
    std::vector<MEMOFFSET_64>   ptrs(number);
433

434
    for ( unsigned long i = 0; i < number; ++i )
435
        ptrs[i] =ptrPtr( offset + i*psize, psize );
436

437
    return ptrs;
438
}
439

440
///////////////////////////////////////////////////////////////////////////////
441

442
std::vector<MEMOFFSET_64> loadPtrList( MEMOFFSET_64 offset, size_t psize )
443
{
444
    offset = addr64( offset );
445

446
    psize = psize == 0 ? ptrSize() : psize;
447

448
    std::vector<MEMOFFSET_64>   ptrs;
449
    ptrs.reserve(100);
450

451
    MEMOFFSET_64     entryAddress = 0;
452
    
453
    for( entryAddress = ptrPtr( offset, psize ); entryAddress != offset && entryAddress != 0; entryAddress = ptrPtr( entryAddress, psize ) )
454
       ptrs.push_back( entryAddress );
455
    
456
    return ptrs;
457
}
458

459
///////////////////////////////////////////////////////////////////////////////
460

461
void setPtr(MEMOFFSET_64 offset, MEMOFFSET_64 value, size_t psize)
462
{
463
    psize = psize == 0 ? ptrSize() : psize;
464

465
    if ( psize == 4 )
466
        return setDWord( offset, value & std::numeric_limits<MEMOFFSET_32>::max() );
467

468
    if ( psize == 8 )
469
        return setQWord( offset, value );
470

471
    throw DbgException("unknown pointer size");
472
}
473

474
///////////////////////////////////////////////////////////////////////////////
475

476
bool compareMemory( MEMOFFSET_64 addr1, MEMOFFSET_64 addr2, size_t length, bool phyAddr )
477
{
478
    bool        result = false;
479

480
    addr1 = addr64( addr1 );
481
    addr2 = addr64( addr2 );
482

483
    std::vector<char>   m1(length);
484
    std::vector<char>   m2(length);
485

486
    readMemory( addr1, &m1[0], length, phyAddr );
487
    readMemory( addr2, &m2[0], length, phyAddr );
488

489
    return std::equal( m1.begin(), m1.end(), m2.begin() );
490
}
491

492
///////////////////////////////////////////////////////////////////////////////
493

494
} // kdlib namespace end
495