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