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 <ar.h>
31 #include <assert.h>
32 #include <ctype.h>
33 #include <libelf.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #include "_libelf.h"
38
39 #define LIBELF_NALLOC_SIZE 16
40
41 /*
42 * `ar' archive handling.
43 *
44 * `ar' archives start with signature `ARMAG'. Each archive member is
45 * preceded by a header containing meta-data for the member. This
46 * header is described in <ar.h> (struct ar_hdr). The header always
47 * starts on an even address. File data is padded with "\n"
48 * characters to keep this invariant.
49 *
50 * Special considerations for `ar' archives:
51 *
52 * The `ar' header only has space for a 16 character file name. File
53 * names are terminated with a '/', so this effectively leaves 15
54 * characters for the actual file name. In order to accomodate longer
55 * file names, names may be stored in a separate 'string table' and
56 * referenced indirectly by a member header. The string table itself
57 * appears as an archive member with name "// ". An indirect file name
58 * in an `ar' header matches the pattern "/[0-9]*". The digits form a
59 * decimal number that corresponds to a byte offset into the string
60 * table where the actual file name of the object starts. Strings in
61 * the string table are padded to start on even addresses.
62 *
63 * Archives may also have a symbol table (see ranlib(1)), mapping
64 * program symbols to object files inside the archive. A symbol table
65 * uses a file name of "/ " in its archive header. The symbol table
66 * is structured as:
67 * - a 4-byte count of entries stored as a binary value, MSB first
68 * - 'n' 4-byte offsets, stored as binary values, MSB first
69 * - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
70 *
71 * If the symbol table and string table are is present in an archive
72 * they must be the very first objects and in that order.
73 */
74
75
76
77 Elf_Arhdr *
_libelf_ar_gethdr(Elf * e)78 _libelf_ar_gethdr(Elf *e)
79 {
80 Elf *parent;
81 struct ar_hdr *arh;
82 Elf_Arhdr *eh;
83 size_t n;
84
85 if ((parent = e->e_parent) == NULL) {
86 LIBELF_SET_ERROR(ARGUMENT, 0);
87 return (NULL);
88 }
89
90 arh = (struct ar_hdr *) ((uintptr_t) e->e_rawfile - sizeof(struct ar_hdr));
91
92 assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
93 assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + parent->e_rawsize -
94 sizeof(struct ar_hdr));
95
96 if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
97 LIBELF_SET_ERROR(RESOURCE, 0);
98 return (NULL);
99 }
100
101 e->e_arhdr = eh;
102 eh->ar_name = eh->ar_rawname = NULL;
103
104 if ((eh->ar_name = _libelf_ar_get_name(arh->ar_name, sizeof(arh->ar_name),
105 parent)) == NULL)
106 goto error;
107
108 if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, &n) == 0)
109 goto error;
110 eh->ar_uid = (uid_t) n;
111
112 if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, &n) == 0)
113 goto error;
114 eh->ar_gid = (gid_t) n;
115
116 if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, &n) == 0)
117 goto error;
118 eh->ar_mode = (mode_t) n;
119
120 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &n) == 0)
121 goto error;
122 eh->ar_size = n;
123
124 if ((eh->ar_rawname = _libelf_ar_get_string(arh->ar_name,
125 sizeof(arh->ar_name), 1)) == NULL)
126 goto error;
127
128 return (eh);
129
130 error:
131 if (eh) {
132 if (eh->ar_name)
133 free(eh->ar_name);
134 if (eh->ar_rawname)
135 free(eh->ar_rawname);
136 free(eh);
137 }
138 e->e_arhdr = NULL;
139
140 return (NULL);
141 }
142
143 Elf *
_libelf_ar_open_member(int fd,Elf_Cmd c,Elf * elf)144 _libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
145 {
146 Elf *e;
147 off_t next;
148 struct ar_hdr *arh;
149 size_t sz;
150
151 assert(elf->e_kind == ELF_K_AR);
152
153 next = elf->e_u.e_ar.e_next;
154
155 /*
156 * `next' is only set to zero by elf_next() when the last
157 * member of an archive is processed.
158 */
159 if (next == (off_t) 0)
160 return (NULL);
161
162 assert((next & 1) == 0);
163
164 arh = (struct ar_hdr *) (elf->e_rawfile + next);
165
166 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &sz) == 0) {
167 LIBELF_SET_ERROR(ARCHIVE, 0);
168 return (NULL);
169 }
170
171 assert(sz > 0);
172
173 arh++; /* skip over archive member header */
174
175 if ((e = elf_memory((char *) arh, sz)) == NULL)
176 return (NULL);
177
178 e->e_fd = fd;
179 e->e_cmd = c;
180
181 elf->e_u.e_ar.e_nchildren++;
182 e->e_parent = elf;
183
184 return (e);
185 }
186
187 /*
188 * An ar(1) symbol table has the following layout:
189 *
190 * The first 4 bytes are a binary count of the number of entries in the
191 * symbol table, stored MSB-first.
192 *
193 * Then there are 'n' 4-byte binary offsets, also stored MSB first.
194 *
195 * Following this, there are 'n' null-terminated strings.
196 */
197
198 #define GET_WORD(P, V) do { \
199 (V) = 0; \
200 (V) = (P)[0]; (V) <<= 8; \
201 (V) += (P)[1]; (V) <<= 8; \
202 (V) += (P)[2]; (V) <<= 8; \
203 (V) += (P)[3]; \
204 } while (0)
205
206 #define INTSZ 4
207
208 Elf_Arsym *
_libelf_ar_process_symtab(Elf * e,size_t * count)209 _libelf_ar_process_symtab(Elf *e, size_t *count)
210 {
211 size_t n, nentries, off;
212 Elf_Arsym *symtab, *sym;
213 unsigned char *p, *s, *end;
214
215 assert(e != NULL);
216 assert(count != NULL);
217
218 if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) {
219 LIBELF_SET_ERROR(ARCHIVE, 0);
220 return (NULL);
221 }
222
223 p = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
224 end = p + e->e_u.e_ar.e_rawsymtabsz;
225
226 GET_WORD(p, nentries);
227 p += INTSZ;
228
229 if (nentries == 0 || p + nentries * INTSZ >= end) {
230 LIBELF_SET_ERROR(ARCHIVE, 0);
231 return (NULL);
232 }
233
234 /* Allocate space for a nentries + a sentinel. */
235 if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
236 LIBELF_SET_ERROR(RESOURCE, 0);
237 return (NULL);
238 }
239
240 s = p + (nentries * INTSZ); /* start of the string table. */
241
242 for (n = nentries, sym = symtab; n > 0; n--) {
243 off = 0;
244
245 GET_WORD(p, off);
246
247 sym->as_off = off;
248 sym->as_hash = elf_hash(s);
249 sym->as_name = s;
250
251 p += INTSZ;
252 sym++;
253
254 for (; s < end && *s++ != '\0';) /* skip to next string */
255 ;
256 if (s > end) {
257 LIBELF_SET_ERROR(ARCHIVE, 0);
258 free(symtab);
259 return (NULL);
260 }
261 }
262
263 /* Fill up the sentinel entry. */
264 sym->as_name = NULL;
265 sym->as_hash = ~0UL;
266 sym->as_off = (off_t) 0;
267
268 *count = e->e_u.e_ar.e_symtabsz = nentries + 1;
269 e->e_u.e_ar.e_symtab = symtab;
270
271 return (symtab);
272 }
273