Elf * elf_memory(char *image, size_t sz) { Elf *e; if (LIBELF_PRIVATE(version) == EV_NONE) { LIBELF_SET_ERROR(SEQUENCE, 0); return (NULL); } if (image == NULL || sz == 0) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } if ((e = _libelf_allocate_elf()) == NULL) return (NULL); e->e_cmd = ELF_C_READ; e->e_rawfile = image; e->e_rawsize = sz; #undef LIBELF_IS_ELF #define LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 && \ (P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 && \ (P)[EI_MAG3] == ELFMAG3) if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) { _libelf_init_elf(e, ELF_K_ELF); e->e_class = image[EI_CLASS]; e->e_byteorder = image[EI_DATA]; e->e_version = image[EI_VERSION]; if (e->e_version > EV_CURRENT) { e = _libelf_release_elf(e); LIBELF_SET_ERROR(VERSION, 0); return (NULL); } if ((e->e_byteorder != ELFDATA2LSB && e->e_byteorder != ELFDATA2MSB) || (e->e_class != ELFCLASS32 && e->e_class != ELFCLASS64)) { e = _libelf_release_elf(e); LIBELF_SET_ERROR(HEADER, 0); return (NULL); } } else if (sz >= SARMAG && strncmp(image, ARMAG, (size_t) SARMAG) == 0) { _libelf_init_elf(e, ELF_K_AR); e = _libelf_ar_open(e); } else _libelf_init_elf(e, ELF_K_NONE); return (e); }
Elf * _libelf_memory(char *image, size_t sz, int reporterror) { Elf *e; int e_class; enum Elf_Error error; unsigned int e_byteorder, e_version; assert(image != NULL); assert(sz > 0); if ((e = _libelf_allocate_elf()) == NULL) return (NULL); e->e_cmd = ELF_C_READ; e->e_rawfile = image; e->e_rawsize = sz; #undef LIBELF_IS_ELF #define LIBELF_IS_ELF(P) ((P)[EI_MAG0] == ELFMAG0 && \ (P)[EI_MAG1] == ELFMAG1 && (P)[EI_MAG2] == ELFMAG2 && \ (P)[EI_MAG3] == ELFMAG3) if (sz > EI_NIDENT && LIBELF_IS_ELF(image)) { e_byteorder = image[EI_DATA]; e_class = image[EI_CLASS]; e_version = image[EI_VERSION]; error = ELF_E_NONE; if (e_version > EV_CURRENT) error = ELF_E_VERSION; else if ((e_byteorder != ELFDATA2LSB && e_byteorder != ELFDATA2MSB) || (e_class != ELFCLASS32 && e_class != ELFCLASS64)) error = ELF_E_HEADER; if (error != ELF_E_NONE) { if (reporterror) { LIBELF_PRIVATE(error) = LIBELF_ERROR(error, 0); (void) _libelf_release_elf(e); return (NULL); } } else { _libelf_init_elf(e, ELF_K_ELF); e->e_byteorder = e_byteorder; e->e_class = e_class; e->e_version = e_version; } } else if (sz >= SARMAG && strncmp(image, ARMAG, (size_t) SARMAG) == 0) return (_libelf_ar_open(e, reporterror)); return (e); }
Elf * elf_begin(int fd, Elf_Cmd c, Elf *a) { Elf *e; e = NULL; if (LIBELF_PRIVATE(version) == EV_NONE) { LIBELF_SET_ERROR(SEQUENCE, 0); return (NULL); } switch (c) { case ELF_C_NULL: return (NULL); case ELF_C_WRITE: if (a != NULL) { /* not allowed for ar(1) archives. */ LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } /* * Check writeability of `fd' immediately and fail if * not writeable. */ if (ftruncate(fd, (off_t) 0) < 0) { LIBELF_SET_ERROR(IO, errno); return (NULL); } if ((e = _libelf_allocate_elf()) != NULL) { _libelf_init_elf(e, ELF_K_ELF); e->e_byteorder = LIBELF_PRIVATE(byteorder); e->e_fd = fd; e->e_cmd = c; } return (e); case ELF_C_RDWR: if (a != NULL) { /* not allowed for ar(1) archives. */ LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } /*FALLTHROUGH*/ case ELF_C_READ: /* * Descriptor `a' could be for a regular ELF file, or * for an ar(1) archive. */ if (a && (a->e_fd != fd || c != a->e_cmd)) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } break; default: LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } if (a == NULL) e = _libelf_open_object(fd, c); else if (a->e_kind == ELF_K_AR) e = _libelf_ar_open_member(fd, c, a); else (e = a)->e_activations++; return (e); }
Elf * _libelf_open_object(int fd, Elf_Cmd c, int reporterror) { Elf *e; void *m; mode_t mode; size_t fsize; struct stat sb; unsigned int flags; assert(c == ELF_C_READ || c == ELF_C_RDWR || c == ELF_C_WRITE); if (fstat(fd, &sb) < 0) { LIBELF_SET_ERROR(IO, errno); return (NULL); } mode = sb.st_mode; fsize = (size_t) sb.st_size; /* * Reject unsupported file types. */ if (!S_ISREG(mode) && !S_ISCHR(mode) && !S_ISFIFO(mode) && !S_ISSOCK(mode)) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } /* * For ELF_C_WRITE mode, allocate and return a descriptor. */ if (c == ELF_C_WRITE) { if ((e = _libelf_allocate_elf()) != NULL) { _libelf_init_elf(e, ELF_K_ELF); e->e_byteorder = LIBELF_PRIVATE(byteorder); e->e_fd = fd; e->e_cmd = c; if (!S_ISREG(mode)) e->e_flags |= LIBELF_F_SPECIAL_FILE; } return (e); } /* * ELF_C_READ and ELF_C_RDWR mode. */ m = NULL; flags = 0; if (S_ISREG(mode)) { /* * Reject zero length files. */ if (fsize == 0) { LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } #if ELFTC_HAVE_MMAP /* * Always map regular files in with 'PROT_READ' * permissions. * * For objects opened in ELF_C_RDWR mode, when * elf_update(3) is called, we remove this mapping, * write file data out using write(2), and map the new * contents back. */ m = mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, (off_t) 0); if (m == MAP_FAILED) m = NULL; else flags = LIBELF_F_RAWFILE_MMAP; #endif /* * Fallback to a read() if the call to mmap() failed, * or if mmap() is not available. */ if (m == NULL) { if ((m = malloc(fsize)) == NULL) { LIBELF_SET_ERROR(RESOURCE, 0); return (NULL); } if (read(fd, m, fsize) != (ssize_t) fsize) { LIBELF_SET_ERROR(IO, errno); free(m); return (NULL); } flags = LIBELF_F_RAWFILE_MALLOC; } } else if ((m = _libelf_read_special_file(fd, &fsize)) != NULL) flags = LIBELF_F_RAWFILE_MALLOC | LIBELF_F_SPECIAL_FILE; else return (NULL); if ((e = _libelf_memory(m, fsize, reporterror)) == NULL) { assert((flags & LIBELF_F_RAWFILE_MALLOC) || (flags & LIBELF_F_RAWFILE_MMAP)); if (flags & LIBELF_F_RAWFILE_MALLOC) free(m); #if ELFTC_HAVE_MMAP else (void) munmap(m, fsize); #endif return (NULL); } /* ar(1) archives aren't supported in RDWR mode. */ if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) { (void) elf_end(e); LIBELF_SET_ERROR(ARGUMENT, 0); return (NULL); } e->e_flags |= flags; e->e_fd = fd; e->e_cmd = c; return (e); }