static int unexec_doit( int infd, int outfd ) { int i; struct load_command **the_commands = NULL; unsigned the_commands_len; struct mach_header the_header; int fgrowth; int fdatastart; int fdatasize; int size; struct stat st; char *buf; vm_address_t data_address; vm_size_t data_size; struct segment_command *segment; if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) { return (0); } malloc_cookie = malloc_freezedry(); if (!get_data_region(&data_address, &data_size)) { return (0); } /* * DO NOT USE MALLOC IN THIS SECTION */ { /* * Fix offsets */ for (i = 0; i < the_commands_len; i++) { switch (the_commands[i]->cmd) { case LC_SEGMENT: segment = ((struct segment_command *) the_commands[i]); if (strcmp(segment->segname, SEG_DATA) == 0) { fdatastart = segment->fileoff; fdatasize = segment->filesize; fgrowth = (data_size - segment->filesize); segment->vmsize = data_size; segment->filesize = data_size; } break; case LC_SYMTAB: ((struct symtab_command *) the_commands[i])->symoff += fgrowth; ((struct symtab_command *) the_commands[i])->stroff += fgrowth; break; case LC_SYMSEG: ((struct symseg_command *) the_commands[i])->offset += fgrowth; break; default: break; } } /* * Write header */ if (write(outfd, &the_header, sizeof(the_header)) != sizeof(the_header)) { fatal_unexec("cannot write output file"); return (0); } /* * Write commands */ for (i = 0; i < the_commands_len; i++) { if (write(outfd, the_commands[i], the_commands[i]->cmdsize) != the_commands[i]->cmdsize) { fatal_unexec("cannot write output file"); return (0); } } /* * Write original text * We're already positioned at the beginning of the text * segment, so all we need to do is to copy the bytes. */ size = fdatastart - (sizeof(the_header) + the_header.sizeofcmds); buf = my_malloc(size); if (read(infd, buf, size) != size) { my_free(buf, size); fatal_unexec("cannot read input file"); } if (write(outfd, buf, size) != size) { my_free(buf, size); fatal_unexec("cannot write output file"); return (0); } my_free(buf, size); /* * Write new data */ if (write(outfd, (char *)data_address, data_size) != data_size) { fatal_unexec("cannot write output file"); return (0); } } /* * OKAY TO USE MALLOC NOW */ /* * Write rest of file */ fstat(infd, &st); if (lseek(infd, fdatasize, L_INCR) < 0) { fatal_unexec("cannot seek input file"); return (0); } size = st.st_size - lseek(infd, 0, L_INCR); buf = malloc(size); if (read(infd, buf, size) != size) { free(buf); fatal_unexec("cannot read input file"); return (0); } if (write(outfd, buf, size) != size) { free(buf); fatal_unexec("cannot write output file"); return (0); } free(buf); return (1); }
static int unexec_doit( int infd, int outfd ) { int i; struct load_command **the_commands = NULL; unsigned the_commands_len; struct mach_header the_header; int fgrowth = 0; int fdatastart; int fdatasize; int size; struct stat st; char *buf; vm_address_t data_address; vm_size_t data_size; vm_size_t vmaddr_growth = 0; vm_size_t dataseg_vmaddr, dataseg_vmend; struct segment_command *segment; #ifdef NS_TARGET unsigned long extreloff = 0; unsigned long nextrel = 0; struct dysymtab_command *dysymtab; struct relocation_info reloc_info; #endif if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) { return (0); } malloc_cookie = malloc_freezedry (); if (!get_data_region(&data_address, &data_size)) { return (0); } /* * DO NOT USE MALLOC IN THIS SECTION */ { /* * Fix offsets */ for (i = 0; i < the_commands_len; i++) { switch (the_commands[i]->cmd) { case LC_SEGMENT: segment = ((struct segment_command *) the_commands[i]); if (strcmp(segment->segname, SEG_DATA) == 0) { fdatastart = segment->fileoff; fdatasize = segment->filesize; fgrowth = (data_size - segment->filesize); segment->vmsize = data_size; segment->filesize = data_size; dataseg_vmaddr = segment->vmaddr; dataseg_vmend = segment->vmaddr + segment->vmsize; vmaddr_growth = segment->vmaddr + segment->vmsize; } else { ((struct segment_command *)the_commands[i])->fileoff += fgrowth; } if( strcmp( segment->segname, SEG_LINKEDIT ) == 0 ) { segment->vmaddr = vmaddr_growth; } break; case LC_SYMTAB: ((struct symtab_command *) the_commands[i])->symoff += fgrowth; ((struct symtab_command *) the_commands[i])->stroff += fgrowth; break; case LC_SYMSEG: ((struct symseg_command *) the_commands[i])->offset += fgrowth; break; #ifdef NS_TARGET case LC_DYSYMTAB: dysymtab = ((struct dysymtab_command *)the_commands[i]); extreloff = dysymtab->extreloff; nextrel = dysymtab->nextrel; dysymtab->indirectsymoff += fgrowth; dysymtab->extreloff += fgrowth; break; #endif default: break; } } /* * Write header */ if (write(outfd, &the_header, sizeof(the_header)) != sizeof(the_header)) { fatal_unexec("cannot write output file"); return (0); } /* * Write commands */ for (i = 0; i < the_commands_len; i++) { if (write(outfd, the_commands[i], the_commands[i]->cmdsize) != the_commands[i]->cmdsize) { fatal_unexec("cannot write output file"); return (0); } } /* * Write original text */ if (lseek(infd, the_header.sizeofcmds + sizeof(the_header), L_SET) < 0) { fatal_unexec("cannot seek input file"); return (0); } size = fdatastart - (sizeof(the_header) + the_header.sizeofcmds); buf = my_malloc(size); if (read(infd, buf, size) != size) { my_free(buf, size); fatal_unexec("cannot read input file"); } if (write(outfd, buf, size) != size) { my_free(buf, size); fatal_unexec("cannot write output file"); return (0); } my_free(buf, size); /* * Write new data */ if (write(outfd, (char *)data_address, data_size) != data_size) { fatal_unexec("cannot write output file"); return (0); } } /* * OKAY TO USE MALLOC NOW */ /* * Write rest of file */ fstat(infd, &st); if (lseek(infd, fdatasize, L_INCR) < 0) { fatal_unexec("cannot seek input file"); return (0); } size = st.st_size - lseek(infd, 0, L_INCR); buf = malloc(size); if (read(infd, buf, size) != size) { free(buf); fatal_unexec("cannot read input file"); return (0); } if (write(outfd, buf, size) != size) { free(buf); fatal_unexec("cannot write output file"); return (0); } free(buf); #ifdef NS_TARGET /* * Fix up relocation entries in the data segment. */ if (lseek(infd, extreloff, L_SET) < 0) { fatal_unexec("cannot seek input file"); return (0); } for (i = 0; i < nextrel; i++) { long zeroval = 0; if (read(infd, &reloc_info, sizeof (reloc_info)) != sizeof (reloc_info)) { fatal_unexec("cannot read input file"); return (0); } if (reloc_info.r_address >= dataseg_vmaddr && reloc_info.r_address < dataseg_vmend) { if (lseek (outfd, fdatastart + reloc_info.r_address - dataseg_vmaddr, L_SET) < 0 ) { fatal_unexec("cannot seek input file"); return (0); } switch (reloc_info.r_length) { case 0: if (write(outfd, &zeroval, 1) != 1) { fatal_unexec("cannot write output file"); return (0); } break; case 1: if (write(outfd, &zeroval, 2) != 2) { fatal_unexec("cannot write output file"); return (0); } break; case 2: if (write(outfd, &zeroval, 4) != 4) { fatal_unexec("cannot write output file"); return (0); } break; } } } #endif return (1); }
static void unexec_doit(int infd,int outfd) { int i,j,hpos,opos; extern int malloc_freezedry(void); struct region { struct region *next; unsigned long addr; unsigned long size; vm_prot_t prot; vm_prot_t mprot; } *regions=0,*cregion,**pregions; struct mach_header mh; struct segment_command *lc,*sp; struct symtab_command *st; struct section *sect; malloc_cookie=malloc_freezedry(); { vm_task_t task=task_self(); vm_address_t addr; vm_size_t size; vm_prot_t prot,mprot; vm_inherit_t inhe; boolean_t shrd; port_t name; vm_offset_t offset; for(addr=VM_MIN_ADDRESS,pregions=®ions; vm_region(task,&addr,&size,&prot,&mprot, &inhe,&shrd,&name,&offset)==KERN_SUCCESS; addr += size) { (*pregions)=alloca(sizeof(struct region)); (*pregions)->addr=addr; (*pregions)->size=size; (*pregions)->prot=prot; (*pregions)->mprot=mprot; (*pregions)->next=0; pregions=&((*pregions)->next); } } for(cregion=regions;cregion;cregion=cregion->next) while ((cregion->next) && (cregion->next->addr==cregion->addr+cregion->size) && (cregion->next->prot==cregion->prot) && (cregion->next->mprot==cregion->mprot)) { cregion->size += cregion->next->size; cregion->next = cregion->next->next; } mcopy(infd,-1,0,(unsigned long) &mh,sizeof(mh)); lc=alloca(mh.sizeofcmds); mcopy(infd,-1,sizeof(mh),(unsigned long) lc,mh.sizeofcmds); for(pregions=®ions;*pregions;) { if (!((*pregions)->prot&VM_PROT_WRITE) || ((*pregions)->addr>=0x3000000)) goto kill_region; for(sp=lc,i=0; i<mh.ncmds; i++,sp=(struct segment_command *)(((char *)sp)+sp->cmdsize)) { unsigned long ob,oe; if (sp->cmd!=LC_SEGMENT||(strcmp(sp->segname,SEG_DATA)==0)) continue; ob=MAX((*pregions)->addr,sp->vmaddr); oe=MIN((*pregions)->addr+(*pregions)->size,sp->vmaddr+sp->vmsize); if (ob >= oe) continue; if (ob==(*pregions)->addr) if (oe==(*pregions)->addr+(*pregions)->size) { goto kill_region; } else { (*pregions)->addr=oe; (*pregions)->size-=(oe-ob); } else if (oe==(*pregions)->addr+(*pregions)->size) { (*pregions)->size-=(oe-ob); } else { cregion=alloca(sizeof(*cregion)); cregion->addr=oe; cregion->size=((*pregions)->addr+(*pregions)->size)-oe; cregion->prot=(*pregions)->prot; cregion->mprot=(*pregions)->mprot; cregion->next=(*pregions)->next; (*pregions)->size=ob-(*pregions)->addr; (*pregions)->next=cregion; } } pregions=&((*pregions)->next); continue; kill_region: *pregions=(*pregions)->next; } for(sp=lc,i=mh.ncmds,hpos=sizeof(mh),opos=0; i>0; i--,sp=(struct segment_command *)(((char *)sp)+sp->cmdsize)) switch (sp->cmd) { case LC_SEGMENT: if (strcmp(sp->segname,SEG_DATA)==0) { mh.ncmds--; j=sp->cmdsize; while (regions) { mcopy(-1,outfd,regions->addr,opos,regions->size); sp->cmd=LC_SEGMENT; sp->cmdsize=sizeof(*sp); strncpy(sp->segname,SEG_DATA,sizeof(sp->segname)); sp->vmaddr=regions->addr; sp->vmsize=regions->size; sp->filesize=regions->size; sp->maxprot=regions->prot; sp->initprot=regions->mprot; sp->nsects=0; sp->flags=0; sp->fileoff=opos; opos+=sp->filesize; mcopy(-1,outfd,(unsigned long)sp,hpos,sp->cmdsize); hpos+=sp->cmdsize; mh.ncmds++; regions=regions->next; } sp->cmdsize=j; regions=0; } else if (strcmp(sp->segname,SEG_LINKEDIT)==0) { mh.ncmds--; } else { mcopy(infd,outfd,sp->fileoff,opos,sp->filesize); sect=(struct section *) (((char *)sp)+sizeof(*sp)); for(j=0;j<sp->nsects;j++) { if (sect[j].offset!=0) sect[j].offset=(sect[j].offset-sp->fileoff)+opos; if (sect[j].reloff!=0) sect[j].reloff=(sect[j].reloff-sp->fileoff)+opos; } sp->fileoff=opos; opos+=sp->filesize; mcopy(-1,outfd,(unsigned long)sp,hpos,sp->cmdsize); hpos+=sp->cmdsize; } break; case LC_SYMTAB: st=(struct symtab_command *)sp; mcopy(infd,outfd,st->symoff,opos,st->nsyms*sizeof(struct nlist)); st->symoff=opos; opos+=sizeof(struct nlist)*st->nsyms; mcopy(infd,outfd,st->stroff,opos,st->strsize); ((struct symtab_command *)sp)->stroff=opos; opos+=((struct symtab_command *)sp)->strsize; default: mcopy(-1,outfd,(unsigned long)sp,hpos,sp->cmdsize); hpos+=sp->cmdsize; } mh.sizeofcmds=hpos-sizeof(mh); mcopy(-1,outfd,(unsigned long) &mh,0,sizeof(mh)); }