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; }