1 // copyright (c) 2020-2021 hors<horsicq@gmail.com>
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to deal
5 // in the Software without restriction, including without limitation the rights
6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 // copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9
10 // The above copyright notice and this permission notice shall be included in all
11 // copies or substantial portions of the Software.
12
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 // SOFTWARE.
20 //
21 #include "xne.h"
22
XNE(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)23 XNE::XNE(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress) : XMSDOS(pDevice,bIsImage,nModuleAddress)
24 {
25
26 }
27
isValid()28 bool XNE::isValid()
29 {
30 bool bResult=false;
31
32 quint16 magic=get_magic();
33
34 if(magic==XMSDOS_DEF::S_IMAGE_DOS_SIGNATURE_MZ)
35 {
36 qint32 lfanew=get_lfanew();
37
38 if(lfanew>0)
39 {
40 quint32 signature=read_uint16(lfanew);
41
42 if(signature==XNE_DEF::S_IMAGE_OS2_SIGNATURE)
43 {
44 bResult=true;
45 }
46 }
47 }
48
49 return bResult;
50 }
51
isValid(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)52 bool XNE::isValid(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
53 {
54 XNE xne(pDevice,bIsImage,nModuleAddress);
55
56 return xne.isValid();
57 }
58
getMode(QIODevice * pDevice,bool bIsImage,qint64 nModuleAddress)59 XBinary::MODE XNE::getMode(QIODevice *pDevice, bool bIsImage, qint64 nModuleAddress)
60 {
61 XNE xne(pDevice,bIsImage,nModuleAddress);
62
63 return xne.getMode();
64 }
65
getImageOS2HeaderOffset()66 qint64 XNE::getImageOS2HeaderOffset()
67 {
68 qint64 nResult=get_lfanew();
69
70 if(!_isOffsetValid(nResult))
71 {
72 nResult=-1;
73 }
74
75 return nResult;
76 }
77
getImageOS2HeaderSize()78 qint64 XNE::getImageOS2HeaderSize()
79 {
80 return sizeof(XNE_DEF::IMAGE_OS2_HEADER);
81 }
82
getImageOS2Header()83 XNE_DEF::IMAGE_OS2_HEADER XNE::getImageOS2Header()
84 {
85 XNE_DEF::IMAGE_OS2_HEADER result={};
86
87 qint64 nOffset=getImageOS2HeaderOffset();
88
89 if(nOffset!=-1)
90 {
91 result.ne_magic=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_magic));
92 result.ne_ver=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_ver));
93 result.ne_rev=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rev));
94 result.ne_enttab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_enttab));
95 result.ne_cbenttab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbenttab));
96 result.ne_crc=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_crc));
97 result.ne_flags=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flags));
98 result.ne_autodata=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_autodata));
99 result.ne_heap=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_heap));
100 result.ne_stack=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_stack));
101 result.ne_csip=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_csip));
102 result.ne_sssp=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_sssp));
103 result.ne_cseg=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cseg));
104 result.ne_cmod=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmod));
105 result.ne_cbnrestab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbnrestab));
106 result.ne_segtab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_segtab));
107 result.ne_rsrctab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rsrctab));
108 result.ne_restab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_restab));
109 result.ne_modtab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_modtab));
110 result.ne_imptab=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_imptab));
111 result.ne_nrestab=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_nrestab));
112 result.ne_cmovent=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmovent));
113 result.ne_align=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_align));
114 result.ne_cres=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cres));
115 result.ne_exetyp=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_exetyp));
116 result.ne_flagsothers=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flagsothers));
117 result.ne_pretthunks=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_pretthunks));
118 result.ne_psegrefbytes=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_psegrefbytes));
119 result.ne_swaparea=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_swaparea));
120 result.ne_expver=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_expver));
121 }
122
123 return result;
124 }
125
getImageOS2Header_magic()126 quint16 XNE::getImageOS2Header_magic()
127 {
128 quint16 nResult=0;
129
130 qint64 nOffset=getImageOS2HeaderOffset();
131
132 if(nOffset!=-1)
133 {
134 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_magic));
135 }
136
137 return nResult;
138 }
139
getImageOS2Header_ver()140 quint8 XNE::getImageOS2Header_ver()
141 {
142 quint8 nResult=0;
143
144 qint64 nOffset=getImageOS2HeaderOffset();
145
146 if(nOffset!=-1)
147 {
148 nResult=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_ver));
149 }
150
151 return nResult;
152 }
153
getImageOS2Header_rev()154 quint8 XNE::getImageOS2Header_rev()
155 {
156 quint8 nResult=0;
157
158 qint64 nOffset=getImageOS2HeaderOffset();
159
160 if(nOffset!=-1)
161 {
162 nResult=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rev));
163 }
164
165 return nResult;
166 }
167
getImageOS2Header_enttab()168 quint16 XNE::getImageOS2Header_enttab()
169 {
170 quint16 nResult=0;
171
172 qint64 nOffset=getImageOS2HeaderOffset();
173
174 if(nOffset!=-1)
175 {
176 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_enttab));
177 }
178
179 return nResult;
180 }
181
getImageOS2Header_cbenttab()182 quint16 XNE::getImageOS2Header_cbenttab()
183 {
184 quint16 nResult=0;
185
186 qint64 nOffset=getImageOS2HeaderOffset();
187
188 if(nOffset!=-1)
189 {
190 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbenttab));
191 }
192
193 return nResult;
194 }
195
getImageOS2Header_crc()196 quint32 XNE::getImageOS2Header_crc()
197 {
198 quint32 nResult=0;
199
200 qint64 nOffset=getImageOS2HeaderOffset();
201
202 if(nOffset!=-1)
203 {
204 nResult=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_crc));
205 }
206
207 return nResult;
208 }
209
getImageOS2Header_flags()210 quint16 XNE::getImageOS2Header_flags()
211 {
212 quint16 nResult=0;
213
214 qint64 nOffset=getImageOS2HeaderOffset();
215
216 if(nOffset!=-1)
217 {
218 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flags));
219 }
220
221 return nResult;
222 }
223
getImageOS2Header_autodata()224 quint16 XNE::getImageOS2Header_autodata()
225 {
226 quint16 nResult=0;
227
228 qint64 nOffset=getImageOS2HeaderOffset();
229
230 if(nOffset!=-1)
231 {
232 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_autodata));
233 }
234
235 return nResult;
236 }
237
getImageOS2Header_heap()238 quint16 XNE::getImageOS2Header_heap()
239 {
240 quint16 nResult=0;
241
242 qint64 nOffset=getImageOS2HeaderOffset();
243
244 if(nOffset!=-1)
245 {
246 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_heap));
247 }
248
249 return nResult;
250 }
251
getImageOS2Header_stack()252 quint16 XNE::getImageOS2Header_stack()
253 {
254 quint16 nResult=0;
255
256 qint64 nOffset=getImageOS2HeaderOffset();
257
258 if(nOffset!=-1)
259 {
260 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_stack));
261 }
262
263 return nResult;
264 }
265
getImageOS2Header_csip()266 quint32 XNE::getImageOS2Header_csip()
267 {
268 quint32 nResult=0;
269
270 qint64 nOffset=getImageOS2HeaderOffset();
271
272 if(nOffset!=-1)
273 {
274 nResult=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_csip));
275 }
276
277 return nResult;
278 }
279
getImageOS2Header_sssp()280 quint32 XNE::getImageOS2Header_sssp()
281 {
282 quint32 nResult=0;
283
284 qint64 nOffset=getImageOS2HeaderOffset();
285
286 if(nOffset!=-1)
287 {
288 nResult=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_sssp));
289 }
290
291 return nResult;
292 }
293
getImageOS2Header_cseg()294 quint16 XNE::getImageOS2Header_cseg()
295 {
296 quint16 nResult=0;
297
298 qint64 nOffset=getImageOS2HeaderOffset();
299
300 if(nOffset!=-1)
301 {
302 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cseg));
303 }
304
305 return nResult;
306 }
307
getImageOS2Header_cmod()308 quint16 XNE::getImageOS2Header_cmod()
309 {
310 quint16 nResult=0;
311
312 qint64 nOffset=getImageOS2HeaderOffset();
313
314 if(nOffset!=-1)
315 {
316 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmod));
317 }
318
319 return nResult;
320 }
321
getImageOS2Header_cbnrestab()322 quint16 XNE::getImageOS2Header_cbnrestab()
323 {
324 quint16 nResult=0;
325
326 qint64 nOffset=getImageOS2HeaderOffset();
327
328 if(nOffset!=-1)
329 {
330 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbnrestab));
331 }
332
333 return nResult;
334 }
335
getImageOS2Header_segtab()336 quint16 XNE::getImageOS2Header_segtab()
337 {
338 quint16 nResult=0;
339
340 qint64 nOffset=getImageOS2HeaderOffset();
341
342 if(nOffset!=-1)
343 {
344 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_segtab));
345 }
346
347 return nResult;
348 }
349
getImageOS2Header_rsrctab()350 quint16 XNE::getImageOS2Header_rsrctab()
351 {
352 quint16 nResult=0;
353
354 qint64 nOffset=getImageOS2HeaderOffset();
355
356 if(nOffset!=-1)
357 {
358 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rsrctab));
359 }
360
361 return nResult;
362 }
363
getImageOS2Header_restab()364 quint16 XNE::getImageOS2Header_restab()
365 {
366 quint16 nResult=0;
367
368 qint64 nOffset=getImageOS2HeaderOffset();
369
370 if(nOffset!=-1)
371 {
372 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_restab));
373 }
374
375 return nResult;
376 }
377
getImageOS2Header_modtab()378 quint16 XNE::getImageOS2Header_modtab()
379 {
380 quint16 nResult=0;
381
382 qint64 nOffset=getImageOS2HeaderOffset();
383
384 if(nOffset!=-1)
385 {
386 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_modtab));
387 }
388
389 return nResult;
390 }
391
getImageOS2Header_imptab()392 quint16 XNE::getImageOS2Header_imptab()
393 {
394 quint16 nResult=0;
395
396 qint64 nOffset=getImageOS2HeaderOffset();
397
398 if(nOffset!=-1)
399 {
400 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_imptab));
401 }
402
403 return nResult;
404 }
405
getImageOS2Header_nrestab()406 quint32 XNE::getImageOS2Header_nrestab()
407 {
408 quint32 nResult=0;
409
410 qint64 nOffset=getImageOS2HeaderOffset();
411
412 if(nOffset!=-1)
413 {
414 nResult=read_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_nrestab));
415 }
416
417 return nResult;
418 }
419
getImageOS2Header_cmovent()420 quint16 XNE::getImageOS2Header_cmovent()
421 {
422 quint16 nResult=0;
423
424 qint64 nOffset=getImageOS2HeaderOffset();
425
426 if(nOffset!=-1)
427 {
428 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmovent));
429 }
430
431 return nResult;
432 }
433
getImageOS2Header_align()434 quint16 XNE::getImageOS2Header_align()
435 {
436 quint16 nResult=0;
437
438 qint64 nOffset=getImageOS2HeaderOffset();
439
440 if(nOffset!=-1)
441 {
442 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_align));
443 }
444
445 return nResult;
446 }
447
getImageOS2Header_cres()448 quint16 XNE::getImageOS2Header_cres()
449 {
450 quint16 nResult=0;
451
452 qint64 nOffset=getImageOS2HeaderOffset();
453
454 if(nOffset!=-1)
455 {
456 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cres));
457 }
458
459 return nResult;
460 }
461
getImageOS2Header_exetyp()462 quint8 XNE::getImageOS2Header_exetyp()
463 {
464 quint8 nResult=0;
465
466 qint64 nOffset=getImageOS2HeaderOffset();
467
468 if(nOffset!=-1)
469 {
470 nResult=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_exetyp));
471 }
472
473 return nResult;
474 }
475
getImageOS2Header_flagsothers()476 quint8 XNE::getImageOS2Header_flagsothers()
477 {
478 quint8 nResult=0;
479
480 qint64 nOffset=getImageOS2HeaderOffset();
481
482 if(nOffset!=-1)
483 {
484 nResult=read_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flagsothers));
485 }
486
487 return nResult;
488 }
489
getImageOS2Header_pretthunks()490 quint16 XNE::getImageOS2Header_pretthunks()
491 {
492 quint16 nResult=0;
493
494 qint64 nOffset=getImageOS2HeaderOffset();
495
496 if(nOffset!=-1)
497 {
498 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_pretthunks));
499 }
500
501 return nResult;
502 }
503
getImageOS2Header_psegrefbytes()504 quint16 XNE::getImageOS2Header_psegrefbytes()
505 {
506 quint16 nResult=0;
507
508 qint64 nOffset=getImageOS2HeaderOffset();
509
510 if(nOffset!=-1)
511 {
512 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_psegrefbytes));
513 }
514
515 return nResult;
516 }
517
getImageOS2Header_swaparea()518 quint16 XNE::getImageOS2Header_swaparea()
519 {
520 quint16 nResult=0;
521
522 qint64 nOffset=getImageOS2HeaderOffset();
523
524 if(nOffset!=-1)
525 {
526 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_swaparea));
527 }
528
529 return nResult;
530 }
531
getImageOS2Header_expver()532 quint16 XNE::getImageOS2Header_expver()
533 {
534 quint16 nResult=0;
535
536 qint64 nOffset=getImageOS2HeaderOffset();
537
538 if(nOffset!=-1)
539 {
540 nResult=read_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_expver));
541 }
542
543 return nResult;
544 }
545
setImageOS2Header_magic(quint16 nValue)546 void XNE::setImageOS2Header_magic(quint16 nValue)
547 {
548 qint64 nOffset=getImageOS2HeaderOffset();
549
550 if(nOffset!=-1)
551 {
552 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_magic),nValue);
553 }
554 }
555
setImageOS2Header_ver(quint8 nValue)556 void XNE::setImageOS2Header_ver(quint8 nValue)
557 {
558 qint64 nOffset=getImageOS2HeaderOffset();
559
560 if(nOffset!=-1)
561 {
562 write_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_ver),nValue);
563 }
564 }
565
setImageOS2Header_rev(quint8 nValue)566 void XNE::setImageOS2Header_rev(quint8 nValue)
567 {
568 qint64 nOffset=getImageOS2HeaderOffset();
569
570 if(nOffset!=-1)
571 {
572 write_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rev),nValue);
573 }
574 }
575
setImageOS2Header_enttab(quint16 nValue)576 void XNE::setImageOS2Header_enttab(quint16 nValue)
577 {
578 qint64 nOffset=getImageOS2HeaderOffset();
579
580 if(nOffset!=-1)
581 {
582 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_enttab),nValue);
583 }
584 }
585
setImageOS2Header_cbenttab(quint16 nValue)586 void XNE::setImageOS2Header_cbenttab(quint16 nValue)
587 {
588 qint64 nOffset=getImageOS2HeaderOffset();
589
590 if(nOffset!=-1)
591 {
592 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbenttab),nValue);
593 }
594 }
595
setImageOS2Header_crc(quint32 nValue)596 void XNE::setImageOS2Header_crc(quint32 nValue)
597 {
598 qint64 nOffset=getImageOS2HeaderOffset();
599
600 if(nOffset!=-1)
601 {
602 write_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_crc),nValue);
603 }
604 }
605
setImageOS2Header_flags(quint16 nValue)606 void XNE::setImageOS2Header_flags(quint16 nValue)
607 {
608 qint64 nOffset=getImageOS2HeaderOffset();
609
610 if(nOffset!=-1)
611 {
612 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flags),nValue);
613 }
614 }
615
setImageOS2Header_autodata(quint16 nValue)616 void XNE::setImageOS2Header_autodata(quint16 nValue)
617 {
618 qint64 nOffset=getImageOS2HeaderOffset();
619
620 if(nOffset!=-1)
621 {
622 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_autodata),nValue);
623 }
624 }
625
setImageOS2Header_heap(quint16 nValue)626 void XNE::setImageOS2Header_heap(quint16 nValue)
627 {
628 qint64 nOffset=getImageOS2HeaderOffset();
629
630 if(nOffset!=-1)
631 {
632 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_heap),nValue);
633 }
634 }
635
setImageOS2Header_stack(quint16 nValue)636 void XNE::setImageOS2Header_stack(quint16 nValue)
637 {
638 qint64 nOffset=getImageOS2HeaderOffset();
639
640 if(nOffset!=-1)
641 {
642 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_stack),nValue);
643 }
644 }
645
setImageOS2Header_csip(quint32 nValue)646 void XNE::setImageOS2Header_csip(quint32 nValue)
647 {
648 qint64 nOffset=getImageOS2HeaderOffset();
649
650 if(nOffset!=-1)
651 {
652 write_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_csip),nValue);
653 }
654 }
655
setImageOS2Header_sssp(quint32 nValue)656 void XNE::setImageOS2Header_sssp(quint32 nValue)
657 {
658 qint64 nOffset=getImageOS2HeaderOffset();
659
660 if(nOffset!=-1)
661 {
662 write_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_sssp),nValue);
663 }
664 }
665
setImageOS2Header_cseg(quint16 nValue)666 void XNE::setImageOS2Header_cseg(quint16 nValue)
667 {
668 qint64 nOffset=getImageOS2HeaderOffset();
669
670 if(nOffset!=-1)
671 {
672 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cseg),nValue);
673 }
674 }
675
setImageOS2Header_cmod(quint16 nValue)676 void XNE::setImageOS2Header_cmod(quint16 nValue)
677 {
678 qint64 nOffset=getImageOS2HeaderOffset();
679
680 if(nOffset!=-1)
681 {
682 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmod),nValue);
683 }
684 }
685
setImageOS2Header_cbnrestab(quint16 nValue)686 void XNE::setImageOS2Header_cbnrestab(quint16 nValue)
687 {
688 qint64 nOffset=getImageOS2HeaderOffset();
689
690 if(nOffset!=-1)
691 {
692 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cbnrestab),nValue);
693 }
694 }
695
setImageOS2Header_segtab(quint16 nValue)696 void XNE::setImageOS2Header_segtab(quint16 nValue)
697 {
698 qint64 nOffset=getImageOS2HeaderOffset();
699
700 if(nOffset!=-1)
701 {
702 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_segtab),nValue);
703 }
704 }
705
setImageOS2Header_rsrctab(quint16 nValue)706 void XNE::setImageOS2Header_rsrctab(quint16 nValue)
707 {
708 qint64 nOffset=getImageOS2HeaderOffset();
709
710 if(nOffset!=-1)
711 {
712 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_rsrctab),nValue);
713 }
714 }
715
setImageOS2Header_restab(quint16 nValue)716 void XNE::setImageOS2Header_restab(quint16 nValue)
717 {
718 qint64 nOffset=getImageOS2HeaderOffset();
719
720 if(nOffset!=-1)
721 {
722 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_restab),nValue);
723 }
724 }
725
setImageOS2Header_modtab(quint16 nValue)726 void XNE::setImageOS2Header_modtab(quint16 nValue)
727 {
728 qint64 nOffset=getImageOS2HeaderOffset();
729
730 if(nOffset!=-1)
731 {
732 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_modtab),nValue);
733 }
734 }
735
setImageOS2Header_imptab(quint16 nValue)736 void XNE::setImageOS2Header_imptab(quint16 nValue)
737 {
738 qint64 nOffset=getImageOS2HeaderOffset();
739
740 if(nOffset!=-1)
741 {
742 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_imptab),nValue);
743 }
744 }
745
setImageOS2Header_nrestab(quint32 nValue)746 void XNE::setImageOS2Header_nrestab(quint32 nValue)
747 {
748 qint64 nOffset=getImageOS2HeaderOffset();
749
750 if(nOffset!=-1)
751 {
752 write_uint32(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_nrestab),nValue);
753 }
754 }
755
setImageOS2Header_cmovent(quint16 nValue)756 void XNE::setImageOS2Header_cmovent(quint16 nValue)
757 {
758 qint64 nOffset=getImageOS2HeaderOffset();
759
760 if(nOffset!=-1)
761 {
762 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cmovent),nValue);
763 }
764 }
765
setImageOS2Header_align(quint16 nValue)766 void XNE::setImageOS2Header_align(quint16 nValue)
767 {
768 qint64 nOffset=getImageOS2HeaderOffset();
769
770 if(nOffset!=-1)
771 {
772 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_align),nValue);
773 }
774 }
775
setImageOS2Header_cres(quint16 nValue)776 void XNE::setImageOS2Header_cres(quint16 nValue)
777 {
778 qint64 nOffset=getImageOS2HeaderOffset();
779
780 if(nOffset!=-1)
781 {
782 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_cres),nValue);
783 }
784 }
785
setImageOS2Header_exetyp(quint8 nValue)786 void XNE::setImageOS2Header_exetyp(quint8 nValue)
787 {
788 qint64 nOffset=getImageOS2HeaderOffset();
789
790 if(nOffset!=-1)
791 {
792 write_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_exetyp),nValue);
793 }
794 }
795
setImageOS2Header_flagsothers(quint8 nValue)796 void XNE::setImageOS2Header_flagsothers(quint8 nValue)
797 {
798 qint64 nOffset=getImageOS2HeaderOffset();
799
800 if(nOffset!=-1)
801 {
802 write_uint8(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_flagsothers),nValue);
803 }
804 }
805
setImageOS2Header_pretthunks(quint16 nValue)806 void XNE::setImageOS2Header_pretthunks(quint16 nValue)
807 {
808 qint64 nOffset=getImageOS2HeaderOffset();
809
810 if(nOffset!=-1)
811 {
812 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_pretthunks),nValue);
813 }
814 }
815
setImageOS2Header_psegrefbytes(quint16 nValue)816 void XNE::setImageOS2Header_psegrefbytes(quint16 nValue)
817 {
818 qint64 nOffset=getImageOS2HeaderOffset();
819
820 if(nOffset!=-1)
821 {
822 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_psegrefbytes),nValue);
823 }
824 }
825
setImageOS2Header_swaparea(quint16 nValue)826 void XNE::setImageOS2Header_swaparea(quint16 nValue)
827 {
828 qint64 nOffset=getImageOS2HeaderOffset();
829
830 if(nOffset!=-1)
831 {
832 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_swaparea),nValue);
833 }
834 }
835
setImageOS2Header_expver(quint16 nValue)836 void XNE::setImageOS2Header_expver(quint16 nValue)
837 {
838 qint64 nOffset=getImageOS2HeaderOffset();
839
840 if(nOffset!=-1)
841 {
842 write_uint16(nOffset+offsetof(XNE_DEF::IMAGE_OS2_HEADER,ne_expver),nValue);
843 }
844 }
845
getEntryTableOffset()846 qint64 XNE::getEntryTableOffset()
847 {
848 return getImageOS2HeaderOffset()+getImageOS2Header_enttab();
849 }
850
getEntryTableSize()851 qint64 XNE::getEntryTableSize()
852 {
853 return getImageOS2Header_cbenttab();
854 }
855
getSegmentTableOffset()856 qint64 XNE::getSegmentTableOffset()
857 {
858 return getImageOS2HeaderOffset()+getImageOS2Header_segtab();
859 }
860
getResourceTableOffset()861 qint64 XNE::getResourceTableOffset()
862 {
863 return getImageOS2HeaderOffset()+getImageOS2Header_rsrctab();
864 }
865
getResidentNameTableOffset()866 qint64 XNE::getResidentNameTableOffset()
867 {
868 return getImageOS2HeaderOffset()+getImageOS2Header_restab();
869 }
870
getModuleReferenceTableOffset()871 qint64 XNE::getModuleReferenceTableOffset()
872 {
873 return getImageOS2HeaderOffset()+getImageOS2Header_modtab();
874 }
875
getImportedNamesTableOffset()876 qint64 XNE::getImportedNamesTableOffset()
877 {
878 return getImageOS2HeaderOffset()+getImageOS2Header_imptab();
879 }
880
getNotResindentNameTableOffset()881 qint64 XNE::getNotResindentNameTableOffset()
882 {
883 return getImageOS2Header_nrestab();
884 }
885
getSegmentList()886 QList<XNE_DEF::NE_SEGMENT> XNE::getSegmentList()
887 {
888 QList<XNE_DEF::NE_SEGMENT> listResult;
889
890 qint64 nOffset=getSegmentTableOffset();
891 int nNumberOfSegments=getImageOS2Header_cseg();
892
893 for(int i=0;i<nNumberOfSegments;i++)
894 {
895 XNE_DEF::NE_SEGMENT segment=_read_NE_SEGMENT(nOffset);
896
897 listResult.append(segment);
898
899 nOffset+=sizeof(XNE_DEF::NE_SEGMENT);
900 }
901
902 return listResult;
903 }
904
_read_NE_SEGMENT(qint64 nOffset)905 XNE_DEF::NE_SEGMENT XNE::_read_NE_SEGMENT(qint64 nOffset)
906 {
907 XNE_DEF::NE_SEGMENT result={};
908
909 result.dwFileOffset=read_uint16(nOffset+offsetof(XNE_DEF::NE_SEGMENT,dwFileOffset));
910 result.dwFileSize=read_uint16(nOffset+offsetof(XNE_DEF::NE_SEGMENT,dwFileSize));
911 result.dwFlags=read_uint16(nOffset+offsetof(XNE_DEF::NE_SEGMENT,dwFlags));
912 result.dwMinAllocSize=read_uint16(nOffset+offsetof(XNE_DEF::NE_SEGMENT,dwMinAllocSize));
913
914 return result;
915 }
916
getMemoryMap()917 XBinary::_MEMORY_MAP XNE::getMemoryMap()
918 {
919 _MEMORY_MAP result={};
920
921 qint32 nIndex=0;
922
923 result.sArch=getArch();
924 result.sType=getTypeAsString();
925
926 result.fileType=FT_NE;
927 result.mode=MODE_16SEG;
928 result.nRawSize=getSize();
929
930 QList<XNE_DEF::NE_SEGMENT> listSegments=getSegmentList();
931
932 int nNumberOfSegments=listSegments.count();
933
934 result.nModuleAddress=0x10000; // TODO const
935 result.nImageSize=nNumberOfSegments*0x10000; // TODO Check
936
937 qint64 nMaxOffset=0;
938
939 for(int i=0;i<nNumberOfSegments;i++)
940 {
941 qint64 nFileSize=listSegments.at(i).dwFileSize;
942 qint64 nFileOffset=listSegments.at(i).dwFileOffset*0x200;
943
944 if(nFileSize==0)
945 {
946 nFileSize=0x10000;
947 }
948
949 nFileSize=S_ALIGN_UP(nFileSize,0x200); // TODO const
950
951 if(nFileOffset) // if offset = 0 no data
952 {
953 _MEMORY_RECORD record={};
954 record.nSize=nFileSize;
955 record.nOffset=nFileOffset;
956 record.nAddress=(i+1)*0x10000; // TODO const
957 record.segment=ADDRESS_SEGMENT_UNKNOWN;
958 record.type=MMT_LOADSEGMENT;
959 record.nIndex=nIndex++;
960
961 result.listRecords.append(record);
962 }
963
964 if(0x10000-nFileSize)
965 {
966 _MEMORY_RECORD record={};
967 record.nSize=0x10000-nFileSize;
968 record.nOffset=-1;
969 record.nAddress=(i+1)*0x10000+nFileSize; // TODO const
970 record.segment=ADDRESS_SEGMENT_UNKNOWN;
971 record.type=MMT_LOADSEGMENT;
972 record.nIndex=nIndex++;
973 record.bIsVirtual=true;
974
975 result.listRecords.append(record);
976 }
977
978 if(nFileOffset)
979 {
980 nMaxOffset=qMax(nMaxOffset,nFileOffset+nFileSize);
981 }
982 }
983
984 // TODO Overlay !!!
985 // Check overlay!!
986 // qint64 nOverlaySize=result.nRawSize-nMaxOffset;
987
988 // if(nOverlaySize>0)
989 // {
990 // XBinary::_MEMORY_RECORD record={};
991
992 // record.type=MMT_OVERLAY;
993 // record.nAddress=-1;
994 // record.nSize=nOverlaySize;
995 // record.nOffset=nMaxOffset;
996 // record.nIndex=nIndex++;
997
998 // result.listRecords.append(record);
999 // }
1000
1001 return result;
1002 }
1003
getImageNEMagics()1004 QMap<quint64, QString> XNE::getImageNEMagics()
1005 {
1006 QMap<quint64, QString> mapResult;
1007
1008 mapResult.insert(0x454E,"IMAGE_OS2_SIGNATURE");
1009
1010 return mapResult;
1011 }
1012
getImageNEMagicsS()1013 QMap<quint64, QString> XNE::getImageNEMagicsS()
1014 {
1015 QMap<quint64, QString> mapResult;
1016
1017 mapResult.insert(0x454E,"OS2_SIGNATURE");
1018
1019 return mapResult;
1020 }
1021
getImageNEFlagsS()1022 QMap<quint64, QString> XNE::getImageNEFlagsS()
1023 {
1024 QMap<quint64, QString> mapResult;
1025
1026 mapResult.insert(0x0001,"single shared");
1027 mapResult.insert(0x0002,"multiple");
1028 mapResult.insert(0x0004,"Global initialization");
1029 mapResult.insert(0x0008,"Protected mode only");
1030 mapResult.insert(0x0010,"8086 instructions");
1031 mapResult.insert(0x0020,"80286 instructions");
1032 mapResult.insert(0x0040,"80386 instructions");
1033 mapResult.insert(0x0080,"80x87 instructions");
1034 mapResult.insert(0x0100,"Full screen");
1035 mapResult.insert(0x0200,"Compatible with Windows/P.M.");
1036 // mapResult.insert(0x0400,""); // TODO Check !!!
1037 mapResult.insert(0x0800,"OS/2 family application");
1038 mapResult.insert(0x1000,"reserved?");
1039 mapResult.insert(0x2000,"Errors in image/executable");
1040 mapResult.insert(0x4000,"non-conforming program");
1041 mapResult.insert(0x8000,"DLL or driver");
1042
1043 return mapResult;
1044 }
1045
getImageNEExetypesS()1046 QMap<quint64, QString> XNE::getImageNEExetypesS()
1047 {
1048 QMap<quint64, QString> mapResult;
1049
1050 mapResult.insert(0x0000,"unknown");
1051 mapResult.insert(0x0001,"OS/2");
1052 mapResult.insert(0x0002,"Windows");
1053 mapResult.insert(0x0003,"European MS-DOS 4.x");
1054 mapResult.insert(0x0004,"Windows 386");
1055 mapResult.insert(0x0005,"BOSS (Borland Operating System Services)");
1056
1057 return mapResult;
1058 }
1059
getImageNEFlagsothersS()1060 QMap<quint64, QString> XNE::getImageNEFlagsothersS()
1061 {
1062 QMap<quint64, QString> mapResult;
1063
1064 mapResult.insert(0x0001,"Long filename support");
1065 mapResult.insert(0x0002,"2.x protected mode");
1066 mapResult.insert(0x0004,"2.x proportional fonts");
1067 mapResult.insert(0x0008,"Executable has gangload area");
1068
1069 return mapResult;
1070 }
1071
getImageSegmentTypesS()1072 QMap<quint64, QString> XNE::getImageSegmentTypesS()
1073 {
1074 QMap<quint64, QString> mapResult;
1075
1076 mapResult.insert(0x0000,"CODE");
1077 mapResult.insert(0x0001,"DATA");
1078
1079 return mapResult;
1080 }
1081
getMode()1082 XBinary::MODE XNE::getMode()
1083 {
1084 return MODE_16SEG;
1085 }
1086
getArch()1087 QString XNE::getArch()
1088 {
1089 QString sResult="8086";
1090
1091 // TODO
1092
1093 return sResult;
1094 }
1095
isBigEndian()1096 bool XNE::isBigEndian()
1097 {
1098 return false;
1099 }
1100
getEntryPointOffset(XBinary::_MEMORY_MAP * pMemoryMap)1101 qint64 XNE::getEntryPointOffset(XBinary::_MEMORY_MAP *pMemoryMap)
1102 {
1103 return addressToOffset(pMemoryMap,getImageOS2Header_csip());
1104 }
1105
getFileType()1106 XBinary::FT XNE::getFileType()
1107 {
1108 return FT_NE;
1109 }
1110
getType()1111 int XNE::getType()
1112 {
1113 return TYPE_EXE; // TODO
1114 }
1115
typeIdToString(int nType)1116 QString XNE::typeIdToString(int nType)
1117 {
1118 QString sResult="Unknown"; // mb TODO translate
1119
1120 switch(nType)
1121 {
1122 case TYPE_UNKNOWN: sResult=QString("Unknown"); break; // mb TODO translate
1123 case TYPE_EXE: sResult=QString("EXE"); break;
1124 case TYPE_DLL: sResult=QString("DLL"); break;
1125 case TYPE_DRIVER: sResult=QString("Driver"); break;
1126 }
1127
1128 return sResult;
1129 }
1130