lib/libelf/elf_begin.c

   1 /*-
   2  * Copyright (c) 2006 Joseph Koshy
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/types.h>
  31 #include <sys/errno.h>
  32 #include <sys/mman.h>
  33 #include <sys/stat.h>
  34
  35 #include <ar.h>
  36 #include <ctype.h>
  37 #include <libelf.h>
  38 #include <unistd.h>
  39
  40 #include "_libelf.h"
  41
  42 static Elf *
  43 _libelf_open_object(int fd, Elf_Cmd c)
  44 {
  45         Elf *e;
  46         void *m;
  47         struct stat sb;
  48
  49         /*
  50          * 'Raw' files are always mapped with 'PROT_READ'.  At
  51          * elf_update(3) time for files opened with ELF_C_RDWR the
  52          * mapping is unmapped, file data is written to using write(2)
  53          * and then the raw data is immediately mapped back in.
  54          */
  55         if (fstat(fd, &sb) < 0) {
  56                 LIBELF_SET_ERROR(IO, errno);
  57                 return (NULL);
  58         }
  59
  60         m = NULL;
  61         if ((m = mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_PRIVATE, fd,
  62             (off_t) 0)) == MAP_FAILED) {
  63                 LIBELF_SET_ERROR(IO, errno);
  64                 return (NULL);
  65         }
  66
  67         if ((e = elf_memory(m, (size_t) sb.st_size)) == NULL) {
  68                 (void) munmap(m, (size_t) sb.st_size);
  69                 return (NULL);
  70         }
  71
  72         e->e_flags |= LIBELF_F_MMAP;
  73         e->e_fd = fd;
  74         e->e_cmd = c;
  75
  76         if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
  77                 (void) elf_end(e);
  78                 LIBELF_SET_ERROR(ARGUMENT, 0);
  79                 return (NULL);
  80         }
  81
  82         return (e);
  83 }
  84
  85 Elf *
  86 elf_begin(int fd, Elf_Cmd c, Elf *a)
  87 {
  88         Elf *e;
  89
  90         e = NULL;
  91
  92         if (LIBELF_PRIVATE(version) == EV_NONE) {
  93                 LIBELF_SET_ERROR(SEQUENCE, 0);
  94                 return (NULL);
  95         }
  96
  97         switch (c) {
  98         case ELF_C_NULL:
  99                 return (NULL);
 100
 101         case ELF_C_WRITE:
 102
 103                 if (a != NULL) { /* not allowed for ar(1) archives. */
 104                         LIBELF_SET_ERROR(ARGUMENT, 0);
 105                         return (NULL);
 106                 }
 107
 108                 /*
 109                  * Check writeability of `fd' immediately and fail if
 110                  * not writeable.
 111                  */
 112                 if (ftruncate(fd, (off_t) 0) < 0) {
 113                         LIBELF_SET_ERROR(IO, errno);
 114                         return (NULL);
 115                 }
 116
 117                 if ((e = _libelf_allocate_elf()) != NULL) {
 118                         _libelf_init_elf(e, ELF_K_ELF);
 119                         e->e_byteorder = LIBELF_PRIVATE(byteorder);
 120                         e->e_fd = fd;
 121                         e->e_cmd = c;
 122                 }
 123                 return (e);
 124
 125         case ELF_C_RDWR:
 126                 if (a != NULL) { /* not allowed for ar(1) archives. */
 127                         LIBELF_SET_ERROR(ARGUMENT, 0);
 128                         return (NULL);
 129                 }
 130                 /*FALLTHROUGH*/
 131         case ELF_C_READ:
 132                 /*
 133                  * Descriptor `a' could be for a regular ELF file, or
 134                  * for an ar(1) archive.  If descriptor `a' was opened
 135                  * using a valid file descriptor, we need to check if
 136                  * the passed in `fd' value matches the original one.
 137                  */
 138                 if (a &&
 139                     ((a->e_fd != -1 && a->e_fd != fd) || c != a->e_cmd)) {
 140                         LIBELF_SET_ERROR(ARGUMENT, 0);
 141                         return (NULL);
 142                 }
 143                 break;
 144
 145         default:
 146                 LIBELF_SET_ERROR(ARGUMENT, 0);
 147                 return (NULL);
 148
 149         }
 150
 151         if (a == NULL)
 152                 e = _libelf_open_object(fd, c);
 153         else if (a->e_kind == ELF_K_AR)
 154                 e = _libelf_ar_open_member(a->e_fd, c, a);
 155         else
 156                 (e = a)->e_activations++;
 157
 158         return (e);
 159 }