gelf_ehdr.c revision 4484:7c56a6c9c265 
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 <limits.h>
28
29#include <assert.h>
30#include "gelf.h"
31#include "libelf.h"
32#include <string.h>
33
34#include "_libelf.h"
35
36Elf32_Ehdr *
37elf32_getehdr(Elf *e)
38{
39        return (_libelf_ehdr(e, ELFCLASS32, 0));
40}
41
42Elf64_Ehdr *
43elf64_getehdr(Elf *e)
44{
45        return (_libelf_ehdr(e, ELFCLASS64, 0));
46}
47
48GElf_Ehdr *
49gelf_getehdr(Elf *e, GElf_Ehdr *d)
50{
51        int ec;
52        Elf32_Ehdr *eh32;
53        Elf64_Ehdr *eh64;
54
55        if (d == NULL || e == NULL ||
56            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
57                LIBELF_SET_ERROR(ARGUMENT, 0);
58                return (NULL);
59        }
60
61        if (ec == ELFCLASS32) {
62                if ((eh32 = _libelf_ehdr(e, ELFCLASS32, 0)) == NULL)
63                        return (NULL);
64
65                (void) memcpy(d->e_ident, eh32->e_ident, sizeof(eh32->e_ident));
66                d->e_type		= eh32->e_type;
67                d->e_machine		= eh32->e_machine;
68                d->e_version		= eh32->e_version;
69                d->e_entry		= eh32->e_entry;
70                d->e_phoff		= eh32->e_phoff;
71                d->e_shoff		= eh32->e_shoff;
72                d->e_flags		= eh32->e_flags;
73                d->e_ehsize		= eh32->e_ehsize;
74                d->e_phentsize		= eh32->e_phentsize;
75                d->e_phnum		= eh32->e_phnum;
76                d->e_shentsize		= eh32->e_shentsize;
77                d->e_shnum		= eh32->e_shnum;
78                d->e_shstrndx		= eh32->e_shstrndx;
79
80                return (d);
81        }
82
83        assert(ec == ELFCLASS64);
84
85        if ((eh64 = _libelf_ehdr(e, ELFCLASS64, 0)) == NULL)
86                return (NULL);
87        *d = *eh64;
88
89        return (d);
90}
91
92Elf32_Ehdr *
93elf32_newehdr(Elf *e)
94{
95        return (_libelf_ehdr(e, ELFCLASS32, 1));
96}
97
98Elf64_Ehdr *
99elf64_newehdr(Elf *e)
100{
101        return (_libelf_ehdr(e, ELFCLASS64, 1));
102}
103
104void *
105gelf_newehdr(Elf *e, int ec)
106{
107        if (e != NULL &&
108            (ec == ELFCLASS32 || ec == ELFCLASS64))
109                return (_libelf_ehdr(e, ec, 1));
110
111        LIBELF_SET_ERROR(ARGUMENT, 0);
112        return (NULL);
113}
114
115int
116gelf_update_ehdr(Elf *e, GElf_Ehdr *s)
117{
118        int ec;
119        void *ehdr;
120        Elf32_Ehdr *eh32;
121        Elf64_Ehdr *eh64;
122
123        if (s== NULL || e == NULL || e->e_kind != ELF_K_ELF ||
124            ((ec = e->e_class) != ELFCLASS32 && ec != ELFCLASS64)) {
125                LIBELF_SET_ERROR(ARGUMENT, 0);
126                return (0);
127        }
128
129        if (e->e_cmd == ELF_C_READ) {
130                LIBELF_SET_ERROR(MODE, 0);
131                return (0);
132        }
133
134        if ((ehdr = _libelf_ehdr(e, ec, 0)) == NULL)
135                return (0);
136
137        if (ec == ELFCLASS64) {
138                eh64 = (Elf64_Ehdr *) ehdr;
139                *eh64 = *s;
140                return (1);
141        }
142
143        eh32 = (Elf32_Ehdr *) ehdr;
144
145        (void) memcpy(eh32->e_ident, s->e_ident, sizeof(eh32->e_ident));
146
147        eh32->e_type      = s->e_type;
148        eh32->e_machine   = s->e_machine;
149        eh32->e_version   = s->e_version;
150        LIBELF_COPY_U32(eh32, s, e_entry);
151        LIBELF_COPY_U32(eh32, s, e_phoff);
152        LIBELF_COPY_U32(eh32, s, e_shoff);
153        eh32->e_flags     = s->e_flags;
154        eh32->e_ehsize    = s->e_ehsize;
155        eh32->e_phentsize = s->e_phentsize;
156        eh32->e_phnum     = s->e_phnum;
157        eh32->e_shentsize = s->e_shentsize;
158        eh32->e_shnum     = s->e_shnum;
159        eh32->e_shstrndx  = s->e_shstrndx;
160
161        (void) elf_flagehdr(e, ELF_C_SET, ELF_F_DIRTY);
162
163        return (1);
164}
165