void eread_ewrite_test () {
FILE *fp;
char program[] = "eread_ewrite_test", filespc[] = "/data/petsun23/testx";
int i, n = N;
float *x, *y;
printf ("CPU_is_bigendian=%d\n", CPU_is_bigendian ());
if (!(x = (float *) malloc (n * sizeof (float)))) errm (program);
if (!(y = (float *) malloc (n * sizeof (float)))) errm (program);
for (i = 0; i < n; i++) {
x[i] = -1. + 2.0*rand ()/(float) RAND_MAX;
if (i < 20) printf ("%10d%10.4f\n", i, x[i]);
}
printf ("Writing: %s\n", filespc); fflush (stdout);
if (!(fp = fopen (filespc, "wb"))) errw (program, filespc);
if (ewrite (x, n, 'b', fp) || fclose (fp)) errw (program, filespc);
printf ("Reading: %s\n", filespc); fflush (stdout);
if (!(fp = fopen (filespc, "rb"))) errr (program, filespc);
if (eread (y, n, 1, fp) || fclose (fp)) errr (program, filespc);
for (i = 0; i < n; i++) assert (y[i] == x[i]);
printf ("Writing: %s\n", filespc); fflush (stdout);
if (!(fp = fopen (filespc, "wb"))) errw (program, filespc);
if (ewrite (x, n, 'l', fp) || fclose (fp)) errw (program, filespc);
printf ("Reading: %s\n", filespc); fflush (stdout);
if (!(fp = fopen (filespc, "rb"))) errr (program, filespc);
if (eread (y, n, 0, fp) || fclose (fp)) errr (program, filespc);
for (i = 0; i < n; i++) assert (y[i] == x[i]);
printf ("Done\n"); fflush (stdout);
free (x); free (y);
}
void *operator new(size_t size)
{
// Avoid relying on the behaviour of malloc(0).
if (size == 0)
size++;
#ifdef COOKIE_BUG
char *p = (char *)malloc(unsigned(size + 8));
#else /* not COOKIE_BUG */
char *p = (char *)malloc(unsigned(size));
#endif /* not COOKIE_BUG */
if (p == 0) {
if (program_name) {
ewrite(program_name);
ewrite(": ");
}
ewrite("out of memory\n");
_exit(-1);
}
#ifdef COOKIE_BUG
((unsigned *)p)[1] = 0;
return p + 8;
#else /* not COOKIE_BUG */
return p;
#endif /* not COOKIE_BUG */
}
int main()
{
uint8_t buf[BUFSIZE];
ssize_t size;
fd_set fds;
struct timeval tv;
struct framebuffer fb;
struct terminal term;
/* init */
setlocale(LC_ALL, "");
if (atexit(tty_die) != 0)
fatal("atexit failed");
tty_init();
fb_init(&fb, term.color_palette);
check_env(&fb);
term_init(&term, fb.res, fb.rotate);
/* fork and exec shell */
eforkpty(&term.fd, term.lines, term.cols);
/* main loop */
while (tty.loop_flag) {
if (tty.redraw_flag) {
redraw(&term);
refresh(&fb, &term);
tty.redraw_flag = false;
}
check_fds(&fds, &tv, STDIN_FILENO, term.fd);
if (FD_ISSET(STDIN_FILENO, &fds)) {
size = read(STDIN_FILENO, buf, BUFSIZE);
if (size > 0)
ewrite(term.fd, buf, size);
}
if (FD_ISSET(term.fd, &fds)) {
size = read(term.fd, buf, BUFSIZE);
if (size > 0) {
if (DEBUG)
ewrite(STDOUT_FILENO, buf, size);
parse(&term, buf, size);
if (tty.lazy_draw && size == BUFSIZE)
continue;
refresh(&fb, &term);
}
}
}
/* die */
term_die(&term);
fb_die(&fb);
return EXIT_SUCCESS;
}
void upP0Back(int arr[], int size){
erase(arr,128,256,size,"P0 Backup"); //erase block 0
printf("XXENV_2 Updating\n");
ewrite(arr,160,176,"XXENV",size); //write new XXENV
printf("XOS3_2 Updating\n");
ewrite(arr,176,224,"XOS3",size); //write new XOS3
printf("Stage0_2 Updating\n"); //write new Stage0
ewrite(arr,128,160,"Stage0",size);
}
void upP0Main(int arr[], int size){
erase(arr,0,128,size,"P0"); //erase block 0
printf("XXENV Updating\n");
ewrite(arr,32,48,"XXENV",size); //write new XXENV
printf("XOS3 Updating\n");
ewrite(arr,48,96,"XOS3",size); //write new XOS3
printf("Stage0 Updating\n"); //write new Stage0
ewrite(arr,0,32,"Stage0",size);
}
void xkeypress(struct framebuffer *xw, struct terminal *term, XEvent *ev)
{
int size;
char buf[BUFSIZE], *customkey;
XKeyEvent *e = &ev->xkey;;
KeySym keysym;
size = XLookupString(e, buf, BUFSIZE, &keysym, NULL);
if ((customkey = keymap(keysym, e->state)))
ewrite(term->fd, customkey, strlen(customkey));
else
ewrite(term->fd, buf, size);
}
static int
write_object_section_header(int fd, long length, os_vm_address_t addr)
{
extern Elf_Shdr sh;
Elf_Word flags = SHF_ALLOC | SHF_EXECINSTR | SHF_WRITE;
sh.sh_name = strlen(string_table_name) + 2;
sh.sh_type = SHT_PROGBITS;
sh.sh_flags = flags;
sh.sh_addr = (Elf_Addr)addr;
/* The object section offset is figured out as follows: elf-header +
three section headers + string table. The string table is the
initial null byte followed by the name strings for the string
table section and the object section. */
sh.sh_offset = sizeof(Elf_Ehdr) + 3 * sizeof(Elf_Shdr) + 1 +
(strlen(string_table_name) + 1) + (strlen(object_name) + 1);
sh.sh_size = length;
sh.sh_link = SHN_UNDEF;
sh.sh_info = 0;
sh.sh_addralign = os_vm_page_size; /* Must be page aligned. */
sh.sh_entsize = 0;
return ewrite(fd, &sh, eh.e_shentsize, __func__);
}
void
addpersrc(void)
{
IMAGE_SECTION_HEADER *h;
uchar *p;
uint32 val;
Reloc *r;
if(rsrcsym == nil)
return;
h = addpesection(".rsrc", rsrcsym->size, rsrcsym->size, 0);
h->Characteristics = IMAGE_SCN_MEM_READ|
IMAGE_SCN_MEM_WRITE | IMAGE_SCN_CNT_INITIALIZED_DATA;
// relocation
for(r=rsrcsym->r; r<rsrcsym->r+rsrcsym->nr; r++) {
p = rsrcsym->p + r->off;
val = h->VirtualAddress + r->add;
// 32-bit little-endian
p[0] = val;
p[1] = val>>8;
p[2] = val>>16;
p[3] = val>>24;
}
ewrite(cout, rsrcsym->p, rsrcsym->size);
strnput("", h->SizeOfRawData - rsrcsym->size);
cflush();
// update data directory
dd[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = h->VirtualAddress;
dd[IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = h->VirtualSize;
}
void tty_init()
{
extern struct tty_state tty; /* global var */
struct sigaction sigact;
struct vt_mode vtm;
char *env;
memset(&sigact, 0, sizeof(struct sigaction));
sigact.sa_handler = handler;
sigact.sa_flags = SA_RESTART;
esigaction(SIGCHLD, &sigact, NULL);
esigaction(SIGUSR1, &sigact, NULL);
vtm.mode = VT_PROCESS;
vtm.waitv = 0;
vtm.relsig = vtm.acqsig = vtm.frsig = SIGUSR1;
if (ioctl(STDIN_FILENO, VT_SETMODE, &vtm))
fatal("ioctl: VT_SETMODE failed (maybe here is not console)");
if (ioctl(STDIN_FILENO, KDSETMODE, KD_GRAPHICS) < 0)
fatal("ioctl: KDSETMODE failed (maybe here is not console)");
tty.save_tm = (struct termios *) emalloc(sizeof(struct termios));
set_rawmode(STDIN_FILENO, tty.save_tm);
ewrite(STDIN_FILENO, "\033[?25l", 6); /* make cusor invisible */
if ((env = getenv("YAFT")) != NULL) {
if (strstr(env, "background") != NULL)
tty.background_draw = true;
if (strstr(env, "lazy") != NULL)
tty.lazy_draw = true;
}
}
/* copy from archive to file system (or nowhere for table-of-contents) */
static void
copyfromar(int ar, int fd, char *fname, uint32_t blksleft, Off bytes)
{
int wrbytes;
uint32_t blksread;
Hdr *hbp;
if (blksleft == 0 || bytes < 0)
bytes = 0;
for (; blksleft > 0; blksleft -= blksread) {
hbp = getblkrd(ar, (fd >= 0? Alldata: Justnxthdr));
if (hbp == nil)
sysfatal("unexpected EOF on archive extracting %s from %s",
fname, arname);
blksread = gothowmany(blksleft);
if (blksread <= 0) {
fprint(2, "%s: got %ld blocks reading %s!\n",
argv0, blksread, fname);
blksread = 0;
}
wrbytes = Tblock*blksread;
assert(bytes >= 0);
if(wrbytes > bytes)
wrbytes = bytes;
assert(wrbytes >= 0);
if (fd >= 0)
ewrite(fname, fd, hbp->data, wrbytes);
putreadblks(ar, blksread);
bytes -= wrbytes;
assert(bytes >= 0);
}
if (bytes > 0)
fprint(2, "%s: %lld bytes uncopied at EOF on archive %s; "
"%s not fully extracted\n", argv0, bytes, arname, fname);
}
static int
write_string_section(int fd)
{
char *buffer = malloc(1 + strlen(string_table_name) + 1 +
strlen(object_name) + 1);
int ret;
if(buffer == NULL) {
perror("Out of memory in write_string_section()");
ret = -1;
} else {
*buffer = '\0';
memcpy(buffer + 1, string_table_name, strlen(string_table_name) + 1);
memcpy(buffer + 1 + strlen(string_table_name) + 1,
object_name,
strlen(object_name) + 1);
ret = ewrite(fd, buffer,
1 + strlen(string_table_name) + 1 + strlen(object_name) + 1,
__func__);
free(buffer);
}
return ret;
}
static void write_fdatasync(void)
{
int fd = ecreat(Option.file);
set_data();
ewrite(fd, Data, sizeof(Data));
efdatasync(fd);
crash();
}
static void
pewrite(void)
{
seek(cout, 0, 0);
ewrite(cout, dosstub, sizeof dosstub);
strnput("PE", 4);
cflush();
// TODO: This code should not assume that the
// memory representation is little-endian or
// that the structs are packed identically to
// their file representation.
ewrite(cout, &fh, sizeof fh);
if(pe64)
ewrite(cout, &oh64, sizeof oh64);
else
ewrite(cout, &oh, sizeof oh);
ewrite(cout, &sh, nsect * sizeof sh[0]);
}
int main(int argc, char *argv[]) {
char buf[10];
int fd = ecreat("zerofile");
ftruncate(fd, 497);
lseek(fd, 5046, 0);
ewrite(fd, buf, 0);
eclose(fd);
return 0;
}
/*
* indicate that one is done with the last block obtained from getblke
* and it is now available to be written into the archive.
*/
static void
putlastblk(int ar)
{
unsigned bytes = Tblock * nblock;
/* if writing end-of-archive, aid compression (good hygiene too) */
if (curblk < endblk)
memset(curblk, 0, (char *)endblk - (char *)curblk);
ewrite(arname, ar, tpblk, bytes);
}
void xkeypress(xwindow *xw, terminal *term, XEvent *ev)
{
int size;
char buf[BUFSIZE];
XKeyEvent *e = &ev->xkey;
KeySym keysym;
size = XLookupString(e, buf, BUFSIZE, &keysym, NULL);
ewrite(term->fd, (u8 *) buf, size);
}
void
cflush(void)
{
int n;
n = sizeof(buf.cbuf) - cbc;
if(n)
ewrite(cout, buf.cbuf, n);
cbp = buf.cbuf;
cbc = sizeof(buf.cbuf);
}
int main()
{
int size;
fd_set fds;
struct timeval tv;
u8 buf[BUFSIZE];
XEvent ev;
xwindow xw;
terminal term;
/* init */
x_init(&xw);
term_init(&term, xw.res);
load_ctrl_func(ctrl_func, CTRL_CHARS);
load_esc_func(esc_func, ESC_CHARS);
load_csi_func(csi_func, ESC_CHARS);
/* fork */
eforkpty(&term.fd, term.lines, term.cols);
signal(SIGCHLD, sigchld);
setvbuf(stdout, NULL, _IONBF, 0);
/* main loop */
while (loop_flag) {
check_fds(&fds, &tv, term.fd);
while(XPending(xw.dsp)) {
XNextEvent(xw.dsp, &ev);
if(XFilterEvent(&ev, xw.win))
continue;
if (event_func[ev.type])
event_func[ev.type](&xw, &term, &ev);
}
if (FD_ISSET(term.fd, &fds)) {
size = read(term.fd, buf, BUFSIZE);
if (size > 0) {
if (DEBUG)
ewrite(STDOUT_FILENO, buf, size);
parse(&term, buf, size);
if (size == BUFSIZE)
continue;
refresh(&xw, &term);
}
}
}
term_die(&term);
x_die(&xw);
return 0;
}
static int
write_elf_header(int fd)
{
extern Elf_Ehdr eh;
/* Ident array. */
eh.e_ident[EI_MAG0] = ELFMAG0;
eh.e_ident[EI_MAG1] = ELFMAG1;
eh.e_ident[EI_MAG2] = ELFMAG2;
eh.e_ident[EI_MAG3] = ELFMAG3;
eh.e_ident[EI_CLASS] = ELFCLASS32;
#if defined(sparc) && defined(SOLARIS)
eh.e_ident[EI_DATA] = ELFDATA2MSB;
#else
eh.e_ident[EI_DATA] = ELFDATA2LSB;
#endif
eh.e_ident[EI_VERSION] = EV_CURRENT;
#ifdef SOLARIS
eh.e_ident[EI_OSABI] = ELFOSABI_SOLARIS;
#else
eh.e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
#endif
#ifdef SOLARIS
eh.e_type = ET_REL; /* ???? */
#else
eh.e_type = ET_NONE; /* ???? */
#endif
#if defined(sparc) && defined(SOLARIS)
/*
* We only support 32-bit code right now, and our binaries are
* v8plus binaries.
*/
eh.e_machine = EM_SPARC32PLUS;
#else
eh.e_machine = EM_386;
#endif
eh.e_version = EV_CURRENT;
eh.e_entry = 0;
eh.e_phoff = 0;
eh.e_shoff = sizeof(Elf_Ehdr);
eh.e_flags = 0;
eh.e_ehsize = sizeof(Elf_Ehdr);
eh.e_phentsize = 0;
eh.e_phnum = 0;
eh.e_shentsize = sizeof(Elf_Shdr);
eh.e_shnum = 3; /* Number of lisp spaces. */
eh.e_shstrndx = 2;
return ewrite(fd, &eh, sizeof(Elf_Ehdr), __func__);
}
int handleRequest(char *cmdbuffer, int *sockfd, int *usbfd) {
char *localCopy = NULL, *request = NULL;
int command = 0;
int32_t returnValue = 0;
// Make a local copy of the command string for parsing
localCopy = malloc(strlen(cmdbuffer)+1);
strcpy( localCopy, cmdbuffer );
// Set all parameters to zero
request = strtok(localCopy , ",");
// See what command has been given
if( request != NULL ) {
if( strstr(request, "MEAS") != NULL ) {
command = CMD_MEAS;
} else if( strstr(request, "ID") != NULL ) {
command = CMD_ID;
} else {
returnValue = UNKNOWN_COMMAND;
ewrite(*sockfd, &returnValue, sizeof(int32_t));
int32_t length = 0;
ewrite(*sockfd, &length, sizeof(int32_t));
return(returnValue);
}
}
free(localCopy);
switch(command) {
case CMD_MEAS:
returnValue = measureWrapper(sockfd, usbfd);
break;
case CMD_ID:
returnValue = idWrapper(sockfd);
break;
}
return returnValue;
}
static void tp(char *s)
{
/* Dump the string into us */
write_buffer_ptr = write_buffer;
/* Write the string with padding */
tputs (s, 1, output_one);
/* Finish the string */
*write_buffer_ptr = '\0';
/* Dump the recorded buffer */
ewrite (write_buffer);
}
static int
write_zero_section_header(int fd)
{
/* Section index 0. */
sh.sh_name = 0;
sh.sh_type = SHT_NULL;
sh.sh_flags = 0;
sh.sh_addr = 0;
sh.sh_offset = 0;
sh.sh_size = 0;
sh.sh_link = SHN_UNDEF;
sh.sh_info = 0;
sh.sh_addralign = 0;
sh.sh_entsize = 0;
return ewrite(fd, &sh, eh.e_shentsize, __func__);
}
static int
write_string_section_header(int fd)
{
/* Section index 0. */
extern Elf_Shdr sh;
sh.sh_name = 1;
sh.sh_type = SHT_STRTAB;
sh.sh_flags = 0;
sh.sh_addr = 0;
sh.sh_offset = sizeof(Elf_Ehdr) + 3 * sizeof(Elf_Shdr);
/* The size of this section is the lengths of the strings plus the
nulls. */
sh.sh_size = strlen(string_table_name) + strlen(object_name) + 3;
sh.sh_link = SHN_UNDEF;
sh.sh_info = 0;
sh.sh_addralign = 0;
sh.sh_entsize = 0;
return ewrite(fd, &sh, eh.e_shentsize, __func__);
}
int write_image_4dfp(char *filespc, IMAGE_4dfp *image)
{
int isbig, vdim, status = 0;
char imgroot[MAXL], imgfile[MAXL], command[MAXL];
FILE *imgfp;
char control = '\0';
isbig = strcmp (image->ifh.imagedata_byte_order, "littleendian");
if (!control) control = (isbig) ? 'b' : 'l';
vdim=image->ifh.matrix_size[0]*image->ifh.matrix_size[1]*image->ifh.matrix_size[2]*image->ifh.matrix_size[3];
getroot(filespc, imgroot);
sprintf(imgfile, "%s.4dfp.img", imgroot);
if (!(imgfp = fopen (imgfile, "wb"))) errw("write_image_4dfp", imgfile);
if (ewrite(image->image, vdim, control, imgfp)) errw("write_image_4dfp", imgfile);
/* ifh hdr rec */
if (fclose(imgfp)) errw("write_image_4dfp", imgfile);
if (Writeifh("write_image_4dfp", imgfile, &image->ifh, control)) errw("write_image_4dfp", imgroot);
sprintf(command, "ifh2hdr %s", imgroot);
status |= system (command);
return status;
}
void tty_die()
{
/* no error handling */
extern struct tty_state tty; /* global var */
struct sigaction sigact;
struct vt_mode vtm;
memset(&sigact, 0, sizeof(struct sigaction));
sigact.sa_handler = SIG_DFL;
sigaction(SIGCHLD, &sigact, NULL);
sigaction(SIGUSR1, &sigact, NULL);
vtm.mode = VT_AUTO;
vtm.waitv = 0;
vtm.relsig = vtm.acqsig = vtm.frsig = 0;
ioctl(STDIN_FILENO, VT_SETMODE, &vtm);
ioctl(STDIN_FILENO, KDSETMODE, KD_TEXT);
if (tty.save_tm != NULL)
tcsetattr(STDIN_FILENO, TCSAFLUSH, tty.save_tm);
fflush(stdout);
ewrite(STDIN_FILENO, "\033[?25h", 6); /* make cursor visible */
}
//saves a segment to harddisk
bool dump_seg_to_disk(ulong n)
{
segment_t *curseg;
uchar *segdata;
char *answer;
FILE *file;
curseg = getnseg(n);
//show "save file" dialog
answer = askfile_cv(1,get_segm_name(curseg),"Enter a filename for the segment:",0);
if(answer == NULL)
{
return false;
}
//get copy of segment and save it to disk
segdata = get_segment_data(curseg->startEA, curseg->endEA, getsegsize(curseg));
file = fopenWB(answer);
ewrite(file, segdata, getsegsize(curseg));
eclose(file);
free(segdata);
return true;
}
int handleRequest( char *cmdbuffer, int *clientfd, FILE *hittite) {
char *localCopy = NULL, *request = NULL, *stringParam = NULL;
double parameters[MAX_PARAMS];
int command = 0;
int32_t returnValue = 0;
// Make a local copy of the command string for parsing
localCopy = malloc(strlen(cmdbuffer)+1);
strcpy( localCopy, cmdbuffer );
// Set all parameters to zero
memset(parameters, 0, sizeof(double)*MAX_PARAMS);
request = strtok(localCopy , ",");
// See what command has been given
if( request != NULL ) {
if( strstr(request, "SET") != NULL ) {
command = CMD_SET;
} else if( strstr(request, "ID") != NULL ) {
command = CMD_ID;
} else {
returnValue = UNKNOWN_COMMAND;
ewrite(*clientfd, &returnValue, sizeof(int32_t));
int32_t length = 0;
ewrite(*clientfd, &length, sizeof(int32_t));
return(returnValue);
}
}
// If SET has been issued, the parameter name and respective value should have been received
if( command == CMD_SET ) {
request = strtok(NULL, ",");
if( request != NULL ) {
stringParam = malloc(strlen(request)+1);
strcpy( stringParam, request );
} else {
returnValue = NOT_ENOUGH_PARAMETERS;
ewrite(*clientfd, &returnValue, sizeof(int32_t));
int32_t length = 0;
ewrite(*clientfd, &length, sizeof(int32_t));
return(returnValue);
}
if( command == CMD_SET ) {
int i = 0;
request = strtok(NULL, ",");
while( request != NULL && i < MAX_PARAMS ) {
parameters[i] = atof(request);
i++;
request = strtok(NULL, ",");
}
if( i == 0 ) {
returnValue = NOT_ENOUGH_PARAMETERS;
ewrite(*clientfd, &returnValue, sizeof(int32_t));
int32_t length = 0;
ewrite(*clientfd, &length, sizeof(int32_t));
return(returnValue);
}
}
}
free(localCopy);
switch(command) {
case CMD_SET:
returnValue = setWrapper(stringParam, parameters, clientfd, hittite);
free(stringParam);
break;
case CMD_ID:
returnValue = idWrapper(clientfd);
break;
}
return returnValue;
}
int main (int argc, char *argv[]) {
/*************/
/* image I/O */
/*************/
FILE *fp_img, *fp_out;
IFH ifh;
char imgfile[MAXL], outfile[MAXL], imgroot[MAXL], outroot[MAXL];
char *str, command[MAXL], program[MAXL];
/**************/
/* processing */
/**************/
char control = '\0';
int dimension, c, i, j, k;
int imgdim[4], orient, isbig;
float voxdim[3], voxdimn[3];
float *imgz, *imgp;
double q;
/*********/
/* flags */
/*********/
int status = 0;
int p_flag = 0;
int two_sided = 0;
int defined;
int debug = 0;
printf ("%s\n", rcsid);
setprog (program, argv);
/************************/
/* process command line */
/************************/
for (k = 0, i = 1; i < argc; i++) {
if (*argv[i] == '-') {
strcpy (command, argv[i]); str = command;
while (c = *str++) switch (c) {
case 'd': debug++; break;
case 'p': p_flag++; break;
case '2': two_sided++; break;
case '@': control = *str++; *str = '\0'; break;
}
} else switch (k) {
case 0: getroot (argv[i], imgroot); k++; break;
}
}
if (k < 1) usage (program);
/**************************/
/* get input 4dfp z-image */
/**************************/
sprintf (imgfile, "%s.4dfp.img", imgroot);
if (get_4dfp_dimoe (imgfile, imgdim, voxdim, &orient, &isbig) < 0) errr (program, imgfile);
if (Getifh (imgfile, &ifh)) errr (program, imgfile);
if (!control) control = (isbig) ? 'b' : 'l';
dimension = imgdim[0] * imgdim[1] * imgdim[2];
if (!(imgz = (float *) malloc (dimension * sizeof (float)))) errm (program);
if (!(imgp = (float *) malloc (dimension * sizeof (float)))) errm (program);
/***************************/
/* prepare 4dfp read/write */
/***************************/
fprintf (stdout, "Reading: %s\n", imgfile);
if (!(fp_img = fopen (imgfile, "rb"))) errr (program, imgfile);
sprintf (outroot, "%s_%s", imgroot, (p_flag) ? "p" : "log10p");
sprintf (outfile, "%s.4dfp.img", outroot);
fprintf (stdout, "Writing: %s\n", outfile);
if (!(fp_out = fopen (outfile, "wb"))) errw (program, outfile);
/***********/
/* process */
/***********/
for (j = 0; j < imgdim[3]; j++) {
if (eread (imgz, dimension, isbig, fp_img)) errr (program, imgfile);
for (i = 0; i < dimension; i++) {
q = (double) imgz[i];
defined = !isnan (q) && imgz[i] != (float) 1.e-37 && finite (q);
if (defined) {
if (two_sided) {
q = fabs (q);
imgp[i] = (p_flag) ? 2.*p_z (q) : (-1./M_LN10)*(lnp_z (q) + M_LN2);
} else {
if (q > 0) {
imgp[i] = (p_flag) ? p_z (q) : (-1./M_LN10)*lnp_z (q);
} else {
imgp[i] = (p_flag) ? 1.0 : 0.0;
}
}
} else {
imgp[i] = 1.e-37;
}
}
if (ewrite (imgp, dimension, control, fp_out)) errw (program, outfile);
}
if (fclose (fp_img)) errr (program, imgfile);
if (fclose (fp_out)) errw (program, outfile);
/*******/
/* ifh */
/*******/
if (Writeifh (program, outfile, &ifh, control)) errw (program, outroot);
/*******/
/* hdr */
/*******/
sprintf (command, "ifh2hdr %s", outroot);
status |= system (command);
/*******/
/* rec */
/*******/
startrece (outfile, argc, argv, rcsid, control);
catrec (imgfile);
endrec ();
free (imgz); free (imgp);
exit (status);
}
void
asmb(void)
{
int32 v, magic;
int a, dynsym;
uint32 symo, startva, machlink;
ElfEhdr *eh;
ElfPhdr *ph, *pph;
ElfShdr *sh;
Section *sect;
Sym *sym;
int i;
if(debug['v'])
Bprint(&bso, "%5.2f asmb\n", cputime());
Bflush(&bso);
sect = segtext.sect;
seek(cout, sect->vaddr - segtext.vaddr + segtext.fileoff, 0);
codeblk(sect->vaddr, sect->len);
/* output read-only data in text segment (rodata, gosymtab and pclntab) */
for(sect = sect->next; sect != nil; sect = sect->next) {
seek(cout, sect->vaddr - segtext.vaddr + segtext.fileoff, 0);
datblk(sect->vaddr, sect->len);
}
if(debug['v'])
Bprint(&bso, "%5.2f datblk\n", cputime());
Bflush(&bso);
seek(cout, segdata.fileoff, 0);
datblk(segdata.vaddr, segdata.filelen);
machlink = 0;
if(HEADTYPE == Hdarwin)
machlink = domacholink();
if(iself) {
/* index of elf text section; needed by asmelfsym, double-checked below */
/* !debug['d'] causes extra sections before the .text section */
elftextsh = 1;
if(!debug['d']) {
elftextsh += 10;
if(elfverneed)
elftextsh += 2;
}
}
symsize = 0;
spsize = 0;
lcsize = 0;
symo = 0;
if(!debug['s']) {
// TODO: rationalize
if(debug['v'])
Bprint(&bso, "%5.2f sym\n", cputime());
Bflush(&bso);
switch(HEADTYPE) {
default:
if(iself)
goto Elfsym;
case Hgarbunix:
symo = rnd(HEADR+segtext.filelen, 8192)+segdata.filelen;
break;
case Hunixcoff:
symo = rnd(HEADR+segtext.filelen, INITRND)+segdata.filelen;
break;
case Hplan9x32:
symo = HEADR+segtext.filelen+segdata.filelen;
break;
case Hmsdoscom:
case Hmsdosexe:
debug['s'] = 1;
symo = HEADR+segtext.filelen+segdata.filelen;
break;
case Hdarwin:
symo = rnd(HEADR+segtext.filelen, INITRND)+rnd(segdata.filelen, INITRND)+machlink;
break;
Elfsym:
symo = rnd(HEADR+segtext.filelen, INITRND)+segdata.filelen;
symo = rnd(symo, INITRND);
break;
case Hwindows:
symo = rnd(HEADR+segtext.filelen, PEFILEALIGN)+segdata.filelen;
symo = rnd(symo, PEFILEALIGN);
break;
}
seek(cout, symo, 0);
switch(HEADTYPE) {
default:
if(iself) {
if(debug['v'])
Bprint(&bso, "%5.2f elfsym\n", cputime());
asmelfsym();
cflush();
ewrite(cout, elfstrdat, elfstrsize);
if(debug['v'])
Bprint(&bso, "%5.2f dwarf\n", cputime());
dwarfemitdebugsections();
}
break;
case Hplan9x32:
asmplan9sym();
cflush();
sym = lookup("pclntab", 0);
if(sym != nil) {
lcsize = sym->np;
for(i=0; i < lcsize; i++)
cput(sym->p[i]);
cflush();
}
break;
case Hdarwin:
case Hwindows:
if(debug['v'])
Bprint(&bso, "%5.2f dwarf\n", cputime());
dwarfemitdebugsections();
break;
}
}
if(debug['v'])
Bprint(&bso, "%5.2f headr\n", cputime());
Bflush(&bso);
seek(cout, 0L, 0);
switch(HEADTYPE) {
default:
if(iself)
goto Elfput;
case Hgarbunix: /* garbage */
lputb(0x160L<<16); /* magic and sections */
lputb(0L); /* time and date */
lputb(rnd(HEADR+segtext.filelen, 4096)+segdata.filelen);
lputb(symsize); /* nsyms */
lputb((0x38L<<16)|7L); /* size of optional hdr and flags */
lputb((0413<<16)|0437L); /* magic and version */
lputb(rnd(HEADR+segtext.filelen, 4096)); /* sizes */
lputb(segdata.filelen);
lputb(segdata.len - segdata.filelen);
lputb(entryvalue()); /* va of entry */
lputb(INITTEXT-HEADR); /* va of base of text */
lputb(segdata.vaddr); /* va of base of data */
lputb(segdata.vaddr+segdata.filelen); /* va of base of bss */
lputb(~0L); /* gp reg mask */
lputb(0L);
lputb(0L);
lputb(0L);
lputb(0L);
lputb(~0L); /* gp value ?? */
break;
case Hunixcoff: /* unix coff */
/*
* file header
*/
lputl(0x0004014c); /* 4 sections, magic */
lputl(0); /* unix time stamp */
lputl(0); /* symbol table */
lputl(0); /* nsyms */
lputl(0x0003001c); /* flags, sizeof a.out header */
/*
* a.out header
*/
lputl(0x10b); /* magic, version stamp */
lputl(rnd(segtext.filelen, INITRND)); /* text sizes */
lputl(segdata.filelen); /* data sizes */
lputl(segdata.len - segdata.filelen); /* bss sizes */
lputb(entryvalue()); /* va of entry */
lputl(INITTEXT); /* text start */
lputl(segdata.vaddr); /* data start */
/*
* text section header
*/
s8put(".text");
lputl(HEADR); /* pa */
lputl(HEADR); /* va */
lputl(segtext.filelen); /* text size */
lputl(HEADR); /* file offset */
lputl(0); /* relocation */
lputl(0); /* line numbers */
lputl(0); /* relocation, line numbers */
lputl(0x20); /* flags text only */
/*
* data section header
*/
s8put(".data");
lputl(segdata.vaddr); /* pa */
lputl(segdata.vaddr); /* va */
lputl(segdata.filelen); /* data size */
lputl(HEADR+segtext.filelen); /* file offset */
lputl(0); /* relocation */
lputl(0); /* line numbers */
lputl(0); /* relocation, line numbers */
lputl(0x40); /* flags data only */
/*
* bss section header
*/
s8put(".bss");
lputl(segdata.vaddr+segdata.filelen); /* pa */
lputl(segdata.vaddr+segdata.filelen); /* va */
lputl(segdata.len - segdata.filelen); /* bss size */
lputl(0); /* file offset */
lputl(0); /* relocation */
lputl(0); /* line numbers */
lputl(0); /* relocation, line numbers */
lputl(0x80); /* flags bss only */
/*
* comment section header
*/
s8put(".comment");
lputl(0); /* pa */
lputl(0); /* va */
lputl(symsize+lcsize); /* comment size */
lputl(HEADR+segtext.filelen+segdata.filelen); /* file offset */
lputl(HEADR+segtext.filelen+segdata.filelen); /* offset of syms */
lputl(HEADR+segtext.filelen+segdata.filelen+symsize);/* offset of line numbers */
lputl(0); /* relocation, line numbers */
lputl(0x200); /* flags comment only */
break;
case Hplan9x32: /* plan9 */
magic = 4*11*11+7;
lputb(magic); /* magic */
lputb(segtext.filelen); /* sizes */
lputb(segdata.filelen);
lputb(segdata.len - segdata.filelen);
lputb(symsize); /* nsyms */
lputb(entryvalue()); /* va of entry */
lputb(spsize); /* sp offsets */
lputb(lcsize); /* line offsets */
break;
case Hmsdoscom:
/* MS-DOS .COM */
break;
case Hmsdosexe:
/* fake MS-DOS .EXE */
v = rnd(HEADR+segtext.filelen, INITRND)+segdata.filelen;
wputl(0x5A4D); /* 'MZ' */
wputl(v % 512); /* bytes in last page */
wputl(rnd(v, 512)/512); /* total number of pages */
wputl(0x0000); /* number of reloc items */
v = rnd(HEADR-(INITTEXT & 0xFFFF), 16);
wputl(v/16); /* size of header */
wputl(0x0000); /* minimum allocation */
wputl(0xFFFF); /* maximum allocation */
wputl(0x0000); /* initial ss value */
wputl(0x0100); /* initial sp value */
wputl(0x0000); /* complemented checksum */
v = entryvalue();
wputl(v); /* initial ip value (!) */
wputl(0x0000); /* initial cs value */
wputl(0x0000);
wputl(0x0000);
wputl(0x003E); /* reloc table offset */
wputl(0x0000); /* overlay number */
break;
case Hdarwin:
asmbmacho();
break;
Elfput:
eh = getElfEhdr();
startva = INITTEXT - HEADR;
/* This null SHdr must appear before all others */
newElfShdr(elfstr[ElfStrEmpty]);
/* program header info */
pph = newElfPhdr();
pph->type = PT_PHDR;
pph->flags = PF_R + PF_X;
pph->off = eh->ehsize;
pph->vaddr = INITTEXT - HEADR + pph->off;
pph->paddr = INITTEXT - HEADR + pph->off;
pph->align = INITRND;
if(!debug['d']) {
/* interpreter */
sh = newElfShdr(elfstr[ElfStrInterp]);
sh->type = SHT_PROGBITS;
sh->flags = SHF_ALLOC;
sh->addralign = 1;
if(interpreter == nil) {
switch(HEADTYPE) {
case Hlinux:
interpreter = linuxdynld;
break;
case Hfreebsd:
interpreter = freebsddynld;
break;
}
}
elfinterp(sh, startva, interpreter);
ph = newElfPhdr();
ph->type = PT_INTERP;
ph->flags = PF_R;
phsh(ph, sh);
}
elfphload(&segtext);
elfphload(&segdata);
/* Dynamic linking sections */
if (!debug['d']) { /* -d suppresses dynamic loader format */
/* S headers for dynamic linking */
sh = newElfShdr(elfstr[ElfStrGot]);
sh->type = SHT_PROGBITS;
sh->flags = SHF_ALLOC+SHF_WRITE;
sh->entsize = 4;
sh->addralign = 4;
shsym(sh, lookup(".got", 0));
sh = newElfShdr(elfstr[ElfStrGotPlt]);
sh->type = SHT_PROGBITS;
sh->flags = SHF_ALLOC+SHF_WRITE;
sh->entsize = 4;
sh->addralign = 4;
shsym(sh, lookup(".got.plt", 0));
dynsym = eh->shnum;
sh = newElfShdr(elfstr[ElfStrDynsym]);
sh->type = SHT_DYNSYM;
sh->flags = SHF_ALLOC;
sh->entsize = ELF32SYMSIZE;
sh->addralign = 4;
sh->link = dynsym+1; // dynstr
// sh->info = index of first non-local symbol (number of local symbols)
shsym(sh, lookup(".dynsym", 0));
sh = newElfShdr(elfstr[ElfStrDynstr]);
sh->type = SHT_STRTAB;
sh->flags = SHF_ALLOC;
sh->addralign = 1;
shsym(sh, lookup(".dynstr", 0));
if(elfverneed) {
sh = newElfShdr(elfstr[ElfStrGnuVersion]);
sh->type = SHT_GNU_VERSYM;
sh->flags = SHF_ALLOC;
sh->addralign = 2;
sh->link = dynsym;
sh->entsize = 2;
shsym(sh, lookup(".gnu.version", 0));
sh = newElfShdr(elfstr[ElfStrGnuVersionR]);
sh->type = SHT_GNU_VERNEED;
sh->flags = SHF_ALLOC;
sh->addralign = 4;
sh->info = elfverneed;
sh->link = dynsym+1; // dynstr
shsym(sh, lookup(".gnu.version_r", 0));
}
sh = newElfShdr(elfstr[ElfStrRelPlt]);
sh->type = SHT_REL;
sh->flags = SHF_ALLOC;
sh->entsize = ELF32RELSIZE;
sh->addralign = 4;
sh->link = dynsym;
sh->info = eh->shnum; // .plt
shsym(sh, lookup(".rel.plt", 0));
sh = newElfShdr(elfstr[ElfStrPlt]);
sh->type = SHT_PROGBITS;
sh->flags = SHF_ALLOC+SHF_EXECINSTR;
sh->entsize = 4;
sh->addralign = 4;
shsym(sh, lookup(".plt", 0));
sh = newElfShdr(elfstr[ElfStrHash]);
sh->type = SHT_HASH;
sh->flags = SHF_ALLOC;
sh->entsize = 4;
sh->addralign = 4;
sh->link = dynsym;
shsym(sh, lookup(".hash", 0));
sh = newElfShdr(elfstr[ElfStrRel]);
sh->type = SHT_REL;
sh->flags = SHF_ALLOC;
sh->entsize = ELF32RELSIZE;
sh->addralign = 4;
sh->link = dynsym;
shsym(sh, lookup(".rel", 0));
/* sh and PT_DYNAMIC for .dynamic section */
sh = newElfShdr(elfstr[ElfStrDynamic]);
sh->type = SHT_DYNAMIC;
sh->flags = SHF_ALLOC+SHF_WRITE;
sh->entsize = 8;
sh->addralign = 4;
sh->link = dynsym+1; // dynstr
shsym(sh, lookup(".dynamic", 0));
ph = newElfPhdr();
ph->type = PT_DYNAMIC;
ph->flags = PF_R + PF_W;
phsh(ph, sh);
/*
* Thread-local storage segment (really just size).
*/
if(tlsoffset != 0) {
ph = newElfPhdr();
ph->type = PT_TLS;
ph->flags = PF_R;
ph->memsz = -tlsoffset;
ph->align = 4;
}
}
ph = newElfPhdr();
ph->type = PT_GNU_STACK;
ph->flags = PF_W+PF_R;
ph->align = 4;
if(elftextsh != eh->shnum)
diag("elftextsh = %d, want %d", elftextsh, eh->shnum);
for(sect=segtext.sect; sect!=nil; sect=sect->next)
elfshbits(sect);
for(sect=segdata.sect; sect!=nil; sect=sect->next)
elfshbits(sect);
if (!debug['s']) {
sh = newElfShdr(elfstr[ElfStrSymtab]);
sh->type = SHT_SYMTAB;
sh->off = symo;
sh->size = symsize;
sh->addralign = 4;
sh->entsize = 16;
sh->link = eh->shnum; // link to strtab
sh = newElfShdr(elfstr[ElfStrStrtab]);
sh->type = SHT_STRTAB;
sh->off = symo+symsize;
sh->size = elfstrsize;
sh->addralign = 1;
dwarfaddelfheaders();
}
sh = newElfShstrtab(elfstr[ElfStrShstrtab]);
sh->type = SHT_STRTAB;
sh->addralign = 1;
shsym(sh, lookup(".shstrtab", 0));
/* Main header */
eh->ident[EI_MAG0] = '\177';
eh->ident[EI_MAG1] = 'E';
eh->ident[EI_MAG2] = 'L';
eh->ident[EI_MAG3] = 'F';
eh->ident[EI_CLASS] = ELFCLASS32;
eh->ident[EI_DATA] = ELFDATA2LSB;
eh->ident[EI_VERSION] = EV_CURRENT;
switch(HEADTYPE) {
case Hfreebsd:
eh->ident[EI_OSABI] = 9;
break;
}
eh->type = ET_EXEC;
eh->machine = EM_386;
eh->version = EV_CURRENT;
eh->entry = entryvalue();
if(pph != nil) {
pph->filesz = eh->phnum * eh->phentsize;
pph->memsz = pph->filesz;
}
seek(cout, 0, 0);
a = 0;
a += elfwritehdr();
a += elfwritephdrs();
a += elfwriteshdrs();
cflush();
if(a+elfwriteinterp() > ELFRESERVE)
diag("ELFRESERVE too small: %d > %d", a, ELFRESERVE);
break;
case Hwindows:
asmbpe();
break;
}
cflush();
}
int
pppoe(char *ether)
{
char buf[64];
uint8_t pkt[1520];
int dfd, p[2], n, sfd, sz, timeout;
Pppoehdr *ph;
ph = (Pppoehdr*)(pkt+EtherHdrSz);
snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeDiscovery);
if((dfd = dial(buf, nil, nil, nil)) < 0)
sysfatal("dial %s: %r", buf);
snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeSession);
if((sfd = dial(buf, nil, nil, nil)) < 0)
sysfatal("dial %s: %r", buf);
for(timeout=250; timeout<16000; timeout*=2){
clearstate();
memset(pkt, 0, sizeof pkt);
sz = padi(pkt);
if(debug)
dumppkt(pkt);
if(sz < EtherMintu)
sz = EtherMintu;
ewrite(dfd, pkt, sz);
if(pktread(timeout, dfd, pkt, sizeof pkt, wantoffer) < 0)
continue;
memset(pkt, 0, sizeof pkt);
sz = padr(pkt);
if(debug)
dumppkt(pkt);
if(sz < EtherMintu)
sz = EtherMintu;
ewrite(dfd, pkt, sz);
if(pktread(timeout, dfd, pkt, sizeof pkt, wantsession) < 0)
continue;
break;
}
if(sessid < 0)
sysfatal("could not establish session");
rfork(RFNOTEG);
if(pipe(p) < 0)
sysfatal("pipe: %r");
switch(fork()){
case -1:
sysfatal("fork: %r");
default:
break;
case 0:
close(p[1]);
while((n = read(p[0], pkt+Hdr, sizeof pkt-Hdr)) > 0){
etherhdr(pkt, etherdst, EtherPppoeSession);
pppoehdr(pkt+EtherHdrSz, 0x00, sessid);
hnputs(pkt+Hdr-2, n);
sz = Hdr+n;
if(debug > 1){
dumppkt(pkt);
hexdump(pkt, sz);
}
if(sz < EtherMintu)
sz = EtherMintu;
if(write(sfd, pkt, sz) < 0){
if(debug)
fprint(2, "write to ether failed: %r");
_exits(nil);
}
}
_exits(nil);
}
switch(fork()){
case -1:
sysfatal("fork: %r");
default:
break;
case 0:
close(p[1]);
while((n = read(sfd, pkt, sizeof pkt)) > 0){
if(malformed(pkt, n, EtherPppoeSession)
|| ph->code != 0x00 || nhgets(ph->sessid) != sessid){
if(debug)
fprint(2, "malformed session pkt: %r\n");
if(debug)
dumppkt(pkt);
continue;
}
if(write(p[0], pkt+Hdr, nhgets(ph->length)) < 0){
if(debug)
fprint(2, "write to ppp failed: %r\n");
_exits(nil);
}
}
_exits(nil);
}
close(p[0]);
return p[1];
}
