lib/libelf/elf_begin.c

   1 /*-
   2  * Copyright (c) 2006,2008 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
  29 #include <sys/types.h>
  30 #include <sys/errno.h>
  31 #if 0
  32 #include <sys/mman.h>
  33 #endif
  34 #include <sys/stat.h>
  35
  36 #include <ar.h>
  37 #include <ctype.h>
  38 #include <errno.h>
  39 #include <libelf.h>
  40 #include <unistd.h>
  41
  42 #include "_libelf.h"
  43
  44 LIBELF_VCSID("$Id$");
  45
  46 static Elf *
  47 _libelf_open_object(int fd, Elf_Cmd c)
  48 {
  49         Elf *e;
  50         void *m;
  51         struct stat sb;
  52
  53         /*
  54          * 'Raw' files are always mapped with 'PROT_READ'.  At
  55          * elf_update(3) time for files opened with ELF_C_RDWR the
  56          * mapping is unmapped, file data is written to using write(2)
  57          * and then the raw data is immediately mapped back in.
  58          */
  59         if (fstat(fd, &sb) < 0) {
  60                 LIBELF_SET_ERROR(IO, errno);
  61                 return (NULL);
  62         }
  63
  64         m = NULL;
  65         if ((m = mmap(NULL, (size_t) sb.st_size, PROT_READ, MAP_PRIVATE, fd,
  66             (off_t) 0)) == MAP_FAILED) {
  67                 LIBELF_SET_ERROR(IO, errno);
  68                 return (NULL);
  69         }
  70
  71         if ((e = elf_memory(m, (size_t) sb.st_size)) == NULL) {
  72                 (void) munmap(m, (size_t) sb.st_size);
  73                 return (NULL);
  74         }
  75
  76         e->e_flags |= LIBELF_F_MMAP;
  77         e->e_fd = fd;
  78         e->e_cmd = c;
  79
  80         if (c == ELF_C_RDWR && e->e_kind == ELF_K_AR) {
  81                 (void) elf_end(e);
  82                 LIBELF_SET_ERROR(ARGUMENT, 0);
  83                 return (NULL);
  84         }
  85
  86         return (e);
  87 }
  88
  89 Elf *
  90 elf_begin(int fd, Elf_Cmd c, Elf *a)
  91 {
  92         Elf *e;
  93
  94         e = NULL;
  95
  96         if (LIBELF_PRIVATE(version) == EV_NONE) {
  97                 LIBELF_SET_ERROR(SEQUENCE, 0);
  98                 return (NULL);
  99         }
 100
 101         switch (c) {
 102         case ELF_C_NULL:
 103                 return (NULL);
 104
 105         case ELF_C_WRITE:
 106
 107                 if (a != NULL) { /* not allowed for ar(1) archives. */
 108                         LIBELF_SET_ERROR(ARGUMENT, 0);
 109                         return (NULL);
 110                 }
 111
 112                 /*
 113                  * Check writeability of `fd' immediately and fail if
 114                  * not writeable.
 115                  */
 116                 if (ftruncate(fd, (off_t) 0) < 0) {
 117                         LIBELF_SET_ERROR(IO, errno);
 118                         return (NULL);
 119                 }
 120
 121                 if ((e = _libelf_allocate_elf()) != NULL) {
 122                         _libelf_init_elf(e, ELF_K_ELF);
 123                         e->e_byteorder = LIBELF_PRIVATE(byteorder);
 124                         e->e_fd = fd;
 125                         e->e_cmd = c;
 126                 }
 127                 return (e);
 128
 129         case ELF_C_RDWR:
 130                 if (a != NULL) { /* not allowed for ar(1) archives. */
 131                         LIBELF_SET_ERROR(ARGUMENT, 0);
 132                         return (NULL);
 133                 }
 134                 /*FALLTHROUGH*/
 135         case ELF_C_READ:
 136                 /*
 137                  * Descriptor `a' could be for a regular ELF file, or
 138                  * for an ar(1) archive.  If descriptor `a' was opened
 139                  * using a valid file descriptor, we need to check if
 140                  * the passed in `fd' value matches the original one.
 141                  */
 142                 if (a &&
 143                     ((a->e_fd != -1 && a->e_fd != fd) || c != a->e_cmd)) {
 144                         LIBELF_SET_ERROR(ARGUMENT, 0);
 145                         return (NULL);
 146                 }
 147                 break;
 148
 149         default:
 150                 LIBELF_SET_ERROR(ARGUMENT, 0);
 151                 return (NULL);
 152
 153         }
 154
 155         if (a == NULL)
 156                 e = _libelf_open_object(fd, c);
 157         else if (a->e_kind == ELF_K_AR)
 158                 e = _libelf_ar_open_member(a->e_fd, c, a);
 159         else
 160                 (e = a)->e_activations++;
 161
 162         return (e);
 163 }