static int pageraddfile(const char *wtitle,
const char *filename, int enc,
int deleteonexit)
{
ConsoleData p = getdata(pagerInstance);
int i;
xbuf nxbuf = file2xbuf(filename, enc, deleteonexit);
if (!nxbuf) {
/* R_ShowMessage("File not found or memory insufficient"); */
return 0;
}
if (pagerActualKept == PAGERMAXKEPT) {
pagerActualKept -= 1;
xbufdel(pagerXbuf[pagerActualKept]);
}
if(pagerActualKept > 0)
pagerRow[0] = FV;
for (i = pagerActualKept; i > 0; i--) {
pagerXbuf[i] = pagerXbuf[i - 1];
pagerRow[i] = pagerRow[i - 1];
strcpy(&pagerTitles[i][4], &pagerTitles[i - 1][4]);
}
pagerXbuf[0] = nxbuf;
pagerRow[0] = 0;
strcpy(&pagerTitles[0][4], wtitle);
pagerActualKept += 1;
for (i = 0; i < pagerActualKept; i++) {
enable(pagerMenus[i]);
settext(pagerMenus[i], pagerTitles[i]);
}
for (i = pagerActualKept; i < PAGERMAXKEPT; i++)
disable(pagerMenus[i]);
uncheck(pagerMenus[pagerActualShown]);
pagerActualShown = 0;
check(pagerMenus[pagerActualShown]);
return 1;
}
int Qt1::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: fun(); break;
case 1: fun1((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 2: fun3((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 3: fun2(); break;
case 4: tellme((*reinterpret_cast< int(*)>(_a[1]))); break;
case 5: textchange(); break;
case 6: addtext(); break;
case 7: settext((*reinterpret_cast< int(*)>(_a[1]))); break;
case 8: settext1((*reinterpret_cast< QString(*)>(_a[1]))); break;
case 9: settext2((*reinterpret_cast< int(*)>(_a[1]))); break;
case 10: displayimage(); break;
case 11: displayqt2(); break;
}
_id -= 12;
}
return _id;
}
void terminate( void ) {
free_all( );
restorecrtmode( );
closegraph( );
settext( );
}
/*
* Elf32 binaries.
*/
static int
elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
{
ulong (*swal)(ulong);
ushort (*swab)(ushort);
Ehdr *ep;
Phdr *ph;
int i, it, id, is, phsz;
/* bitswap the header according to the DATA format */
ep = &hp->e;
if(ep->ident[CLASS] != ELFCLASS32) {
werrstr("bad ELF class - not 32 bit");
return 0;
}
if(ep->ident[DATA] == ELFDATA2LSB) {
swab = leswab;
swal = leswal;
} else if(ep->ident[DATA] == ELFDATA2MSB) {
swab = beswab;
swal = beswal;
} else {
werrstr("bad ELF encoding - not big or little endian");
return 0;
}
ep->type = swab(ep->type);
ep->machine = swab(ep->machine);
ep->version = swal(ep->version);
ep->elfentry = swal(ep->elfentry);
ep->phoff = swal(ep->phoff);
ep->shoff = swal(ep->shoff);
ep->flags = swal(ep->flags);
ep->ehsize = swab(ep->ehsize);
ep->phentsize = swab(ep->phentsize);
ep->phnum = swab(ep->phnum);
ep->shentsize = swab(ep->shentsize);
ep->shnum = swab(ep->shnum);
ep->shstrndx = swab(ep->shstrndx);
if(ep->type != EXEC || ep->version != CURRENT)
return 0;
/* we could definitely support a lot more machines here */
fp->magic = ELF_MAG;
fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
switch(ep->machine) {
case I386:
mach = &mi386;
fp->type = FI386;
break;
case MIPS:
mach = &mmips;
fp->type = FMIPS;
break;
case SPARC64:
mach = &msparc64;
fp->type = FSPARC64;
break;
case POWER:
mach = &mpower;
fp->type = FPOWER;
break;
case AMD64:
mach = &mamd64;
fp->type = FAMD64;
break;
case ARM:
mach = &marm;
fp->type = FARM;
break;
default:
return 0;
}
if(ep->phentsize != sizeof(Phdr)) {
werrstr("bad ELF header size");
return 0;
}
phsz = sizeof(Phdr)*ep->phnum;
ph = malloc(phsz);
if(!ph)
return 0;
seek(fd, ep->phoff, 0);
if(read(fd, ph, phsz) < 0) {
free(ph);
return 0;
}
hswal(ph, phsz/sizeof(ulong), swal);
/* find text, data and symbols and install them */
it = id = is = -1;
for(i = 0; i < ep->phnum; i++) {
if(ph[i].type == LOAD
&& (ph[i].flags & (R|X)) == (R|X) && it == -1)
it = i;
else if(ph[i].type == LOAD
&& (ph[i].flags & (R|W)) == (R|W) && id == -1)
id = i;
else if(ph[i].type == NOPTYPE && is == -1)
is = i;
}
if(it == -1 || id == -1) {
/*
* The SPARC64 boot image is something of an ELF hack.
* Text+Data+BSS are represented by ph[0]. Symbols
* are represented by ph[1]:
*
* filesz, memsz, vaddr, paddr, off
* ph[0] : txtsz+datsz, txtsz+datsz+bsssz, txtaddr-KZERO, datasize, txtoff
* ph[1] : symsz, lcsz, 0, 0, symoff
*/
if(ep->machine == SPARC64 && ep->phnum == 2) {
ulong txtaddr, txtsz, dataddr, bsssz;
txtaddr = ph[0].vaddr | 0x80000000;
txtsz = ph[0].filesz - ph[0].paddr;
dataddr = txtaddr + txtsz;
bsssz = ph[0].memsz - ph[0].filesz;
settext(fp, ep->elfentry | 0x80000000, txtaddr, txtsz, ph[0].offset);
setdata(fp, dataddr, ph[0].paddr, ph[0].offset + txtsz, bsssz);
setsym(fp, ph[1].filesz, 0, ph[1].memsz, ph[1].offset);
free(ph);
return 1;
}
werrstr("No TEXT or DATA sections");
free(ph);
return 0;
}
settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, ph[id].memsz - ph[id].filesz);
if(is != -1)
setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
free(ph);
return 1;
}
/*
* ELF64 binaries.
*/
static int
elf64dotout(int fd, Fhdr *fp, ExecHdr *hp)
{
E64hdr *ep;
P64hdr *ph;
ushort (*swab)(ushort);
ulong (*swal)(ulong);
uvlong (*swav)(uvlong);
int i, it, id, is, phsz;
uvlong uvl;
ep = &hp->e;
if(ep->ident[DATA] == ELFDATA2LSB) {
swab = leswab;
swal = leswal;
swav = leswav;
} else if(ep->ident[DATA] == ELFDATA2MSB) {
swab = beswab;
swal = beswal;
swav = beswav;
} else {
werrstr("bad ELF64 encoding - not big or little endian");
return 0;
}
ep->type = swab(ep->type);
ep->machine = swab(ep->machine);
ep->version = swal(ep->version);
if(ep->type != EXEC || ep->version != CURRENT)
return 0;
ep->elfentry = swav(ep->elfentry);
ep->phoff = swav(ep->phoff);
ep->shoff = swav(ep->shoff);
ep->flags = swal(ep->flags);
ep->ehsize = swab(ep->ehsize);
ep->phentsize = swab(ep->phentsize);
ep->phnum = swab(ep->phnum);
ep->shentsize = swab(ep->shentsize);
ep->shnum = swab(ep->shnum);
ep->shstrndx = swab(ep->shstrndx);
fp->magic = ELF_MAG;
fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
switch(ep->machine) {
default:
return 0;
case AMD64:
mach = &mamd64;
fp->type = FAMD64;
fp->name = "amd64 ELF64 executable";
break;
case POWER64:
mach = &mpower64;
fp->type = FPOWER64;
fp->name = "power64 ELF64 executable";
break;
}
if(ep->phentsize != sizeof(P64hdr)) {
werrstr("bad ELF64 header size");
return 0;
}
phsz = sizeof(P64hdr)*ep->phnum;
ph = malloc(phsz);
if(!ph)
return 0;
seek(fd, ep->phoff, 0);
if(read(fd, ph, phsz) < 0) {
free(ph);
return 0;
}
for(i = 0; i < ep->phnum; i++) {
ph[i].type = swal(ph[i].type);
ph[i].flags = swal(ph[i].flags);
ph[i].offset = swav(ph[i].offset);
ph[i].vaddr = swav(ph[i].vaddr);
ph[i].paddr = swav(ph[i].paddr);
ph[i].filesz = swav(ph[i].filesz);
ph[i].memsz = swav(ph[i].memsz);
ph[i].align = swav(ph[i].align);
}
/* find text, data and symbols and install them */
it = id = is = -1;
for(i = 0; i < ep->phnum; i++) {
if(ph[i].type == LOAD
&& (ph[i].flags & (R|X)) == (R|X) && it == -1)
it = i;
else if(ph[i].type == LOAD
&& (ph[i].flags & (R|W)) == (R|W) && id == -1)
id = i;
else if(ph[i].type == NOPTYPE && is == -1)
is = i;
}
if(it == -1 || id == -1) {
werrstr("No ELF64 TEXT or DATA sections");
free(ph);
return 0;
}
settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
/* 8c: out of fixed registers */
uvl = ph[id].memsz - ph[id].filesz;
setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, uvl);
if(is != -1)
setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
free(ph);
return 1;
}
int main( int argc, char *argv[] ) {
/* (x,y) position of edit window. x column, y line -> (0,0) at upper left on screen */
unsigned int xCursorPos = 0;
unsigned int yCursorPos = 0;
unsigned int curmenu = 0x1100;
int i;
cwsetup( argc, argv );
writestatus( 0 );
writetab( );
splashscreen( );
/* Main program loop */
do {
dispstrhgc( " ", wind.col, 2, NORMALATTR );
i = pulled_down_menu( &curmenu, &xCursorPos, &yCursorPos );
if ( filename[0] != '\0' ) {
switch ( i ) {
case RETKEY:
keymain = menu_to_key( curmenu );
break;
case ESCKEY:
waitkbd( wind.col + xCursorPos, wind.row + yCursorPos ); /* Show blinking cursor */
keymain = readkbd( ); /* If keypressed Get it */
break;
default:
keymain = i;
break;
}
while ( keymain != ESCKEY ) {
if ( ( keymain & 0xff ) >= 32 ) {
keymain = changekey( keymain );
if ( insertmode ) {
if ( !insert_char( keymain, &xCursorPos, &yCursorPos ) ) {
linetoolong( );
}
} else {
if ( !ovrwrite_char( keymain, &xCursorPos, &yCursorPos ) ) {
linetoolong( );
}
}
refreshline( xCursorPos, yCursorPos );
} else { /* Function Key */
switch ( keymain ) {
case PGUPKEY:
case CNTRL_R:
page_up( );
break;
case PGDNKEY:
case CNTRL_C:
page_down( );
break;
case UPKEY:
case CNTRL_E:
cursor_up( );
break;
case DNKEY:
case CNTRL_X:
cursor_down( yCursorPos );
break;
case LEKEY:
case CNTRL_S:
cursor_left( &xCursorPos );
break;
case 0x2301:
gobeginblk( &xCursorPos );
break;
case 0x2401:
goendblk( &xCursorPos );
break;
case RIKEY:
case CNTRL_D:
cursor_right( &xCursorPos, yCursorPos );
break;
case CNTRL_W:
scroll_up( );
break;
case CNTRL_Z:
scroll_down( );
break;
case CHOMEKEY:
top_of_page( );
break;
case CPGUPKEY:
topfile( &xCursorPos );
break;
case CENDKEY:
bottom_of_page( );
break;
case CPGDNKEY:
endfile( &xCursorPos );
break;
case DELKEY:
case CNTRL_G:
delete_char( xCursorPos );
refreshline( xCursorPos, yCursorPos );
changeflag = YES;
break;
case CNTRL_T:
delete_word( xCursorPos );
refreshline( xCursorPos, yCursorPos );
changeflag = YES;
break;
case CNTRL_Y:
delete_line( );
changeflag = YES;
break;
case CNTRL_M:
case RETKEY:
if ( insertmode == NO ) {
returnkey( &xCursorPos, yCursorPos );
} else {
ret_with_ins( &xCursorPos, yCursorPos );
changeflag = YES;
}
break;
case BSKEY:
case CNTRL_H:
backspace( &xCursorPos );
yCursorPos = findrow( );
refreshline( 0, yCursorPos );
changeflag = YES;
break;
case INSKEY:
case CNTRL_V:
insertmode = !insertmode;
writeinsmode( );
break;
case CNTRL_N:
insert_ret( &xCursorPos );
break;
case F10KEY:
thaimode = !thaimode;
writelanguage( );
break;
case F1KEY:
fontused = 0x00;
writeattr( );
break;
case F2KEY:
fontused = fontused | ITALICATTR;
writeattr( );
break;
case F3KEY:
fontused = fontused | ONELINEATTR;
fontused = fontused & 0x7f;
writeattr( );
break;
case F4KEY:
fontused = fontused | TWOLINEATTR;
fontused = fontused & 0xfe;
writeattr( );
break;
case F5KEY:
fontused = fontused | BOLDATTR;
writeattr( );
break;
case F6KEY:
fontused = fontused | ENLARGEATTR;
writeattr( );
break;
case F7KEY:
fontused = fontused | SUPERATTR;
if ( ( fontused & SUBATTR ) == SUBATTR ) {
fontused = fontused ^ SUBATTR;
}
writeattr( );
break;
case F8KEY:
fontused = fontused | SUBATTR;
if ( ( fontused & SUPERATTR ) == SUPERATTR ) {
fontused = fontused ^ SUPERATTR;
}
writeattr( );
break;
case F9KEY:
manualwrap( &xCursorPos, &yCursorPos );
break;
case ALTM:
editmacro( );
break;
case TABKEY:
case CNTRL_I:
movetotab( &xCursorPos, yCursorPos );
break;
case CNTRL_K:
blockcommand( &xCursorPos );
break;
case 0x1401:
blkcmd( 'p', &xCursorPos );
break;
case 0x6101:
blkcmd( 'b', &xCursorPos );
break;
case 0x6201:
blkcmd( 'k', &xCursorPos );
break;
case 0x6301:
blkcmd( 'c', &xCursorPos );
break;
case 0x6401:
blkcmd( 'y', &xCursorPos );
break;
case 0x6501:
blkcmd( 'v', &xCursorPos );
break;
case 0x6601:
blkcmd( 'r', &xCursorPos );
break;
case 0x6701:
blkcmd( 'w', &xCursorPos );
break;
case 0x6801:
blkcmd( 'h', &xCursorPos );
break;
case CNTRL_O:
onscreen( xCursorPos, yCursorPos );
break;
case 0x7101:
doonscrn( 'l', xCursorPos, yCursorPos );
break;
case 0x7201:
doonscrn( 'r', xCursorPos, yCursorPos );
break;
case 0x7301:
doonscrn( 'i', xCursorPos, yCursorPos );
break;
case 0x7401:
doonscrn( 'n', xCursorPos, yCursorPos );
break;
case 0x7501:
doonscrn( 'c', xCursorPos, yCursorPos );
break;
case 0x7601:
doonscrn( 'p', xCursorPos, yCursorPos );
break;
case 0x7701:
doonscrn( 'x', xCursorPos, yCursorPos );
break;
case CNTRL_Q:
quick( &xCursorPos, &yCursorPos );
break;
case 0x3501:
deltoendline( xCursorPos, yCursorPos );
break;
case 0x8111:
inscntrl( CNTRL_W, xCursorPos, yCursorPos );
break;
case 0x8211:
inscntrl( CNTRL_S, xCursorPos, yCursorPos );
break;
case 0x8311:
inscntrl( CNTRL_R, xCursorPos, yCursorPos );
break;
case 0x8411:
inscntrl( CNTRL_B, xCursorPos, yCursorPos );
break;
case 0x8511:
inscntrl( CNTRL_E, xCursorPos, yCursorPos );
break;
case 0x8611:
inscntrl( CNTRL_T, xCursorPos, yCursorPos );
break;
case 0x8711:
inscntrl( CNTRL_V, xCursorPos, yCursorPos );
break;
case CNTRL_P:
printcntrl( xCursorPos, yCursorPos );
break;
case HOMEKEY:
home( &xCursorPos );
break;
case ENDKEY:
endline( &xCursorPos );
break;
case CLEKEY:
case CNTRL_A:
backword( &xCursorPos );
break;
case CRIKEY:
case CNTRL_F:
nextword( &xCursorPos, yCursorPos );
break;
case CNTRL_L:
if ( source[0] != '\0' ) {
if ( replaceflag == NO ) {
if ( searchfwd( &xCursorPos, &yCursorPos ) == NO ) {
wordnotfound( );
}
} else {
if ( searchreplace( &xCursorPos, &yCursorPos ) == NO ) {
wordnotfound( );
}
}
}
break;
case CNTRL_B:
reform( );
break;
case ALTP:
gotopage( );
break;
case CNTRL_J:
case ALTL:
gotoline( );
break;
case 0x5101:
searching( &xCursorPos, &yCursorPos );
break;
case 0x5201:
replacing( &xCursorPos, &yCursorPos );
break;
case 0x8501:
loadtoline( curline->text );
refreshline( 0, yCursorPos );
break;
case CF1KEY:
insertmacro( ¯o[0][0], &xCursorPos, &yCursorPos );
break;
case CF2KEY:
insertmacro( ¯o[1][0], &xCursorPos, &yCursorPos );
break;
case CF3KEY:
insertmacro( ¯o[2][0], &xCursorPos, &yCursorPos );
break;
case CF4KEY:
insertmacro( ¯o[3][0], &xCursorPos, &yCursorPos );
break;
case CF5KEY:
insertmacro( ¯o[4][0], &xCursorPos, &yCursorPos );
break;
case CF6KEY:
insertmacro( ¯o[5][0], &xCursorPos, &yCursorPos );
break;
case CF7KEY:
insertmacro( ¯o[6][0], &xCursorPos, &yCursorPos );
break;
case CF8KEY:
insertmacro( ¯o[7][0], &xCursorPos, &yCursorPos );
break;
case CF9KEY:
insertmacro( ¯o[8][0], &xCursorPos, &yCursorPos );
break;
case CF10KEY:
insertmacro( ¯o[9][0], &xCursorPos, &yCursorPos );
break;
case AF2KEY:
inscntrl( ITALICCODE, xCursorPos, yCursorPos );
break;
case AF3KEY:
inscntrl( ONELINECODE, xCursorPos, yCursorPos );
break;
case AF4KEY:
inscntrl( TWOLINECODE, xCursorPos, yCursorPos );
break;
case AF5KEY:
inscntrl( BOLDCODE, xCursorPos, yCursorPos );
break;
case AF6KEY:
inscntrl( ENLARGECODE, xCursorPos, yCursorPos );
break;
case AF7KEY:
inscntrl( SUPERCODE, xCursorPos, yCursorPos );
break;
case AF8KEY:
inscntrl( SUBCODE, xCursorPos, yCursorPos );
break;
#ifdef WANT_TO_USE_GRAPH
case ALTG:
insertgraph( );
break;
case ALTD:
deletegraph( );
break;
#endif
case ALTX:
quitprog = YES;
keymain = ESCKEY;
break;
default:
if ( ( alt_char_map( keymain ) ) != -1 ) {
keymain = alt_char_map( keymain );
if ( insertmode ) {
if ( !insert_char( keymain, &xCursorPos, &yCursorPos ) ) {
linetoolong( );
}
} else {
if ( !ovrwrite_char( keymain, &xCursorPos, &yCursorPos ) ) {
linetoolong( );
}
}
refreshline( xCursorPos, yCursorPos );
}
break;
} /* switch ( keymain ) */
}
adjustcol( &xCursorPos );
while ( ( yCursorPos = findrow( ) ) > ( wind.width - 1 ) ) {
storeline( curline );
curline = curline->previous;
loadtoline( curline->text );
lineno--;
}
if ( !keypressed( ) ) {
if ( !pagecomplete ) {
showpage( );
}
if ( !keypressed( ) ) {
writecolno( firstcol + xCursorPos );
dispstrhgc( " ", wind.col, 2, NORMALATTR );
if ( !keypressed( ) ) {
writepageline( );
}
}
}
if ( quitprog != YES ) {
waitkbd( wind.col + xCursorPos, wind.row + yCursorPos );
keymain = readkbd( );
dispkey( keymain );
}
} /* while */
} else { /* if filename[0] != '\0' */
errorsound( );
}
} while ( !quitprog );
if ( changeflag ) {
blockmsg( 5 );
dispstrhgc( "ÂѧäÁèä´é¨Ñ´à¡çºá¿éÁ¢éÍÁÙÅ µéͧ¡ÒèѴà¡çºËÃ×ÍäÁè (Y/N)?", ( 16 + center_factor ) + 7, 5, REVERSEATTR );
keymain = 0;
while ( ( keymain != 'n' ) && ( keymain != 'N' )
&& ( keymain != 'y' ) && ( keymain != 'Y' ) ) {
keymain = ebioskey( 0 ) & 0xff;
if ( ( keymain == 'y' ) || ( keymain == 'Y' ) ) {
writeblk( filename, sentinel->next, 0, sentinel->previous, MAXCOL );
}
}
}
settext( );
return 0;
}
static int
machdotout(int fd, Fhdr *fp, ExecHdr *hp)
{
uvlong (*swav)(uvlong);
uint32 (*swal)(uint32);
Machhdr *mp;
MachCmd **cmd;
MachSymSeg *symtab;
MachSymSeg *pclntab;
MachSeg64 *seg;
MachSect64 *sect;
MachSeg32 *seg32;
MachSect32 *sect32;
uvlong textsize, datasize, bsssize;
uchar *cmdbuf;
uchar *cmdp;
int i, j, hdrsize;
uint32 textva, textoff, datava, dataoff, symoff, symsize, pclnoff, pclnsize;
mp = &hp->e.machhdr;
if (leswal(mp->filetype) != MACH_EXECUTABLE_TYPE) {
werrstr("bad MACH executable type %#ux", leswal(mp->filetype));
return 0;
}
swal = leswal;
swav = leswav;
mp->magic = swal(mp->magic);
mp->cputype = swal(mp->cputype);
mp->cpusubtype = swal(mp->cpusubtype);
mp->filetype = swal(mp->filetype);
mp->ncmds = swal(mp->ncmds);
mp->sizeofcmds = swal(mp->sizeofcmds);
mp->flags = swal(mp->flags);
mp->reserved = swal(mp->reserved);
switch(mp->magic) {
case 0xFEEDFACE: // 32-bit mach
if (mp->cputype != MACH_CPU_TYPE_X86) {
werrstr("bad MACH cpu type - not 386");
return 0;
}
if (mp->cpusubtype != MACH_CPU_SUBTYPE_X86) {
werrstr("bad MACH cpu subtype - not 386");
return 0;
}
if (mp->filetype != MACH_EXECUTABLE_TYPE) {
werrstr("bad MACH executable type");
return 0;
}
mach = &mi386;
fp->type = FI386;
hdrsize = 28;
break;
case 0xFEEDFACF: // 64-bit mach
werrstr("64 bit mach NOT SUPPORTED");
return 0;
//if (mp->cputype != MACH_CPU_TYPE_X86_64) {
// werrstr("bad MACH cpu type - not amd64");
// return 0;
//}
//
//if (mp->cpusubtype != MACH_CPU_SUBTYPE_X86 && mp->cpusubtype != MACH_CPU_SUBTYPE_X86_64) {
// werrstr("bad MACH cpu subtype - not amd64");
// return 0;
//}
//mach = &mamd64;
//fp->type = FAMD64;
//hdrsize = 32;
//break;
default:
werrstr("not mach %#ux", mp->magic);
return 0;
}
cmdbuf = malloc(mp->sizeofcmds);
if(!cmdbuf) {
werrstr("out of memory");
return 0;
}
seek(fd, hdrsize, 0);
if(read(fd, cmdbuf, mp->sizeofcmds) != mp->sizeofcmds) {
free(cmdbuf);
return 0;
}
cmd = malloc(mp->ncmds * sizeof(MachCmd*));
if(!cmd) {
free(cmdbuf);
werrstr("out of memory");
return 0;
}
cmdp = cmdbuf;
textva = 0;
textoff = 0;
dataoff = 0;
datava = 0;
symtab = 0;
pclntab = 0;
textsize = 0;
datasize = 0;
bsssize = 0;
symoff = 0;
symsize = 0;
pclnoff = 0;
pclnsize = 0;
for (i = 0; i < mp->ncmds; i++) {
MachCmd *c;
cmd[i] = (MachCmd*)cmdp;
c = cmd[i];
c->type = swal(c->type);
c->size = swal(c->size);
switch(c->type) {
case MACH_SEGMENT_32:
if(mp->magic != 0xFEEDFACE) {
werrstr("segment 32 in mach 64");
goto bad;
}
seg32 = (MachSeg32*)c;
seg32->vmaddr = swav(seg32->vmaddr);
seg32->vmsize = swav(seg32->vmsize);
seg32->fileoff = swav(seg32->fileoff);
seg32->filesize = swav(seg32->filesize);
seg32->maxprot = swal(seg32->maxprot);
seg32->initprot = swal(seg32->initprot);
seg32->nsects = swal(seg32->nsects);
seg32->flags = swal(seg32->flags);
if (strcmp(seg32->segname, "__TEXT") == 0) {
textva = seg32->vmaddr;
textoff = seg32->fileoff;
textsize = seg32->vmsize;
sect32 = (MachSect32*)(cmdp + sizeof(MachSeg32));
for(j = 0; j < seg32->nsects; j++, sect32++) {
if (strcmp(sect32->sectname, "__gosymtab") == 0) {
symoff = swal(sect32->offset);
symsize = swal(sect32->size);
}
if (strcmp(sect32->sectname, "__gopclntab") == 0) {
pclnoff = swal(sect32->offset);
pclnsize = swal(sect32->size);
}
}
}
if (strcmp(seg32->segname, "__DATA") == 0) {
datava = seg32->vmaddr;
dataoff = seg32->fileoff;
datasize = seg32->filesize;
bsssize = seg32->vmsize - seg32->filesize;
}
break;
case MACH_SEGMENT_64:
werrstr("MACH SEGMENT 64 NOT SUPPORTED");
goto bad;
//if(mp->magic != 0xFEEDFACF) {
// werrstr("segment 32 in mach 64");
// goto bad;
//}
//seg = (MachSeg64*)c;
//seg->vmaddr = swav(seg->vmaddr);
//seg->vmsize = swav(seg->vmsize);
//seg->fileoff = swav(seg->fileoff);
//seg->filesize = swav(seg->filesize);
//seg->maxprot = swal(seg->maxprot);
//seg->initprot = swal(seg->initprot);
//seg->nsects = swal(seg->nsects);
//seg->flags = swal(seg->flags);
//if (strcmp(seg->segname, "__TEXT") == 0) {
// textva = seg->vmaddr;
// textoff = seg->fileoff;
// textsize = seg->vmsize;
// sect = (MachSect64*)(cmdp + sizeof(MachSeg64));
// for(j = 0; j < seg->nsects; j++, sect++) {
// if (strcmp(sect->sectname, "__gosymtab") == 0) {
// symoff = swal(sect->offset);
// symsize = swal(sect->size);
// }
// if (strcmp(sect->sectname, "__gopclntab") == 0) {
// pclnoff = swal(sect->offset);
// pclnsize = swal(sect->size);
// }
// }
//}
//if (strcmp(seg->segname, "__DATA") == 0) {
// datava = seg->vmaddr;
// dataoff = seg->fileoff;
// datasize = seg->filesize;
// bsssize = seg->vmsize - seg->filesize;
//}
break;
case MACH_UNIXTHREAD:
break;
case MACH_SYMSEG:
if (symtab == 0) {
symtab = (MachSymSeg*)c;
symoff = swal(symtab->fileoff);
symsize = swal(symtab->filesize);
} else if (pclntab == 0) {
pclntab = (MachSymSeg*)c;
pclnoff = swal(pclntab->fileoff);
pclnsize = swal(pclntab->filesize);
}
break;
}
cmdp += c->size;
}
if (textva == 0 || datava == 0) {
free(cmd);
free(cmdbuf);
return 0;
}
/* compute entry by taking address after header - weird - BUG? */
settext(fp, textva+sizeof(Machhdr) + mp->sizeofcmds, textva, textsize, textoff);
setdata(fp, datava, datasize, dataoff, bsssize);
if(symoff > 0)
setsym(fp, symoff, symsize, 0, 0, pclnoff, pclnsize);
free(cmd);
free(cmdbuf);
return 1;
bad:
free(cmd);
free(cmdbuf);
return 0;
}
/*
* Decode an Irix 5.x ELF header
*/
static int
elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
{
Ehdr *ep;
Shdr *es, *txt, *init, *s;
long addr, size, offset, bsize;
ep = &hp->e.ehdr;
fp->magic = ELF_MAG;
fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
if(ep->shnum <= 0) {
werrstr("no ELF header sections");
return 0;
}
es = malloc(sizeof(Shdr)*ep->shnum);
if(es == 0)
return 0;
seek(fd, ep->shoff, 0);
if(read(fd, es, sizeof(Shdr)*ep->shnum) < 0){
free(es);
return 0;
}
txt = elfsectbyname(fd, ep, es, ".text");
init = elfsectbyname(fd, ep, es, ".init");
if(txt == 0 || init == 0 || init != txt+1)
goto bad;
if(txt->addr+txt->size != init->addr)
goto bad;
settext(fp, ep->elfentry, txt->addr, txt->size+init->size, txt->offset);
addr = 0;
offset = 0;
size = 0;
s = elfsectbyname(fd, ep, es, ".data");
if(s) {
addr = s->addr;
size = s->size;
offset = s->offset;
}
s = elfsectbyname(fd, ep, es, ".rodata");
if(s) {
if(addr){
if(addr+size != s->addr)
goto bad;
} else {
addr = s->addr;
offset = s->offset;
}
size += s->size;
}
s = elfsectbyname(fd, ep, es, ".got");
if(s) {
if(addr){
if(addr+size != s->addr)
goto bad;
} else {
addr = s->addr;
offset = s->offset;
}
size += s->size;
}
bsize = 0;
s = elfsectbyname(fd, ep, es, ".bss");
if(s) {
if(addr){
if(addr+size != s->addr)
goto bad;
} else {
addr = s->addr;
offset = s->offset;
}
bsize = s->size;
}
if(addr == 0)
goto bad;
setdata(fp, addr, size, offset, bsize);
fp->name = "IRIX Elf a.out executable";
free(es);
return 1;
bad:
free(es);
werrstr("ELF sections scrambled");
return 0;
}
static void showDialog(Gui gui)
{
char buf[100];
wconfig = newwindow(G_("Rgui Configuration Editor"), rect(0, 0, 550, 450),
Titlebar | Centered | Modal);
setbackground(wconfig, dialog_bg());
l_mdi = newlabel("Single or multiple windows",
rect(10, 10, 140, 20), AlignLeft);
rb_mdi = newradiobutton("MDI", rect(150, 10 , 70, 20), cMDI);
rb_sdi = newradiobutton("SDI", rect(220, 10 , 70, 20), cSDI);
toolbar = newcheckbox("MDI toolbar", rect(300, 10, 100, 20), NULL);
if(gui->toolbar) check(toolbar);
statusbar = newcheckbox("MDI statusbar", rect(420, 10, 130, 20), NULL);
if(gui->statusbar) check(statusbar);
if(gui->MDI) {
check(rb_mdi); cMDI(rb_mdi);
} else {
check(rb_sdi); cSDI(rb_sdi);
}
l_mwin = newlabel("Pager style", rect(10, 40, 90, 20), AlignLeft);
g_mwin = newradiogroup();
rb_mwin = newradiobutton("multiple windows", rect(150, 40, 150, 20), NULL);
rb_swin = newradiobutton("single window", rect(150, 60 , 150, 20), NULL);
if(gui->pagerMultiple) check(rb_mwin); else check(rb_swin);
l_lang = newlabel("Language for menus\nand messages",
rect(320, 40, 130, 40), AlignLeft);
f_lang = newfield(gui->language, rect(450, 45, 60, 20));
/* Font, pointsize, style */
l_font = newlabel("Font", rect(10, 100, 40, 20), AlignLeft);
f_font = newdropfield(FontsList, rect(50, 100, 120, 20), scrollFont);
tt_font = newcheckbox("TrueType only", rect(180, 100, 110, 20), changeFont);
if (gui->tt_font) check(tt_font);
settext(f_font, gui->font);
l_point = newlabel("size", rect(310, 100, 30, 20), AlignLeft);
d_point = newdropfield(PointsList, rect(345, 100, 50, 20), scrollPoints);
snprintf(buf, 100, "%d", gui->pointsize);
settext(d_point, buf);
l_style = newlabel("style", rect(410, 100, 40, 20), AlignLeft);
f_style = newdroplist(StyleList, rect(450, 100, 80, 20), scrollStyle);
setlistitem(f_style, cmatch(gui->style, StyleList));
/* Console size, set widthonresize */
l_crows = newlabel("Console rows", rect(10, 150, 100, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->crows);
f_crows = newfield(buf, rect(110, 150, 30, 20));
l_ccols = newlabel("columns", rect(150, 150, 60, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->ccols);
f_ccols = newfield(buf, rect(220, 150, 30, 20));
l_cx = newlabel("Initial left", rect(270, 150, 70, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->cx);
f_cx = newfield(buf, rect(350, 150, 40, 20));
l_cy = newlabel("top", rect(430, 150, 30, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->cy);
f_cy = newfield(buf, rect(480, 150, 40, 20));
c_resize = newcheckbox("set options(width) on resize?",
rect(20, 175, 200, 20), NULL);
if(gui->setWidthOnResize) check(c_resize);
l_cbb = newlabel("buffer chars", rect(270, 175, 70, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->cbb);
f_cbb = newfield(buf, rect(350, 175, 60, 20));
l_cbl = newlabel("lines", rect(430, 175, 50, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->cbl);
f_cbl = newfield(buf, rect(480, 175, 40, 20));
c_buff = newcheckbox("buffer console by default?",
rect(20, 190, 200, 20), NULL);
if(gui->buffered) check(c_buff);
/* Cursor blink */
l_blink = newlabel("Cursor blink", rect(270, 200,100, 30), AlignLeft);
f_blink = newdroplist(BlinkList, rect(350, 200, 80, 20), NULL);
setlistitem(f_blink, gui->cursor_blink);
/* Pager size */
l_prows = newlabel("Pager rows", rect(10, 230, 100, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->prows);
f_prows = newfield(buf, rect(110, 230, 30, 20));
l_pcols = newlabel("columns", rect(150, 230, 60, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->pcols);
f_pcols = newfield(buf, rect(220, 230, 30, 20));
/* Graphics window */
l_grx = newlabel("Graphics windows: initial left",
rect(10, 270, 190, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->grx);
f_grx = newfield(buf, rect(200, 270, 40, 20));
l_gry = newlabel("top", rect(270, 270, 30, 20), AlignLeft);
snprintf(buf, 100, "%d", gui->gry);
f_gry = newfield(buf, rect(300, 270, 40, 20));
/* Font colours */
l_cols = newlabel("Console and Pager Colours",
rect(10, 310, 520, 20), AlignCenter);
guielement = newlistbox(GuiElementNames, rect(50, 330, 100, 80), changeElement, NULL);
guicolor = newlistbox(ColorName, rect(205, 330, 100, 80), clickColor, NULL);
guisample = newrichtextarea("Sample text", rect(350, 330, 150, 55));
for (int i=0; i<numGuiColors; i++)
dialogColors[i] = gui->guiColors[i];
setlistitem(guielement, 0);
changeElement(guielement, 0);
sampleFontNum = cmatch(gettext(f_font), FontsList);
samplePointsize = atoi(gettext(d_point));
scrollStyle(f_style, 0); /* the 0 is ignored */
bApply = newbutton("Apply", rect(50, 410, 70, 25), apply);
bSave = newbutton("Save...", rect(130, 410, 70, 25), save);
bLoad = newbutton("Load...", rect(210, 410, 70, 25), load);
bOK = newbutton("OK", rect(350, 410, 70, 25), ok);
bCancel = newbutton("Cancel", rect(430, 410, 70, 25), cancel);
show(wconfig);
}
void applyGUI(Gui newGUI)
{
rect r = getrect(RConsole);
ConsoleData p = (ConsoleData) getdata(RConsole);
int havenewfont = 0;
struct structGUI curGUI;
getActive(&curGUI);
if(!has_changed(&curGUI, newGUI)) return;
if(newGUI->MDI != curGUI.MDI || newGUI->toolbar != curGUI.toolbar ||
newGUI->statusbar != curGUI.statusbar)
askok(G_("The overall console properties cannot be changed\non a running console.\n\nSave the preferences and restart Rgui to apply them.\n"));
if(strcmp(newGUI->language, curGUI.language)) {
char *buf = malloc(50);
askok(G_("The language for menus cannot be changed on a\n running console.\n\nSave the preferences and restart Rgui to apply to menus.\n"));
snprintf(buf, 50, "LANGUAGE=%s", newGUI->language);
putenv(buf);
}
/* Set a new font? */
if(strcmp(newGUI->font, curGUI.font) ||
newGUI->pointsize != curGUI.pointsize ||
strcmp(newGUI->style, curGUI.style))
{
char msg[LF_FACESIZE + 128];
int sty = Plain;
if(newGUI->tt_font) strcpy(fontname, "TT "); else strcpy(fontname, "");
strcat(fontname, newGUI->font);
if (!strcmp(newGUI->style, "bold")) sty = Bold;
if (!strcmp(newGUI->style, "italic")) sty = Italic;
pointsize = newGUI->pointsize;
fontsty = sty;
/* Don't delete font: open pagers may be using it */
if (strcmp(fontname, "FixedFont"))
consolefn = gnewfont(NULL, fontname, fontsty, pointsize, 0.0, 1);
else consolefn = FixedFont;
if (!consolefn) {
snprintf(msg, LF_FACESIZE + 128,
G_("Font %s-%d-%d not found.\nUsing system fixed font"),
fontname, fontsty | FixedWidth, pointsize);
R_ShowMessage(msg);
consolefn = FixedFont;
}
/* if (!ghasfixedwidth(consolefn)) {
sprintf(msg,
G_("Font %s-%d-%d has variable width.\nUsing system fixed font"),
fontname, fontsty, pointsize);
R_ShowMessage(msg);
consolefn = FixedFont;
} */
p->f = consolefn;
FH = fontheight(p->f);
FW = fontwidth(p->f);
havenewfont = 1;
}
/* resize console, possibly with new font */
if (consoler != newGUI->crows || consolec != newGUI->ccols || havenewfont) {
char buf[20];
consoler = newGUI->crows;
consolec = newGUI->ccols;
r.width = (consolec + 1) * FW;
r.height = (consoler + 1) * FH;
resize(RConsole, r);
snprintf(buf, 20, "%d", ROWS); settext(f_crows, buf);
snprintf(buf, 20, "%d", COLS); settext(f_ccols, buf);
}
if (p->lbuf->dim != newGUI->cbb || p->lbuf->ms != newGUI->cbl)
xbufgrow(p->lbuf, newGUI->cbb, newGUI->cbl);
/* Set colours and redraw */
for (int i=0; i<numGuiColors; i++)
p->guiColors[i] = guiColors[i] = newGUI->guiColors[i];
drawconsole(RConsole, r);
if(haveusedapager &&
(newGUI->prows != curGUI.prows || newGUI->pcols != curGUI.pcols))
askok(G_("Changes in pager size will not apply to any open pagers"));
pagerrow = newGUI->prows;
pagercol = newGUI->pcols;
if(newGUI->pagerMultiple != pagerMultiple) {
if(!haveusedapager ||
askokcancel(G_("Do not change pager type if any pager is open\nProceed?"))
== YES)
pagerMultiple = newGUI->pagerMultiple;
if(pagerMultiple) {
check(rb_mwin); uncheck(rb_swin);
} else {check(rb_swin); uncheck(rb_mwin);}
}
setWidthOnResize = newGUI->setWidthOnResize;
consolebuffered = newGUI->buffered;
Rwin_graphicsx = newGUI->grx;
Rwin_graphicsy = newGUI->gry;
p->cursor_blink = newGUI->cursor_blink;
}
static int
machdotout(int fd, Fhdr *fp, ExecHdr *hp)
{
uvlong (*swav)(uvlong);
uint32 (*swal)(uint32);
ushort (*swab)(ushort);
Machhdr *mp;
MachCmd **cmd;
MachSymSeg *symtab;
MachSymSeg *pclntab;
MachSeg64 *seg;
MachSect64 *sect;
MachSeg32 *seg32;
MachSect32 *sect32;
uvlong textsize, datasize, bsssize;
uchar *cmdbuf;
uchar *cmdp;
int i, hdrsize;
uint32 textva, textoff, datava, dataoff;
mp = &hp->e.machhdr;
if (leswal(mp->filetype) != MACH_EXECUTABLE_TYPE) {
werrstr("bad MACH executable type %#ux", leswal(mp->filetype));
return 0;
}
swab = leswab;
swal = leswal;
swav = leswav;
mp->magic = swal(mp->magic);
mp->cputype = swal(mp->cputype);
mp->cpusubtype = swal(mp->cpusubtype);
mp->filetype = swal(mp->filetype);
mp->ncmds = swal(mp->ncmds);
mp->sizeofcmds = swal(mp->sizeofcmds);
mp->flags = swal(mp->flags);
mp->reserved = swal(mp->reserved);
hdrsize = 0;
switch(mp->magic) {
case 0xFEEDFACE: // 32-bit mach
if (mp->cputype != MACH_CPU_TYPE_X86) {
werrstr("bad MACH cpu type - not 386");
return 0;
}
if (mp->cpusubtype != MACH_CPU_SUBTYPE_X86) {
werrstr("bad MACH cpu subtype - not 386");
return 0;
}
if (mp->filetype != MACH_EXECUTABLE_TYPE) {
werrstr("bad MACH executable type");
return 0;
}
mach = &mi386;
fp->type = FI386;
hdrsize = 28;
break;
case 0xFEEDFACF: // 64-bit mach
if (mp->cputype != MACH_CPU_TYPE_X86_64) {
werrstr("bad MACH cpu type - not amd64");
return 0;
}
if (mp->cpusubtype != MACH_CPU_SUBTYPE_X86) {
werrstr("bad MACH cpu subtype - not amd64");
return 0;
}
mach = &mamd64;
fp->type = FAMD64;
hdrsize = 32;
break;
default:
werrstr("not mach %#ux", mp->magic);
return 0;
}
cmdbuf = malloc(mp->sizeofcmds);
seek(fd, hdrsize, 0);
if(read(fd, cmdbuf, mp->sizeofcmds) != mp->sizeofcmds) {
free(cmdbuf);
return 0;
}
cmd = malloc(mp->ncmds * sizeof(MachCmd*));
cmdp = cmdbuf;
textva = 0;
textoff = 0;
dataoff = 0;
datava = 0;
symtab = 0;
pclntab = 0;
textsize = datasize = bsssize = 0;
for (i = 0; i < mp->ncmds; i++) {
MachCmd *c;
cmd[i] = (MachCmd*)cmdp;
c = cmd[i];
c->type = swal(c->type);
c->size = swal(c->size);
switch(c->type) {
case MACH_SEGMENT_32:
if(mp->magic != 0xFEEDFACE) {
werrstr("segment 32 in mach 64");
goto bad;
}
seg32 = (MachSeg32*)c;
seg32->vmaddr = swav(seg32->vmaddr);
seg32->vmsize = swav(seg32->vmsize);
seg32->fileoff = swav(seg32->fileoff);
seg32->filesize = swav(seg32->filesize);
seg32->maxprot = swal(seg32->maxprot);
seg32->initprot = swal(seg32->initprot);
seg32->nsects = swal(seg32->nsects);
seg32->flags = swal(seg32->flags);
if (strcmp(seg32->segname, "__TEXT") == 0) {
textva = seg32->vmaddr;
textoff = seg32->fileoff;
sect32 = (MachSect32*)(cmdp + sizeof(MachSeg32));
if (strcmp(sect32->sectname, "__text") == 0) {
textsize = swal(sect32->size);
} else {
werrstr("no text section");
goto bad;
}
}
if (strcmp(seg32->segname, "__DATA") == 0) {
datava = seg32->vmaddr;
dataoff = seg32->fileoff;
sect32 = (MachSect32*)(cmdp + sizeof(MachSeg32));
if (strcmp(sect32->sectname, "__data") == 0) {
datasize = swal(sect32->size);
} else {
werrstr("no data section");
goto bad;
}
sect32++;
if (strcmp(sect32->sectname, "__nl_symbol_ptr") == 0)
sect32++;
if (strcmp(sect32->sectname, "__bss") == 0) {
bsssize = swal(sect32->size);
} else {
werrstr("no bss section");
goto bad;
}
}
break;
case MACH_SEGMENT_64:
if(mp->magic != 0xFEEDFACF) {
werrstr("segment 32 in mach 64");
goto bad;
}
seg = (MachSeg64*)c;
seg->vmaddr = swav(seg->vmaddr);
seg->vmsize = swav(seg->vmsize);
seg->fileoff = swav(seg->fileoff);
seg->filesize = swav(seg->filesize);
seg->maxprot = swal(seg->maxprot);
seg->initprot = swal(seg->initprot);
seg->nsects = swal(seg->nsects);
seg->flags = swal(seg->flags);
if (strcmp(seg->segname, "__TEXT") == 0) {
textva = seg->vmaddr;
textoff = seg->fileoff;
sect = (MachSect64*)(cmdp + sizeof(MachSeg64));
if (strcmp(sect->sectname, "__text") == 0) {
textsize = swav(sect->size);
} else {
werrstr("no text section");
goto bad;
}
}
if (strcmp(seg->segname, "__DATA") == 0) {
datava = seg->vmaddr;
dataoff = seg->fileoff;
sect = (MachSect64*)(cmdp + sizeof(MachSeg64));
if (strcmp(sect->sectname, "__data") == 0) {
datasize = swav(sect->size);
} else {
werrstr("no data section");
goto bad;
}
sect++;
if (strcmp(sect->sectname, "__bss") == 0) {
bsssize = swav(sect->size);
} else {
werrstr("no bss section");
goto bad;
}
}
break;
case MACH_UNIXTHREAD:
break;
case MACH_SYMSEG:
if (symtab == 0)
symtab = (MachSymSeg*)c;
else if (pclntab == 0)
pclntab = (MachSymSeg*)c;
break;
}
cmdp += c->size;
}
if (textva == 0 || datava == 0) {
free(cmd);
free(cmdbuf);
return 0;
}
/* compute entry by taking address after header - weird - BUG? */
settext(fp, textva+sizeof(Machhdr) + mp->sizeofcmds, textva, textsize, textoff);
setdata(fp, datava, datasize, dataoff, bsssize);
if(symtab != 0)
setsym(fp, symtab->filesize, 0, pclntab? pclntab->filesize : 0, symtab->fileoff);
free(cmd);
free(cmdbuf);
return 1;
bad:
free(cmd);
free(cmdbuf);
return 0;
}
static int
elfdotout(int fd, Fhdr *fp, ExecHdr *hp)
{
uint32 (*swal)(uint32);
ushort (*swab)(ushort);
Ehdr32 *ep;
Phdr32 *ph;
int i, it, id, is, phsz, shsz;
Shdr32 *sh;
/* bitswap the header according to the DATA format */
ep = &hp->e.elfhdr32;
if(ep->ident[CLASS] != ELFCLASS32) {
return elf64dotout(fd, fp, hp);
}
if(ep->ident[DATA] == ELFDATA2LSB) {
swab = leswab;
swal = leswal;
} else if(ep->ident[DATA] == ELFDATA2MSB) {
swab = beswab;
swal = beswal;
} else {
werrstr("bad ELF encoding - not big or little endian");
return 0;
}
ep->type = swab(ep->type);
ep->machine = swab(ep->machine);
ep->version = swal(ep->version);
ep->elfentry = swal(ep->elfentry);
ep->phoff = swal(ep->phoff);
ep->shoff = swal(ep->shoff);
ep->flags = swal(ep->flags);
ep->ehsize = swab(ep->ehsize);
ep->phentsize = swab(ep->phentsize);
ep->phnum = swab(ep->phnum);
ep->shentsize = swab(ep->shentsize);
ep->shnum = swab(ep->shnum);
ep->shstrndx = swab(ep->shstrndx);
if(ep->type != EXEC || ep->version != CURRENT)
return 0;
/* we could definitely support a lot more machines here */
fp->magic = ELF_MAG;
fp->hdrsz = (ep->ehsize+ep->phnum*ep->phentsize+16)&~15;
switch(ep->machine) {
case I386:
mach = &mi386;
fp->type = FI386;
break;
case MIPS:
mach = &mmips;
fp->type = FMIPS;
break;
case SPARC64:
mach = &msparc64;
fp->type = FSPARC64;
break;
case POWER:
mach = &mpower;
fp->type = FPOWER;
break;
case ARM:
mach = &marm;
fp->type = FARM;
break;
default:
return 0;
}
if(ep->phentsize != sizeof(Phdr32)) {
werrstr("bad ELF header size");
return 0;
}
phsz = sizeof(Phdr32)*ep->phnum;
ph = malloc(phsz);
if(!ph)
return 0;
seek(fd, ep->phoff, 0);
if(read(fd, ph, phsz) < 0) {
free(ph);
return 0;
}
hswal(ph, phsz/sizeof(uint32), swal);
shsz = sizeof(Shdr32)*ep->shnum;
sh = malloc(shsz);
if(sh) {
seek(fd, ep->shoff, 0);
if(read(fd, sh, shsz) < 0) {
free(sh);
sh = 0;
} else
hswal(sh, shsz/sizeof(uint32), swal);
}
/* find text, data and symbols and install them */
it = id = is = -1;
for(i = 0; i < ep->phnum; i++) {
if(ph[i].type == LOAD
&& (ph[i].flags & (R|X)) == (R|X) && it == -1)
it = i;
else if(ph[i].type == LOAD
&& (ph[i].flags & (R|W)) == (R|W) && id == -1)
id = i;
else if(ph[i].type == NOPTYPE && is == -1)
is = i;
}
if(it == -1 || id == -1) {
/*
* The SPARC64 boot image is something of an ELF hack.
* Text+Data+BSS are represented by ph[0]. Symbols
* are represented by ph[1]:
*
* filesz, memsz, vaddr, paddr, off
* ph[0] : txtsz+datsz, txtsz+datsz+bsssz, txtaddr-KZERO, datasize, txtoff
* ph[1] : symsz, lcsz, 0, 0, symoff
*/
if(ep->machine == SPARC64 && ep->phnum == 2) {
uint32 txtaddr, txtsz, dataddr, bsssz;
txtaddr = ph[0].vaddr | 0x80000000;
txtsz = ph[0].filesz - ph[0].paddr;
dataddr = txtaddr + txtsz;
bsssz = ph[0].memsz - ph[0].filesz;
settext(fp, ep->elfentry | 0x80000000, txtaddr, txtsz, ph[0].offset);
setdata(fp, dataddr, ph[0].paddr, ph[0].offset + txtsz, bsssz);
setsym(fp, ph[1].filesz, 0, ph[1].memsz, ph[1].offset);
free(ph);
return 1;
}
werrstr("No TEXT or DATA sections");
error:
free(sh);
free(ph);
return 0;
}
settext(fp, ep->elfentry, ph[it].vaddr, ph[it].memsz, ph[it].offset);
setdata(fp, ph[id].vaddr, ph[id].filesz, ph[id].offset, ph[id].memsz - ph[id].filesz);
if(is != -1)
setsym(fp, ph[is].filesz, 0, ph[is].memsz, ph[is].offset);
else if(sh != 0){
char *buf;
uvlong symsize = 0;
uvlong symoff = 0;
uvlong pclnsz = 0;
/* load shstrtab names */
buf = malloc(sh[ep->shstrndx].size);
if (buf == 0)
goto done;
memset(buf, 0, sizeof buf);
seek(fd, sh[ep->shstrndx].offset, 0);
read(fd, buf, sh[ep->shstrndx].size);
for(i = 0; i < ep->shnum; i++) {
if (strcmp(&buf[sh[i].name], ".gosymtab") == 0) {
symsize = sh[i].size;
symoff = sh[i].offset;
}
if (strcmp(&buf[sh[i].name], ".gopclntab") == 0) {
if (sh[i].offset != symoff+symsize) {
werrstr("pc line table not contiguous with symbol table");
free(buf);
goto error;
}
pclnsz = sh[i].size;
}
}
setsym(fp, symsize, 0, pclnsz, symoff);
free(buf);
}
done:
free(sh);
free(ph);
return 1;
}
/*
* Read from Windows PE/COFF .exe file image.
*/
static int
pedotout(int fd, Fhdr *fp, ExecHdr *hp)
{
uint32 start, magic;
uint32 symtab, esymtab, pclntab, epclntab;
IMAGE_FILE_HEADER fh;
IMAGE_SECTION_HEADER sh;
IMAGE_OPTIONAL_HEADER oh;
PE64_IMAGE_OPTIONAL_HEADER oh64;
uint8 sym[18];
uint32 *valp, ib, entry;
int i, ohoffset;
USED(hp);
seek(fd, 0x3c, 0);
if (readn(fd, &start, sizeof(start)) != sizeof(start)) {
werrstr("crippled PE MSDOS header");
return 0;
}
start = leswal(start);
seek(fd, start, 0);
if (readn(fd, &magic, sizeof(magic)) != sizeof(magic)) {
werrstr("no PE magic number found");
return 0;
}
if (beswal(magic) != 0x50450000) { /* "PE\0\0" */
werrstr("incorrect PE magic number");
return 0;
}
if (readn(fd, &fh, sizeof(fh)) != sizeof(fh)) {
werrstr("crippled PE File Header");
return 0;
}
if (fh.PointerToSymbolTable == 0) {
werrstr("zero pointer to COFF symbol table");
return 0;
}
ohoffset = seek(fd, 0, 1);
if (readn(fd, &oh, sizeof(oh)) != sizeof(oh)) {
werrstr("crippled PE Optional Header");
return 0;
}
switch(oh.Magic) {
case 0x10b: // PE32
fp->type = FI386;
ib = leswal(oh.ImageBase);
entry = leswal(oh.AddressOfEntryPoint);
break;
case 0x20b: // PE32+
fp->type = FAMD64;
seek(fd, ohoffset, 0);
if (readn(fd, &oh64, sizeof(oh64)) != sizeof(oh64)) {
werrstr("crippled PE32+ Optional Header");
return 0;
}
ib = leswal(oh64.ImageBase);
entry = leswal(oh64.AddressOfEntryPoint);
break;
default:
werrstr("invalid PE Optional Header magic number");
return 0;
}
fp->txtaddr = 0;
fp->dataddr = 0;
for (i=0; i<leswab(fh.NumberOfSections); i++) {
if (readn(fd, &sh, sizeof(sh)) != sizeof(sh)) {
werrstr("could not read Section Header %d", i+1);
return 0;
}
if (match8(sh.Name, ".text"))
settext(fp, ib+entry, ib+leswal(sh.VirtualAddress), leswal(sh.VirtualSize), leswal(sh.PointerToRawData));
if (match8(sh.Name, ".data"))
setdata(fp, ib+leswal(sh.VirtualAddress), leswal(sh.SizeOfRawData), leswal(sh.PointerToRawData), leswal(sh.VirtualSize)-leswal(sh.SizeOfRawData));
}
if (fp->txtaddr==0 || fp->dataddr==0) {
werrstr("no .text or .data");
return 0;
}
seek(fd, leswal(fh.PointerToSymbolTable), 0);
symtab = esymtab = pclntab = epclntab = 0;
for (i=0; i<leswal(fh.NumberOfSymbols); i++) {
if (readn(fd, sym, sizeof(sym)) != sizeof(sym)) {
werrstr("crippled COFF symbol %d", i);
return 0;
}
valp = (uint32 *)&sym[8];
if (match8(sym, "symtab"))
symtab = leswal(*valp);
if (match8(sym, "esymtab"))
esymtab = leswal(*valp);
if (match8(sym, "pclntab"))
pclntab = leswal(*valp);
if (match8(sym, "epclntab"))
epclntab = leswal(*valp);
}
if (symtab==0 || esymtab==0 || pclntab==0 || epclntab==0) {
werrstr("no symtab or esymtab or pclntab or epclntab in COFF symbol table");
return 0;
}
setsym(fp, symtab, esymtab-symtab, 0, 0, pclntab, epclntab-pclntab);
return 1;
}
