![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach_header.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / mach-o|
Return to mach_header.c CVS log | Up to [Apple XNU] / XNU / osfmk / mach-o |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * File: kern/mach_header.c ! 24: * ! 25: * Functions for accessing mach-o headers. ! 26: * ! 27: * HISTORY ! 28: * 27-MAR-97 Umesh Vaishampayan ([email protected]) ! 29: * Added getsegdatafromheader(); ! 30: * ! 31: * 29-Jan-92 Mike DeMoney ([email protected]) ! 32: * Made into machine independent form from machdep/m68k/mach_header.c. ! 33: * Ifdef'ed out most of this since I couldn't find any references. ! 34: */ ! 35: ! 36: #include <vm/vm_map.h> ! 37: #include <vm/vm_kern.h> ! 38: #include <mach-o/mach_header.h> ! 39: ! 40: #ifdef __MACHO__ ! 41: ! 42: extern struct mach_header _mh_execute_header; ! 43: ! 44: struct section *getsectbynamefromheader( ! 45: struct mach_header *header, ! 46: char *seg_name, ! 47: char *sect_name); ! 48: struct segment_command *getsegbynamefromheader( ! 49: struct mach_header *header, ! 50: char *seg_name); ! 51: ! 52: /* ! 53: * return the last address (first avail) ! 54: */ ! 55: #ifdef MACH_BSD ! 56: __private_extern__ ! 57: #endif ! 58: vm_offset_t getlastaddr(void) ! 59: { ! 60: struct segment_command *sgp; ! 61: vm_offset_t last_addr = 0; ! 62: struct mach_header *header = &_mh_execute_header; ! 63: int i; ! 64: ! 65: sgp = (struct segment_command *) ! 66: ((char *)header + sizeof(struct mach_header)); ! 67: for (i = 0; i < header->ncmds; i++){ ! 68: if ( sgp->cmd == LC_SEGMENT) { ! 69: if (sgp->vmaddr + sgp->vmsize > last_addr) ! 70: last_addr = sgp->vmaddr + sgp->vmsize; ! 71: } ! 72: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 73: } ! 74: return last_addr; ! 75: } ! 76: ! 77: #ifdef XXX_MACH_BSD ! 78: __private_extern__ ! 79: #endif ! 80: struct mach_header ** ! 81: getmachheaders(void) ! 82: { ! 83: extern struct mach_header _mh_execute_header; ! 84: struct mach_header **tl; ! 85: ! 86: if (kmem_alloc(kernel_map, (vm_offset_t *) &tl, 2*sizeof(struct mach_header *)) != KERN_SUCCESS) ! 87: return NULL; ! 88: ! 89: tl[0] = &_mh_execute_header; ! 90: tl[1] = (struct mach_header *)0; ! 91: return tl; ! 92: } ! 93: ! 94: /* ! 95: * This routine returns the a pointer to the data for the named section in the ! 96: * named segment if it exist in the mach header passed to it. Also it returns ! 97: * the size of the section data indirectly through the pointer size. Otherwise ! 98: * it returns zero for the pointer and the size. ! 99: */ ! 100: #ifdef MACH_BSD ! 101: __private_extern__ ! 102: #endif ! 103: void * ! 104: getsectdatafromheader( ! 105: struct mach_header *mhp, ! 106: char *segname, ! 107: char *sectname, ! 108: int *size) ! 109: { ! 110: const struct section *sp; ! 111: void *result; ! 112: ! 113: sp = getsectbynamefromheader(mhp, segname, sectname); ! 114: if(sp == (struct section *)0){ ! 115: *size = 0; ! 116: return((char *)0); ! 117: } ! 118: *size = sp->size; ! 119: result = (void *)sp->addr; ! 120: return result; ! 121: } ! 122: ! 123: /* ! 124: * This routine returns the a pointer to the data for the named segment ! 125: * if it exist in the mach header passed to it. Also it returns ! 126: * the size of the segment data indirectly through the pointer size. ! 127: * Otherwise it returns zero for the pointer and the size. ! 128: */ ! 129: #ifdef MACH_BSD ! 130: __private_extern__ ! 131: #endif ! 132: void * ! 133: getsegdatafromheader( ! 134: struct mach_header *mhp, ! 135: char *segname, ! 136: int *size) ! 137: { ! 138: const struct segment_command *sc; ! 139: void *result; ! 140: ! 141: sc = getsegbynamefromheader(mhp, segname); ! 142: if(sc == (struct segment_command *)0){ ! 143: *size = 0; ! 144: return((char *)0); ! 145: } ! 146: *size = sc->vmsize; ! 147: result = (void *)sc->vmaddr; ! 148: return result; ! 149: } ! 150: ! 151: /* ! 152: * This routine returns the section structure for the named section in the ! 153: * named segment for the mach_header pointer passed to it if it exist. ! 154: * Otherwise it returns zero. ! 155: */ ! 156: #ifdef MACH_BSD ! 157: __private_extern__ ! 158: #endif ! 159: struct section * ! 160: getsectbynamefromheader( ! 161: struct mach_header *mhp, ! 162: char *segname, ! 163: char *sectname) ! 164: { ! 165: struct segment_command *sgp; ! 166: struct section *sp; ! 167: long i, j; ! 168: ! 169: sgp = (struct segment_command *) ! 170: ((char *)mhp + sizeof(struct mach_header)); ! 171: for(i = 0; i < mhp->ncmds; i++){ ! 172: if(sgp->cmd == LC_SEGMENT) ! 173: if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0 || ! 174: mhp->filetype == MH_OBJECT){ ! 175: sp = (struct section *)((char *)sgp + ! 176: sizeof(struct segment_command)); ! 177: for(j = 0; j < sgp->nsects; j++){ ! 178: if(strncmp(sp->sectname, sectname, ! 179: sizeof(sp->sectname)) == 0 && ! 180: strncmp(sp->segname, segname, ! 181: sizeof(sp->segname)) == 0) ! 182: return(sp); ! 183: sp = (struct section *)((char *)sp + ! 184: sizeof(struct section)); ! 185: } ! 186: } ! 187: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 188: } ! 189: return((struct section *)0); ! 190: } ! 191: ! 192: #ifdef MACH_BSD ! 193: __private_extern__ ! 194: #endif ! 195: struct segment_command *getsegbynamefromheader( ! 196: struct mach_header *header, ! 197: char *seg_name) ! 198: { ! 199: struct segment_command *sgp; ! 200: int i; ! 201: ! 202: sgp = (struct segment_command *) ! 203: ((char *)header + sizeof(struct mach_header)); ! 204: for (i = 0; i < header->ncmds; i++){ ! 205: if ( sgp->cmd == LC_SEGMENT ! 206: && !strncmp(sgp->segname, seg_name, sizeof(sgp->segname))) ! 207: return sgp; ! 208: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 209: } ! 210: return (struct segment_command *)0; ! 211: } ! 212: ! 213: ! 214: /* ! 215: * For now at least, all the rest of this seems unused. ! 216: * NOTE: The constant in here for segment alignment is machine-dependent, ! 217: * so if you include this, define a machine dependent constant for it's ! 218: * value. ! 219: */ ! 220: static struct { ! 221: struct segment_command seg; ! 222: struct section sect; ! 223: } fvm_data = { ! 224: { ! 225: LC_SEGMENT, // cmd ! 226: sizeof(fvm_data), // cmdsize ! 227: "__USER", // segname ! 228: 0, // vmaddr ! 229: 0, // vmsize ! 230: 0, // fileoff ! 231: 0, // filesize ! 232: VM_PROT_READ, // maxprot ! 233: VM_PROT_READ, // initprot, ! 234: 1, // nsects ! 235: 0 // flags ! 236: }, ! 237: { ! 238: "", // sectname ! 239: "__USER", // segname ! 240: 0, // addr ! 241: 0, // size ! 242: 0, // offset ! 243: 4, // align ! 244: 0, // reloff ! 245: 0, // nreloc ! 246: 0 // flags ! 247: } ! 248: }; ! 249: ! 250: #ifdef MACH_BSD ! 251: static ! 252: #endif ! 253: struct segment_command *fvm_seg; ! 254: ! 255: static struct fvmfile_command *fvmfilefromheader(struct mach_header *header); ! 256: static vm_offset_t getsizeofmacho(struct mach_header *header); ! 257: ! 258: /* ! 259: * Return the first segment_command in the header. ! 260: */ ! 261: #ifdef MACH_BSD ! 262: __private_extern__ ! 263: #endif ! 264: struct segment_command *firstseg(void) ! 265: { ! 266: return firstsegfromheader(&_mh_execute_header); ! 267: } ! 268: ! 269: #ifdef MACH_BSD ! 270: __private_extern__ ! 271: #endif ! 272: struct segment_command *firstsegfromheader(struct mach_header *header) ! 273: { ! 274: struct segment_command *sgp; ! 275: int i; ! 276: ! 277: sgp = (struct segment_command *) ! 278: ((char *)header + sizeof(struct mach_header)); ! 279: for (i = 0; i < header->ncmds; i++){ ! 280: if (sgp->cmd == LC_SEGMENT) ! 281: return sgp; ! 282: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 283: } ! 284: return (struct segment_command *)0; ! 285: } ! 286: ! 287: #ifdef MACH_BSD ! 288: __private_extern__ ! 289: #endif ! 290: struct segment_command *nextseg(struct segment_command *sgp) ! 291: { ! 292: struct segment_command *this; ! 293: ! 294: this = nextsegfromheader(&_mh_execute_header, sgp); ! 295: ! 296: /* ! 297: * For the kernel's header add on the faked segment for the ! 298: * USER boot code identified by a FVMFILE_COMMAND in the mach header. ! 299: */ ! 300: if (!this && sgp != fvm_seg) ! 301: this = fvm_seg; ! 302: ! 303: return this; ! 304: } ! 305: ! 306: #ifdef MACH_BSD ! 307: __private_extern__ ! 308: #endif ! 309: struct segment_command *nextsegfromheader( ! 310: struct mach_header *header, ! 311: struct segment_command *seg) ! 312: { ! 313: struct segment_command *sgp; ! 314: int i; ! 315: ! 316: sgp = (struct segment_command *) ! 317: ((char *)header + sizeof(struct mach_header)); ! 318: for (i = 0; i < header->ncmds; i++) { ! 319: if (sgp == seg) ! 320: break; ! 321: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 322: } ! 323: ! 324: if (i == header->ncmds) ! 325: return (struct segment_command *)0; ! 326: ! 327: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 328: for (; i < header->ncmds; i++) { ! 329: if (sgp->cmd == LC_SEGMENT) ! 330: return sgp; ! 331: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 332: } ! 333: ! 334: return (struct segment_command *)0; ! 335: } ! 336: ! 337: ! 338: /* ! 339: * Return the address of the named Mach-O segment, or NULL. ! 340: */ ! 341: #ifdef MACH_BSD ! 342: __private_extern__ ! 343: #endif ! 344: struct segment_command *getsegbyname(char *seg_name) ! 345: { ! 346: struct segment_command *this; ! 347: ! 348: this = getsegbynamefromheader(&_mh_execute_header, seg_name); ! 349: ! 350: /* ! 351: * For the kernel's header add on the faked segment for the ! 352: * USER boot code identified by a FVMFILE_COMMAND in the mach header. ! 353: */ ! 354: if (!this && strcmp(seg_name, fvm_seg->segname) == 0) ! 355: this = fvm_seg; ! 356: ! 357: return this; ! 358: } ! 359: ! 360: /* ! 361: * This routine returns the a pointer the section structure of the named ! 362: * section in the named segment if it exist in the mach executable it is ! 363: * linked into. Otherwise it returns zero. ! 364: */ ! 365: #ifdef MACH_BSD ! 366: __private_extern__ ! 367: #endif ! 368: struct section * ! 369: getsectbyname( ! 370: char *segname, ! 371: char *sectname) ! 372: { ! 373: return(getsectbynamefromheader( ! 374: (struct mach_header *)&_mh_execute_header, segname, sectname)); ! 375: } ! 376: ! 377: #ifdef MACH_BSD ! 378: __private_extern__ ! 379: #endif ! 380: struct section *firstsect(struct segment_command *sgp) ! 381: { ! 382: struct section *sp; ! 383: ! 384: if (!sgp || sgp->nsects == 0) ! 385: return (struct section *)0; ! 386: ! 387: return (struct section *)(sgp+1); ! 388: } ! 389: ! 390: #ifdef MACH_BSD ! 391: __private_extern__ ! 392: #endif ! 393: struct section *nextsect(struct segment_command *sgp, struct section *sp) ! 394: { ! 395: struct section *fsp = firstsect(sgp); ! 396: ! 397: if (sp - fsp >= sgp->nsects-1) ! 398: return (struct section *)0; ! 399: ! 400: return sp+1; ! 401: } ! 402: ! 403: static struct fvmfile_command *fvmfilefromheader(struct mach_header *header) ! 404: { ! 405: struct fvmfile_command *fvp; ! 406: int i; ! 407: ! 408: fvp = (struct fvmfile_command *) ! 409: ((char *)header + sizeof(struct mach_header)); ! 410: for (i = 0; i < header->ncmds; i++){ ! 411: if (fvp->cmd == LC_FVMFILE) ! 412: return fvp; ! 413: fvp = (struct fvmfile_command *)((char *)fvp + fvp->cmdsize); ! 414: } ! 415: return (struct fvmfile_command *)0; ! 416: } ! 417: ! 418: /* ! 419: * Create a fake USER seg if a fvmfile_command is present. ! 420: */ ! 421: #ifdef MACH_BSD ! 422: __private_extern__ ! 423: #endif ! 424: struct segment_command *getfakefvmseg(void) ! 425: { ! 426: struct segment_command *sgp = getsegbyname("__USER"); ! 427: struct fvmfile_command *fvp = fvmfilefromheader(&_mh_execute_header); ! 428: struct section *sp; ! 429: ! 430: if (sgp) ! 431: return sgp; ! 432: ! 433: if (!fvp) ! 434: return (struct segment_command *)0; ! 435: ! 436: fvm_seg = &fvm_data.seg; ! 437: sgp = fvm_seg; ! 438: sp = &fvm_data.sect; ! 439: ! 440: sgp->vmaddr = fvp->header_addr; ! 441: sgp->vmsize = getsizeofmacho((struct mach_header *)(sgp->vmaddr)); ! 442: ! 443: strcpy(sp->sectname, fvp->name.ptr); ! 444: sp->addr = sgp->vmaddr; ! 445: sp->size = sgp->vmsize; ! 446: ! 447: #if DEBUG ! 448: printf("fake fvm seg __USER/\"%s\" at 0x%x, size 0x%x\n", ! 449: sp->sectname, sp->addr, sp->size); ! 450: #endif /*DEBUG*/ ! 451: return sgp; ! 452: } ! 453: ! 454: /* ! 455: * Figure out the size the size of the data associated with a ! 456: * loaded mach_header. ! 457: */ ! 458: static vm_offset_t getsizeofmacho(struct mach_header *header) ! 459: { ! 460: struct segment_command *sgp; ! 461: struct section *sp; ! 462: vm_offset_t last_addr; ! 463: ! 464: last_addr = 0; ! 465: for ( sgp = firstsegfromheader(header) ! 466: ; sgp ! 467: ; sgp = nextsegfromheader(header, sgp)) ! 468: { ! 469: if (sgp->fileoff + sgp->filesize > last_addr) ! 470: last_addr = sgp->fileoff + sgp->filesize; ! 471: } ! 472: ! 473: return last_addr; ! 474: } ! 475: ! 476: #ifdef MACH_KDB ! 477: /* ! 478: * This routine returns the section command for the symbol table in the ! 479: * named segment for the mach_header pointer passed to it if it exist. ! 480: * Otherwise it returns zero. ! 481: */ ! 482: struct symtab_command * ! 483: getsectcmdsymtabfromheader( ! 484: struct mach_header *mhp) ! 485: { ! 486: struct segment_command *sgp; ! 487: struct section *sp; ! 488: long i; ! 489: ! 490: sgp = (struct segment_command *) ! 491: ((char *)mhp + sizeof(struct mach_header)); ! 492: for(i = 0; i < mhp->ncmds; i++){ ! 493: if(sgp->cmd == LC_SYMTAB) ! 494: return((struct symtab_command *)sgp); ! 495: sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); ! 496: } ! 497: return(NULL); ! 498: } ! 499: ! 500: boolean_t getsymtab(struct mach_header *header, ! 501: vm_offset_t *symtab, ! 502: int *nsyms, ! 503: vm_offset_t *strtab, ! 504: vm_size_t *strtabsize) ! 505: { ! 506: struct segment_command *seglink_cmd; ! 507: struct symtab_command *symtab_cmd; ! 508: ! 509: seglink_cmd = NULL; ! 510: ! 511: if(header->magic != MH_MAGIC) { /* Check if this is a valid header format */ ! 512: printf("Attempt to use invalid header (magic = %08X) to find symbol table\n", ! 513: header->magic); /* Tell them what's wrong */ ! 514: return (FALSE); /* Bye y'all... */ ! 515: } ! 516: ! 517: seglink_cmd = getsegbynamefromheader(header,"__LINKEDIT"); ! 518: if (seglink_cmd == NULL) { ! 519: return(FALSE); ! 520: } ! 521: ! 522: symtab_cmd = NULL; ! 523: symtab_cmd = getsectcmdsymtabfromheader(header); ! 524: if (symtab_cmd == NULL) ! 525: return(FALSE); ! 526: ! 527: *nsyms = symtab_cmd->nsyms; ! 528: if(symtab_cmd->nsyms == 0) return (FALSE); /* No symbols */ ! 529: ! 530: *strtabsize = symtab_cmd->strsize; ! 531: if(symtab_cmd->strsize == 0) return (FALSE); /* Symbol length is 0 */ ! 532: ! 533: *symtab = seglink_cmd->vmaddr + symtab_cmd->symoff - ! 534: seglink_cmd->fileoff; ! 535: ! 536: *strtab = seglink_cmd->vmaddr + symtab_cmd->stroff - ! 537: seglink_cmd->fileoff; ! 538: ! 539: return(TRUE); ! 540: } ! 541: #endif ! 542: ! 543: #else ! 544: ! 545: void * getsegdatafromheader( struct mach_header *mhp, char *segname, int *size) ! 546: { ! 547: return 0; ! 548: } ! 549: ! 550: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.