![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to objcedit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / objc|
Return to objcedit.c CVS log | Up to [Apple Darwin 0.x] / objc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.0 (the 'License'). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License." ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: #include <stdlib.h> ! 25: #include <stdarg.h> ! 26: #include <string.h> ! 27: #include <errno.h> ! 28: #include <stdio.h> ! 29: #include <sys/file.h> ! 30: #include <mach-o/loader.h> ! 31: #define SECT_OBJC_RUNTIME "__runtime_setup" ! 32: #include <sys/types.h> ! 33: #include <sys/stat.h> ! 34: #include <mach/mach.h> ! 35: #include <mach/mach_error.h> ! 36: #include <libc.h> ! 37: ! 38: /* ! 39: * This really is the segment alignment of the input file and is an assumption ! 40: * on what the segment alignment is since it can't exactly be determined from ! 41: * the file itself. ! 42: */ ! 43: const long SEGALIGN = 0x2000; ! 44: ! 45: /* This is set in the routine main() */ ! 46: extern char *progname; ! 47: ! 48: /* These variables are set in the routine map_input() */ ! 49: static char *input_addr = NULL; /* address of where the input file is mapped */ ! 50: static long input_size = 0; /* size of the input file */ ! 51: static long input_mode = 0; /* mode of the input file */ ! 52: static struct mach_header ! 53: *mhp = NULL; /* pointer to the input file's mach header */ ! 54: static struct load_command ! 55: *load_commands = NULL; /* pointer to the input file's load commands */ ! 56: static int swapped; /* TRUE if the input is to be swapped */ ! 57: static enum NXByteOrder host_byte_order = NX_UnknownByteOrder; ! 58: static enum NXByteOrder target_byte_order = NX_UnknownByteOrder; ! 59: ! 60: /* ! 61: * Structures used in objc_runtime_setup in updating sections in the segments ! 62: * of the input file. There is one such structure for each segment and section. ! 63: */ ! 64: struct rep_seg { ! 65: long fileoff; /* original file offset */ ! 66: long filesize; /* original file size */ ! 67: long vmsize; /* original vm size */ ! 68: long padsize; /* new pad size */ ! 69: struct segment_command *sgp;/* pointer to the segment_command */ ! 70: }; ! 71: static struct rep_seg *segs = NULL; ! 72: ! 73: struct rep_sect { ! 74: long offset; /* original file offset */ ! 75: struct section *sp; /* pointer to the section structure */ ! 76: }; ! 77: static struct rep_sect *sects = NULL; ! 78: ! 79: /* Internal routines */ ! 80: static long map_input( ! 81: char *input); ! 82: static long objc_runtime_setup( ! 83: char *input, ! 84: char *output, ! 85: char *objc_runtime_setup_contents, ! 86: unsigned long objc_runtime_setup_size); ! 87: static int qsort_vmaddr( ! 88: const struct rep_seg *seg1, ! 89: const struct rep_seg *seg2); ! 90: static int qsort_fileoff( ! 91: const struct rep_seg *seg1, ! 92: const struct rep_seg *seg2); ! 93: static int qsort_offset( ! 94: const struct rep_sect *sect1, ! 95: const struct rep_sect *sect2); ! 96: static void *allocate( ! 97: long size); ! 98: static void error( ! 99: const char *format, ! 100: ...); ! 101: static void fatal( ! 102: const char *format, ! 103: ...); ! 104: static void system_error( ! 105: const char *format, ! 106: ...); ! 107: static void system_fatal( ! 108: const char *format, ! 109: ...); ! 110: static void machkern_error( ! 111: kern_return_t r, ! 112: char *format, ! 113: ...); ! 114: long round( ! 115: long v, ! 116: unsigned long r); ! 117: ! 118: /* ! 119: * add_objc_runtime_setup is passed a name of an object file and pointer to the ! 120: * contents of the objc_runtime_setup section and it's size and creates an ! 121: * output file with that section added or releaced. It returns 1 if successfull ! 122: * and zero otherwize. ! 123: */ ! 124: long ! 125: add_objc_runtime_setup( ! 126: char *input, ! 127: char *output, ! 128: char *contents, ! 129: long size) ! 130: { ! 131: /* map in the input */ ! 132: if(map_input(input) == 0) ! 133: return(0); ! 134: ! 135: /* create the output with the contents */ ! 136: if(objc_runtime_setup(input, output, contents, size) == 0) ! 137: return(0); ! 138: ! 139: return(1); ! 140: } ! 141: ! 142: /* ! 143: * map_input maps the input file into memory. The address it is mapped at is ! 144: * left in input_addr and the size is left in input_size. The input file is ! 145: * checked to be an object file and that the headers are checked to be correct ! 146: * enough to loop through them. The pointer to the mach header is left in mhp ! 147: * and the pointer to the load commands is left in load_commands. It returns ! 148: * 1 if it is successfull and zero otherwise. ! 149: */ ! 150: static ! 151: long ! 152: map_input( ! 153: char *input) ! 154: { ! 155: int fd; ! 156: long i; ! 157: struct stat stat_buf; ! 158: kern_return_t r; ! 159: struct load_command l, *lcp; ! 160: struct segment_command *sgp; ! 161: struct section *sp; ! 162: struct symtab_command *stp; ! 163: struct symseg_command *ssp; ! 164: ! 165: /* Open the input file and map it in */ ! 166: if((fd = open(input, O_RDONLY)) == -1){ ! 167: system_error("can't open input file: %s", input); ! 168: return(0); ! 169: } ! 170: if(fstat(fd, &stat_buf) == -1){ ! 171: system_error("Can't stat input file: %s", input); ! 172: close(fd); ! 173: return(0); ! 174: } ! 175: input_size = stat_buf.st_size; ! 176: input_mode = stat_buf.st_mode; ! 177: if((r = map_fd(fd, 0, (vm_offset_t *) &input_addr, TRUE, input_size)) ! 178: != KERN_SUCCESS){ ! 179: machkern_error(r, "Can't map input file: %s", input); ! 180: close(fd); ! 181: return(0); ! 182: } ! 183: close(fd); ! 184: ! 185: if(sizeof(struct mach_header) > input_size){ ! 186: error("truncated or malformed object (mach header would extend " ! 187: "past the end of the file) in: %s", input); ! 188: goto map_input_cleanup; ! 189: } ! 190: mhp = (struct mach_header *)input_addr; ! 191: host_byte_order = NXHostByteOrder(); ! 192: if(mhp->magic == NXSwapLong(MH_MAGIC)){ ! 193: swapped = 1; ! 194: target_byte_order = host_byte_order == NX_BigEndian ? ! 195: NX_LittleEndian : NX_BigEndian; ! 196: swap_mach_header(mhp, host_byte_order); ! 197: } ! 198: else if(mhp->magic == MH_MAGIC){ ! 199: swapped = 0; ! 200: target_byte_order = host_byte_order; ! 201: } ! 202: else{ ! 203: error("bad magic number (file is not a Mach-O file) in: %s", input); ! 204: goto map_input_cleanup; ! 205: } ! 206: ! 207: if(mhp->sizeofcmds + sizeof(struct mach_header) > input_size) ! 208: fatal("truncated or malformed object (load commands would extend " ! 209: "past the end of the file) in: %s", input); ! 210: load_commands = (struct load_command *)((char *)input_addr + ! 211: sizeof(struct mach_header)); ! 212: lcp = load_commands; ! 213: for(i = 0; i < mhp->ncmds; i++){ ! 214: l = *lcp; ! 215: if(swapped) ! 216: swap_load_command(&l, host_byte_order); ! 217: if(l.cmdsize % sizeof(long) != 0){ ! 218: error("load command %ld size not a multiple of sizeof(long) " ! 219: "in: %s", i, input); ! 220: goto map_input_cleanup; ! 221: } ! 222: if(l.cmdsize <= 0){ ! 223: error("load command %ld size is less than or equal to zero " ! 224: "in: %s", i, input); ! 225: goto map_input_cleanup; ! 226: } ! 227: if((char *)lcp + l.cmdsize > ! 228: (char *)load_commands + mhp->sizeofcmds){ ! 229: error("load command %ld extends past end of all load commands " ! 230: "in: %s", i, input); ! 231: goto map_input_cleanup; ! 232: } ! 233: switch(l.cmd){ ! 234: case LC_SEGMENT: ! 235: sgp = (struct segment_command *)lcp; ! 236: sp = (struct section *)((char *)sgp + ! 237: sizeof(struct segment_command)); ! 238: if(swapped) ! 239: swap_segment_command(sgp, host_byte_order); ! 240: if(swapped) ! 241: swap_section(sp, sgp->nsects, host_byte_order); ! 242: break; ! 243: case LC_SYMTAB: ! 244: stp = (struct symtab_command *)lcp; ! 245: if(swapped) ! 246: swap_symtab_command(stp, host_byte_order); ! 247: break; ! 248: case LC_SYMSEG: ! 249: ssp = (struct symseg_command *)lcp; ! 250: if(swapped) ! 251: swap_symseg_command(ssp, host_byte_order); ! 252: break; ! 253: default: ! 254: *lcp = l; ! 255: break; ! 256: } ! 257: lcp = (struct load_command *)((char *)lcp + l.cmdsize); ! 258: } ! 259: return(1); ! 260: ! 261: map_input_cleanup: ! 262: /* ! 263: * Cleanup if there were errors in map_input(). ! 264: */ ! 265: if(input_addr != NULL){ ! 266: if((r = vm_deallocate(task_self(), (vm_address_t)input_addr, ! 267: input_size)) != KERN_SUCCESS) ! 268: machkern_error(r,"Can't deallocate input file's mapped memory"); ! 269: } ! 270: return(0); ! 271: } ! 272: ! 273: /* ! 274: * objc_runtime_setup writes a modified version of the input file to output ! 275: * adding or replacing the (__OBJC,__runtime_setup) section with the contents ! 276: * passed to it. ! 277: */ ! 278: static ! 279: long ! 280: objc_runtime_setup( ! 281: char *input, ! 282: char *output, ! 283: char *objc_runtime_setup_contents, ! 284: unsigned long objc_runtime_setup_size) ! 285: { ! 286: long i, j, k, nsegs, nsects; ! 287: long high_reloc_seg, low_noreloc_seg, high_noreloc_seg, low_linkedit; ! 288: long oldvmaddr, oldoffset, newvmaddr, newoffset, newsectsize; ! 289: struct mach_header *new_mhp; ! 290: struct load_command lc, *lcp, *new_lcp, *new_load_commands; ! 291: struct segment_command *sgp, *linkedit_sgp, *objc_sgp; ! 292: struct section *sp, *first_sp, *objc_runtime_setup_sp, *last_objc_sp; ! 293: struct symtab_command *stp; ! 294: struct symseg_command *ssp; ! 295: int outfd; ! 296: vm_address_t pad_addr; ! 297: long size; ! 298: kern_return_t r; ! 299: ! 300: segs = NULL; ! 301: new_mhp = NULL; ! 302: sects = NULL; ! 303: pad_addr = 0; ! 304: outfd = -1; ! 305: ! 306: high_reloc_seg = 0; ! 307: low_noreloc_seg = input_size; ! 308: high_noreloc_seg = 0; ! 309: low_linkedit = input_size; ! 310: ! 311: nsegs = 0; ! 312: segs = allocate(mhp->ncmds * sizeof(struct rep_seg)); ! 313: bzero(segs, mhp->ncmds * sizeof(struct rep_seg)); ! 314: nsects = 0; ! 315: ! 316: stp = NULL; ! 317: ssp = NULL; ! 318: linkedit_sgp = NULL; ! 319: first_sp = NULL; ! 320: objc_sgp = NULL; ! 321: objc_runtime_setup_sp = NULL; ! 322: ! 323: /* ! 324: * First pass over the load commands and determine if the file is laided ! 325: * out in an order that the new section can be replaced or added. ! 326: */ ! 327: lcp = load_commands; ! 328: for(i = 0; i < mhp->ncmds; i++){ ! 329: switch(lcp->cmd){ ! 330: case LC_SEGMENT: ! 331: sgp = (struct segment_command *)lcp; ! 332: sp = (struct section *)((char *)sgp + ! 333: sizeof(struct segment_command)); ! 334: segs[nsegs++].sgp = sgp; ! 335: nsects += sgp->nsects; ! 336: if(strcmp(sgp->segname, SEG_LINKEDIT) != 0){ ! 337: if(strncmp(SEG_OBJC, sgp->segname, ! 338: sizeof(sgp->segname)) == 0){ ! 339: if(objc_sgp != NULL){ ! 340: error("more than one " SEG_OBJC " segment found " ! 341: "in: %s", input); ! 342: goto objc_runtime_setup_cleanup; ! 343: } ! 344: objc_sgp = sgp; ! 345: } ! 346: if(sgp->flags & SG_NORELOC){ ! 347: if(sgp->filesize != 0){ ! 348: if(sgp->fileoff + sgp->filesize > high_noreloc_seg) ! 349: high_noreloc_seg = sgp->fileoff + sgp->filesize; ! 350: if(sgp->fileoff < low_noreloc_seg) ! 351: low_noreloc_seg = sgp->fileoff; ! 352: } ! 353: } ! 354: else{ ! 355: if(sgp->filesize != 0 && ! 356: sgp->fileoff + sgp->filesize > high_reloc_seg) ! 357: high_reloc_seg = sgp->fileoff + sgp->filesize; ! 358: } ! 359: } ! 360: else{ ! 361: if(linkedit_sgp != NULL){ ! 362: error("more than one " SEG_LINKEDIT " segment found " ! 363: "in: %s", input); ! 364: goto objc_runtime_setup_cleanup; ! 365: } ! 366: linkedit_sgp = sgp; ! 367: } ! 368: for(j = 0; j < sgp->nsects; j++){ ! 369: if(sp->nreloc != 0 && sp->reloff < low_linkedit) ! 370: low_linkedit = sp->reloff; ! 371: if(first_sp == NULL) ! 372: first_sp = sp; ! 373: if(strncmp(SEG_OBJC, sp->segname, ! 374: sizeof(sp->segname)) == 0 && ! 375: strncmp(SECT_OBJC_RUNTIME, sp->sectname, ! 376: sizeof(sp->sectname)) == 0){ ! 377: if(objc_runtime_setup_sp != NULL){ ! 378: error("more than one (%0.16s,%0.16s) section in: " ! 379: "%s", sp->segname, sp->sectname, input); ! 380: goto objc_runtime_setup_cleanup; ! 381: } ! 382: objc_runtime_setup_sp = sp; ! 383: if(sp->flags & S_ZEROFILL){ ! 384: error("(%0.16s,%0.16s) is a fill section in: %s", ! 385: sp->segname, sp->sectname, input); ! 386: goto objc_runtime_setup_cleanup; ! 387: } ! 388: if(j != sgp->nsects - 1){ ! 389: error("(%0.16s,%0.16s) is not the last section in " ! 390: "the " SEG_OBJC " segment in: %s", ! 391: sp->segname, sp->sectname, input); ! 392: goto objc_runtime_setup_cleanup; ! 393: } ! 394: if(sp->offset + sp->size > input_size) ! 395: error("truncated or malformed object (section " ! 396: "contents of (%0.16s,%0.16s) extends " ! 397: "past the end of the file) in: %s", ! 398: sp->segname, sp->sectname, input); ! 399: } ! 400: sp++; ! 401: } ! 402: break; ! 403: case LC_SYMTAB: ! 404: if(stp != NULL) ! 405: fatal("more than one symtab_command found in: %s", input); ! 406: stp = (struct symtab_command *)lcp; ! 407: if(stp->nsyms != 0 && stp->symoff < low_linkedit) ! 408: low_linkedit = stp->symoff; ! 409: if(stp->strsize != 0 && stp->stroff < low_linkedit) ! 410: low_linkedit = stp->stroff; ! 411: break; ! 412: case LC_SYMSEG: ! 413: if(ssp != NULL) ! 414: fatal("more than one symseg_command found in: %s", input); ! 415: ssp = (struct symseg_command *)lcp; ! 416: if(ssp->size != 0 && ssp->offset < low_linkedit) ! 417: low_linkedit = ssp->offset; ! 418: break; ! 419: case LC_THREAD: ! 420: case LC_UNIXTHREAD: ! 421: case LC_LOADFVMLIB: ! 422: case LC_IDFVMLIB: ! 423: case LC_IDENT: ! 424: break; ! 425: default: ! 426: error("unknown load command %d in: %s (result maybe bad)", i, ! 427: input); ! 428: break; ! 429: } ! 430: lcp = (struct load_command *)((char *)lcp + lcp->cmdsize); ! 431: } ! 432: ! 433: if(objc_sgp == NULL){ ! 434: error("file: %s does not contain an " SEG_OBJC " segment", input); ! 435: goto objc_runtime_setup_cleanup; ! 436: } ! 437: if(objc_runtime_setup_sp == NULL && ! 438: first_sp->offset - (sizeof(struct mach_header) + mhp->sizeofcmds) < ! 439: sizeof(struct section)){ ! 440: error("file: %s does not have enough header padding to add a " ! 441: "section", input); ! 442: goto objc_runtime_setup_cleanup; ! 443: } ! 444: if(high_reloc_seg > low_noreloc_seg || ! 445: high_reloc_seg > low_linkedit || ! 446: high_noreloc_seg > low_linkedit){ ! 447: error("contents of input file: %s not in an order that the " ! 448: "new section can be added or replaced by this program", ! 449: input); ! 450: goto objc_runtime_setup_cleanup; ! 451: } ! 452: if(low_noreloc_seg != input_size && ! 453: low_noreloc_seg != objc_sgp->fileoff + objc_sgp->filesize){ ! 454: error("file's: %s " SEG_OBJC " segment is not the last segment " ! 455: "before the segments requiring no relocation", input); ! 456: goto objc_runtime_setup_cleanup; ! 457: } ! 458: ! 459: /* ! 460: * If the section must be added rather than just updated then rebuild ! 461: * the headers with the new section in it. And reset the pointers into ! 462: * the load commands to point to the newly allocated load commands. ! 463: */ ! 464: if(objc_runtime_setup_sp == NULL){ ! 465: new_mhp = (struct mach_header *)allocate( ! 466: sizeof(struct mach_header) + mhp->sizeofcmds + ! 467: sizeof(struct section)); ! 468: *new_mhp = *mhp; ! 469: new_mhp->sizeofcmds += sizeof(struct section); ! 470: new_load_commands = (struct load_command *)((char *)new_mhp + ! 471: sizeof(struct mach_header)); ! 472: lcp = load_commands; ! 473: new_lcp = new_load_commands; ! 474: nsegs = 0; ! 475: ! 476: for(i = 0; i < mhp->ncmds; i++){ ! 477: memcpy((char *)new_lcp, (char *)lcp, lcp->cmdsize); ! 478: if(new_lcp->cmd == LC_SEGMENT){ ! 479: segs[nsegs++].sgp = (struct segment_command *)new_lcp; ! 480: if((struct segment_command *)lcp == linkedit_sgp) ! 481: linkedit_sgp = (struct segment_command *)new_lcp; ! 482: } ! 483: if((struct symtab_command *)lcp == stp) ! 484: stp = (struct symtab_command *)new_lcp; ! 485: if((struct symseg_command *)lcp == ssp) ! 486: ssp = (struct symseg_command *)new_lcp; ! 487: if((struct segment_command *)lcp == objc_sgp){ ! 488: objc_sgp = (struct segment_command *)new_lcp; ! 489: objc_runtime_setup_sp = ! 490: (struct section *)((char *)objc_sgp + ! 491: sizeof(struct segment_command) + ! 492: objc_sgp->nsects * sizeof(struct section)); ! 493: last_objc_sp = (struct section *)((char *)objc_sgp + ! 494: sizeof(struct segment_command) + ! 495: (objc_sgp->nsects - 1) * ! 496: sizeof(struct section)); ! 497: objc_sgp->cmdsize += sizeof(struct section); ! 498: objc_sgp->nsects++; ! 499: nsects++; ! 500: memset(objc_runtime_setup_sp, '\0', sizeof(struct section)); ! 501: strcpy(objc_runtime_setup_sp->sectname, SECT_OBJC_RUNTIME); ! 502: strcpy(objc_runtime_setup_sp->segname, SEG_OBJC); ! 503: objc_runtime_setup_sp->addr = round(last_objc_sp->addr + ! 504: last_objc_sp->size, ! 505: sizeof(long)); ! 506: objc_runtime_setup_sp->size = 0; ! 507: objc_runtime_setup_sp->offset = last_objc_sp->offset + ! 508: objc_runtime_setup_sp->addr- ! 509: last_objc_sp->addr; ! 510: objc_runtime_setup_sp->align = 2; ! 511: objc_runtime_setup_sp->reloff = 0; ! 512: objc_runtime_setup_sp->nreloc = 0; ! 513: objc_runtime_setup_sp->flags = 0; ! 514: } ! 515: new_lcp = (struct load_command *)((char *)new_lcp + ! 516: new_lcp->cmdsize); ! 517: lcp = (struct load_command *)((char *)lcp + lcp->cmdsize); ! 518: } ! 519: mhp = new_mhp; ! 520: load_commands = new_load_commands; ! 521: } ! 522: ! 523: qsort(segs, nsegs, sizeof(struct rep_seg), ! 524: (int (*)(const void *, const void *))qsort_vmaddr); ! 525: ! 526: sects = allocate(nsects * sizeof(struct rep_sect)); ! 527: bzero(sects, nsects * sizeof(struct rep_sect)); ! 528: ! 529: /* ! 530: * First go through the segments and adjust the segment offsets, sizes ! 531: * and addresses without adjusting the offset to the relocation entries. ! 532: * This program can only handle object files that have contigious ! 533: * address spaces starting at zero and that the offsets in the file for ! 534: * the contents of the segments also being contiguious and in the same ! 535: * order as the vmaddresses. ! 536: */ ! 537: oldvmaddr = 0; ! 538: newvmaddr = 0; ! 539: k = 0; ! 540: for(i = 0; i < nsegs; i++){ ! 541: if(segs[i].sgp->vmaddr != oldvmaddr){ ! 542: newvmaddr = segs[i].sgp->vmaddr; ! 543: oldvmaddr = newvmaddr; ! 544: } ! 545: segs[i].filesize = segs[i].sgp->filesize; ! 546: segs[i].vmsize = segs[i].sgp->vmsize; ! 547: segs[i].sgp->vmaddr = newvmaddr; ! 548: sp = (struct section *)((char *)(segs[i].sgp) + ! 549: sizeof(struct segment_command)); ! 550: if(segs[i].sgp->filesize != 0){ ! 551: newsectsize = 0; ! 552: if(segs[i].sgp == objc_sgp || segs[i].sgp->flags == SG_NORELOC){ ! 553: for(j = 0; j < segs[i].sgp->nsects; j++){ ! 554: ! 555: /* begin bug fix - snaroff (8/3/90) */ ! 556: if ((sp->offset == 0) && (sp->flags != S_ZEROFILL)) ! 557: sp->offset = (sp+1)->offset; ! 558: /* end bug fix - snaroff (8/3/90) */ ! 559: ! 560: sects[k + j].sp = sp; ! 561: if(sp == objc_runtime_setup_sp) ! 562: sp->size = objc_runtime_setup_size; ! 563: sp->addr += newvmaddr - oldvmaddr; ! 564: newsectsize = (sp->addr - newvmaddr) + sp->size; ! 565: sp++; ! 566: } ! 567: if(strcmp(segs[i].sgp->segname, SEG_LINKEDIT) != 0){ ! 568: segs[i].sgp->filesize = round(newsectsize, SEGALIGN); ! 569: segs[i].sgp->vmsize = round(newsectsize, SEGALIGN); ! 570: segs[i].padsize = segs[i].sgp->filesize - newsectsize; ! 571: } ! 572: } ! 573: else{ ! 574: for(j = 0; j < segs[i].sgp->nsects; j++) ! 575: sects[k + j].sp = sp; ! 576: } ! 577: } ! 578: else{ ! 579: for(j = 0; j < segs[i].sgp->nsects; j++) ! 580: sects[k + j].sp = sp; ! 581: } ! 582: oldvmaddr += segs[i].vmsize; ! 583: newvmaddr += segs[i].sgp->vmsize; ! 584: k += segs[i].sgp->nsects; ! 585: } ! 586: ! 587: qsort(segs, nsegs, sizeof(struct rep_seg), ! 588: (int (*)(const void *, const void *))qsort_fileoff); ! 589: qsort(sects, nsects, sizeof(struct rep_sect), ! 590: (int (*)(const void *, const void *))qsort_offset); ! 591: ! 592: oldoffset = 0; ! 593: newoffset = 0; ! 594: k = 0; ! 595: for(i = 0; i < nsegs; i++){ ! 596: if(segs[i].sgp->filesize != 0){ ! 597: if(segs[i].sgp->fileoff != oldoffset){ ! 598: oldoffset = segs[i].sgp->fileoff; ! 599: newoffset = oldoffset; ! 600: } ! 601: segs[i].fileoff = segs[i].sgp->fileoff; ! 602: if(strcmp(segs[i].sgp->segname, SEG_LINKEDIT) != 0) ! 603: segs[i].sgp->fileoff = newoffset; ! 604: sp = (struct section *)((char *)(segs[i].sgp) + ! 605: sizeof(struct segment_command)); ! 606: if(segs[i].sgp == objc_sgp || segs[i].sgp->flags == SG_NORELOC){ ! 607: for(j = 0; j < segs[i].sgp->nsects; j++){ ! 608: sects[k + j].offset = sp->offset; ! 609: sp->offset += newoffset - oldoffset; ! 610: sp++; ! 611: } ! 612: } ! 613: /* ! 614: * If it is not the LINKEDIT segment or the last segment then ! 615: * move up the offsets. ! 616: */ ! 617: if(strcmp(segs[i].sgp->segname, SEG_LINKEDIT) != 0 || ! 618: i != nsegs - 1){ ! 619: oldoffset += segs[i].filesize; ! 620: newoffset += segs[i].sgp->filesize; ! 621: } ! 622: } ! 623: k += segs[i].sgp->nsects; ! 624: } ! 625: ! 626: /* ! 627: * Now update the offsets to the linkedit information. ! 628: */ ! 629: if(oldoffset != low_linkedit){ ! 630: error("contents of input file: %s not in an order that the " ! 631: "specified sections can be replaced by this program", input); ! 632: goto objc_runtime_setup_cleanup; ! 633: } ! 634: for(i = 0; i < nsegs; i++){ ! 635: sp = (struct section *)((char *)(segs[i].sgp) + ! 636: sizeof(struct segment_command)); ! 637: for(j = 0; j < segs[i].sgp->nsects; j++){ ! 638: if(sp->nreloc != 0) ! 639: sp->reloff += newoffset - oldoffset; ! 640: sp++; ! 641: } ! 642: } ! 643: if(stp != NULL){ ! 644: if(stp->nsyms != 0); ! 645: stp->symoff += newoffset - oldoffset; ! 646: if(stp->strsize != 0) ! 647: stp->stroff += newoffset - oldoffset; ! 648: } ! 649: if(ssp != NULL){ ! 650: if(ssp->size != 0) ! 651: ssp->offset += newoffset - oldoffset; ! 652: } ! 653: if(linkedit_sgp != NULL){ ! 654: linkedit_sgp->fileoff += newoffset - oldoffset; ! 655: } ! 656: ! 657: /* ! 658: * Now write the new file by writing the header and modified load ! 659: * commands, then the segments with any new sections and finally ! 660: * the link edit info. ! 661: */ ! 662: if((outfd = open(output, O_CREAT | O_WRONLY | O_TRUNC ,input_mode)) == ! 663: -1){ ! 664: system_error("can't create output file: %s", output); ! 665: goto objc_runtime_setup_cleanup; ! 666: } ! 667: ! 668: if(r = vm_allocate(task_self(), &pad_addr, SEGALIGN, 1) != ! 669: KERN_SUCCESS){ ! 670: machkern_error(r, "vm_allocate() failed"); ! 671: goto objc_runtime_setup_cleanup; ! 672: } ! 673: ! 674: k = 0; ! 675: for(i = 0; i < nsegs; i++){ ! 676: if(segs[i].sgp == objc_sgp){ ! 677: for(j = 0; j < segs[i].sgp->nsects; j++){ ! 678: sp = sects[k + j].sp; ! 679: if(sp == objc_runtime_setup_sp){ ! 680: lseek(outfd, sp->offset, L_SET); ! 681: if(write(outfd, objc_runtime_setup_contents, ! 682: objc_runtime_setup_size) != ! 683: objc_runtime_setup_size){ ! 684: system_error("can't write section contents for " ! 685: "section (%s,%s) to output file: %s", ! 686: sp->segname, sp->sectname, output); ! 687: goto objc_runtime_setup_cleanup; ! 688: } ! 689: } ! 690: else{ ! 691: /* write the original section */ ! 692: if(sects[k + j].offset + sp->size > input_size){ ! 693: error("truncated or malformed object file: %s " ! 694: "(section (%0.16s,%0.16s) extends past the " ! 695: "end of the file)",input, sp->segname, ! 696: sp->sectname); ! 697: goto objc_runtime_setup_cleanup; ! 698: } ! 699: lseek(outfd, sp->offset, L_SET); ! 700: ! 701: if(write(outfd,(char *)input_addr + sects[k + j].offset, ! 702: sp->size) != sp->size){ ! 703: system_fatal("can't write section contents for " ! 704: "section (%s,%s) to output file: %s", ! 705: sp->segname, sp->sectname, output); ! 706: goto objc_runtime_setup_cleanup; ! 707: } ! 708: } ! 709: } ! 710: /* write the segment padding */ ! 711: if(write(outfd, (char *)pad_addr, segs[i].padsize) != ! 712: segs[i].padsize){ ! 713: system_error("can't write segment padding for segment %s to" ! 714: " output file: %s", segs[i].sgp->segname, ! 715: output); ! 716: goto objc_runtime_setup_cleanup; ! 717: } ! 718: } ! 719: else{ ! 720: /* write the original segment */ ! 721: if(strcmp(segs[i].sgp->segname, SEG_LINKEDIT) != 0 || ! 722: i != nsegs - 1){ ! 723: if(segs[i].fileoff + segs[i].sgp->filesize > input_size){ ! 724: error("truncated or malformed object file: %s " ! 725: "(segment: %s extends past the end of " ! 726: "the file)", input, segs[i].sgp->segname); ! 727: goto objc_runtime_setup_cleanup; ! 728: } ! 729: if(write(outfd, (char *)input_addr + segs[i].fileoff, ! 730: segs[i].sgp->filesize) != segs[i].sgp->filesize){ ! 731: system_error("can't write segment contents for " ! 732: "segment: %s to output file: %s", ! 733: segs[i].sgp->segname, output); ! 734: goto objc_runtime_setup_cleanup; ! 735: } ! 736: } ! 737: } ! 738: k += segs[i].sgp->nsects; ! 739: } ! 740: /* write the linkedit info */ ! 741: size = input_size - low_linkedit; ! 742: if(write(outfd, (char *)input_addr + low_linkedit, size) != size){ ! 743: system_error("can't write link edit information to output file: %s", ! 744: output); ! 745: goto objc_runtime_setup_cleanup; ! 746: } ! 747: lseek(outfd, 0, L_SET); ! 748: size = sizeof(struct mach_header) + mhp->sizeofcmds; ! 749: if(swapped){ ! 750: lcp = load_commands; ! 751: for(i = 0; i < mhp->ncmds; i++){ ! 752: lc = *lcp; ! 753: switch(lcp->cmd){ ! 754: case LC_SEGMENT: ! 755: sgp = (struct segment_command *)lcp; ! 756: sp = (struct section *)((char *)sgp + ! 757: sizeof(struct segment_command)); ! 758: swap_section(sp, sgp->nsects, host_byte_order); ! 759: swap_segment_command(sgp, host_byte_order); ! 760: break; ! 761: case LC_SYMTAB: ! 762: stp = (struct symtab_command *)lcp; ! 763: swap_symtab_command(stp, host_byte_order); ! 764: break; ! 765: case LC_SYMSEG: ! 766: ssp = (struct symseg_command *)lcp; ! 767: swap_symseg_command(ssp, host_byte_order); ! 768: break; ! 769: default: ! 770: swap_load_command(lcp, host_byte_order); ! 771: break; ! 772: } ! 773: lcp = (struct load_command *)((char *)lcp + lc.cmdsize); ! 774: } ! 775: swap_mach_header(mhp, host_byte_order); ! 776: } ! 777: ! 778: if(write(outfd, mhp, size) != size){ ! 779: system_error("can't write headers to output file: %s", output); ! 780: goto objc_runtime_setup_cleanup; ! 781: } ! 782: ! 783: if(close(outfd) == -1){ ! 784: system_error("can't close output file: %s", output); ! 785: outfd = -1; ! 786: goto objc_runtime_setup_cleanup; ! 787: } ! 788: ! 789: /* ! 790: if(segs != NULL) ! 791: free(segs); ! 792: if(sects != NULL) ! 793: free(sects); ! 794: if(new_mhp != NULL) ! 795: free(new_mhp); ! 796: if(pad_addr != 0){ ! 797: if((r = vm_deallocate(task_self(), (vm_address_t)pad_addr, ! 798: SEGALIGN)) != KERN_SUCCESS){ ! 799: machkern_error(r, "Can't deallocate segment pad buffer"); ! 800: return(0); ! 801: } ! 802: } ! 803: */ ! 804: return(1); ! 805: ! 806: objc_runtime_setup_cleanup: ! 807: /* ! 808: * Cleanup if there were errors. ! 809: */ ! 810: if(outfd != -1) ! 811: close(outfd); ! 812: if(segs != NULL) ! 813: free(segs); ! 814: if(sects != NULL) ! 815: free(sects); ! 816: if(new_mhp != NULL) ! 817: free(new_mhp); ! 818: if(pad_addr != 0){ ! 819: if((r = vm_deallocate(task_self(), (vm_address_t)pad_addr, ! 820: SEGALIGN)) != KERN_SUCCESS){ ! 821: machkern_error(r, "Can't deallocate segment pad buffer"); ! 822: } ! 823: } ! 824: return(0); ! 825: } ! 826: ! 827: /* ! 828: * Function for qsort for comparing segments vmaddr feilds ! 829: */ ! 830: static ! 831: int ! 832: qsort_vmaddr( ! 833: const struct rep_seg *seg1, ! 834: const struct rep_seg *seg2) ! 835: { ! 836: return((long)(seg1->sgp->vmaddr) - (long)(seg2->sgp->vmaddr)); ! 837: } ! 838: ! 839: /* ! 840: * Function for qsort for comparing segments fileoff fields ! 841: */ ! 842: static ! 843: int ! 844: qsort_fileoff( ! 845: const struct rep_seg *seg1, ! 846: const struct rep_seg *seg2) ! 847: { ! 848: return((long)(seg1->sgp->fileoff) - (long)(seg2->sgp->fileoff)); ! 849: } ! 850: ! 851: /* ! 852: * Function for qsort for comparing sections offset fields ! 853: */ ! 854: static ! 855: int ! 856: qsort_offset( ! 857: const struct rep_sect *sect1, ! 858: const struct rep_sect *sect2) ! 859: { ! 860: return((long)(sect1->sp->offset) - (long)(sect2->sp->offset)); ! 861: } ! 862: ! 863: /* ! 864: * allocate is just a wrapper around malloc that prints and error message and ! 865: * exits if the malloc fails. ! 866: */ ! 867: static ! 868: void * ! 869: allocate( ! 870: long size) ! 871: { ! 872: void *p; ! 873: ! 874: if((p = (void *)malloc(size)) == (char *)0) ! 875: system_fatal("virtual memory exhausted (malloc failed)"); ! 876: return(p); ! 877: } ! 878: ! 879: /* ! 880: * Print the error message and set the non-fatal error indication. ! 881: */ ! 882: static ! 883: void ! 884: error( ! 885: const char *format, ! 886: ...) ! 887: { ! 888: va_list ap; ! 889: ! 890: va_start(ap, format); ! 891: fprintf(stderr, "%s: ", progname); ! 892: vfprintf(stderr, format, ap); ! 893: fprintf(stderr, "\n"); ! 894: va_end(ap); ! 895: } ! 896: ! 897: /* ! 898: * Print the fatal error message, and exit non-zero. ! 899: */ ! 900: static ! 901: void ! 902: fatal( ! 903: const char *format, ! 904: ...) ! 905: { ! 906: va_list ap; ! 907: ! 908: va_start(ap, format); ! 909: fprintf(stderr, "%s: ", progname); ! 910: vfprintf(stderr, format, ap); ! 911: fprintf(stderr, "\n"); ! 912: va_end(ap); ! 913: exit(1); ! 914: } ! 915: ! 916: /* ! 917: * Print the error message along with the system error message, set the ! 918: * non-fatal error indication. ! 919: */ ! 920: static ! 921: void ! 922: system_error( ! 923: const char *format, ! 924: ...) ! 925: { ! 926: va_list ap; ! 927: ! 928: va_start(ap, format); ! 929: fprintf(stderr, "%s: ", progname); ! 930: vfprintf(stderr, format, ap); ! 931: fprintf(stderr, " (%s)\n", strerror(errno)); ! 932: va_end(ap); ! 933: } ! 934: ! 935: /* ! 936: * Print the fatal message along with the system error message, and exit ! 937: * non-zero. ! 938: */ ! 939: static ! 940: void ! 941: system_fatal( ! 942: const char *format, ! 943: ...) ! 944: { ! 945: va_list ap; ! 946: ! 947: va_start(ap, format); ! 948: fprintf(stderr, "%s: ", progname); ! 949: vfprintf(stderr, format, ap); ! 950: fprintf(stderr, " (%s)\n", strerror(errno)); ! 951: va_end(ap); ! 952: exit(1); ! 953: } ! 954: ! 955: /* ! 956: * Print the error message along with the mach error string. ! 957: */ ! 958: static ! 959: void ! 960: machkern_error( ! 961: kern_return_t r, ! 962: char *format, ! 963: ...) ! 964: { ! 965: va_list ap; ! 966: ! 967: va_start(ap, format); ! 968: fprintf(stderr, "%s: ", progname); ! 969: vfprintf(stderr, format, ap); ! 970: fprintf(stderr, " (%s)\n", mach_error_string(r)); ! 971: va_end(ap); ! 972: } ! 973: ! 974: /* ! 975: * Round v to a multiple of r. ! 976: */ ! 977: ! 978: long ! 979: round( ! 980: long v, ! 981: unsigned long r) ! 982: { ! 983: r--; ! 984: v += r; ! 985: v &= ~(long)r; ! 986: return(v); ! 987: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.