1 | /*- |
---|
2 | * Copyright (c) 2006,2008,2010 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 <assert.h> |
---|
30 | #include <ctype.h> |
---|
31 | #include <libelf.h> |
---|
32 | #include <stdlib.h> |
---|
33 | #include <string.h> |
---|
34 | |
---|
35 | #include "_libelf.h" |
---|
36 | #include "_libelf_ar.h" |
---|
37 | |
---|
38 | LIBELF_VCSID("$Id$"); |
---|
39 | |
---|
40 | #define LIBELF_NALLOC_SIZE 16 |
---|
41 | |
---|
42 | /* |
---|
43 | * `ar' archive handling. |
---|
44 | * |
---|
45 | * `ar' archives start with signature `ARMAG'. Each archive member is |
---|
46 | * preceded by a header containing meta-data for the member. This |
---|
47 | * header is described in <ar.h> (struct ar_hdr). The header always |
---|
48 | * starts on an even address. File data is padded with "\n" |
---|
49 | * characters to keep this invariant. |
---|
50 | * |
---|
51 | * Special considerations for `ar' archives: |
---|
52 | * |
---|
53 | * There are two variants of the `ar' archive format: traditional BSD |
---|
54 | * and SVR4. These differ in the way long file names are treated, and |
---|
55 | * in the layout of the archive symbol table. |
---|
56 | * |
---|
57 | * The `ar' header only has space for a 16 character file name. |
---|
58 | * |
---|
59 | * In the SVR4 format, file names are terminated with a '/', so this |
---|
60 | * effectively leaves 15 characters for the actual file name. Longer |
---|
61 | * file names stored in a separate 'string table' and referenced |
---|
62 | * indirectly from the name field. The string table itself appears as |
---|
63 | * an archive member with name "// ". An `indirect' file name in an |
---|
64 | * `ar' header matches the pattern "/[0-9]*". The digits form a |
---|
65 | * decimal number that corresponds to a byte offset into the string |
---|
66 | * table where the actual file name of the object starts. Strings in |
---|
67 | * the string table are padded to start on even addresses. |
---|
68 | * |
---|
69 | * In the BSD format, file names can be upto 16 characters. File |
---|
70 | * names shorter than 16 characters are padded to 16 characters using |
---|
71 | * (ASCII) space characters. File names with embedded spaces and file |
---|
72 | * names longer than 16 characters are stored immediately after the |
---|
73 | * archive header and the name field set to a special indirect name |
---|
74 | * matching the pattern "#1/[0-9]+". The digits form a decimal number |
---|
75 | * that corresponds to the actual length of the file name following |
---|
76 | * the archive header. The content of the archive member immediately |
---|
77 | * follows the file name, and the size field of the archive member |
---|
78 | * holds the sum of the sizes of the member and of the appended file |
---|
79 | * name. |
---|
80 | * |
---|
81 | * Archives may also have a symbol table (see ranlib(1)), mapping |
---|
82 | * program symbols to object files inside the archive. |
---|
83 | * |
---|
84 | * In the SVR4 format, a symbol table uses a file name of "/ " in its |
---|
85 | * archive header. The symbol table is structured as: |
---|
86 | * - a 4-byte count of entries stored as a binary value, MSB first |
---|
87 | * - 'n' 4-byte offsets, stored as binary values, MSB first |
---|
88 | * - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded. |
---|
89 | * |
---|
90 | * In the BSD format, the symbol table uses a file name of "__.SYMDEF". |
---|
91 | * It is structured as two parts: |
---|
92 | * - The first part is an array of "ranlib" structures preceded by |
---|
93 | * the size of the array in bytes. Each "ranlib" structure |
---|
94 | * describes one symbol. Each structure contains an offset into |
---|
95 | * the string table for the symbol name, and a file offset into the |
---|
96 | * archive for the member defining the symbol. |
---|
97 | * - The second part is a string table containing NUL-terminated |
---|
98 | * strings, preceded by the size of the string table in bytes. |
---|
99 | * |
---|
100 | * If the symbol table and string table are is present in an archive |
---|
101 | * they must be the very first objects and in that order. |
---|
102 | */ |
---|
103 | |
---|
104 | |
---|
105 | /* |
---|
106 | * Retrieve an archive header descriptor. |
---|
107 | */ |
---|
108 | |
---|
109 | Elf_Arhdr * |
---|
110 | _libelf_ar_gethdr(Elf *e) |
---|
111 | { |
---|
112 | Elf *parent; |
---|
113 | char *namelen; |
---|
114 | Elf_Arhdr *eh; |
---|
115 | size_t n, nlen; |
---|
116 | struct ar_hdr *arh; |
---|
117 | |
---|
118 | if ((parent = e->e_parent) == NULL) { |
---|
119 | LIBELF_SET_ERROR(ARGUMENT, 0); |
---|
120 | return (NULL); |
---|
121 | } |
---|
122 | |
---|
123 | assert((e->e_flags & LIBELF_F_AR_HEADER) == 0); |
---|
124 | |
---|
125 | arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr; |
---|
126 | |
---|
127 | assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG); |
---|
128 | assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + |
---|
129 | parent->e_rawsize - sizeof(struct ar_hdr)); |
---|
130 | |
---|
131 | if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) { |
---|
132 | LIBELF_SET_ERROR(RESOURCE, 0); |
---|
133 | return (NULL); |
---|
134 | } |
---|
135 | |
---|
136 | e->e_hdr.e_arhdr = eh; |
---|
137 | e->e_flags |= LIBELF_F_AR_HEADER; |
---|
138 | |
---|
139 | eh->ar_name = eh->ar_rawname = NULL; |
---|
140 | |
---|
141 | if ((eh->ar_name = _libelf_ar_get_translated_name(arh, parent)) == |
---|
142 | NULL) |
---|
143 | goto error; |
---|
144 | |
---|
145 | if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, |
---|
146 | &n) == 0) |
---|
147 | goto error; |
---|
148 | eh->ar_uid = (uid_t) n; |
---|
149 | |
---|
150 | if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, |
---|
151 | &n) == 0) |
---|
152 | goto error; |
---|
153 | eh->ar_gid = (gid_t) n; |
---|
154 | |
---|
155 | if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, |
---|
156 | &n) == 0) |
---|
157 | goto error; |
---|
158 | eh->ar_mode = (mode_t) n; |
---|
159 | |
---|
160 | if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, |
---|
161 | &n) == 0) |
---|
162 | goto error; |
---|
163 | |
---|
164 | /* |
---|
165 | * Get the true size of the member if extended naming is being used. |
---|
166 | */ |
---|
167 | if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { |
---|
168 | namelen = arh->ar_name + |
---|
169 | LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; |
---|
170 | if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - |
---|
171 | LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0) |
---|
172 | goto error; |
---|
173 | n -= nlen; |
---|
174 | } |
---|
175 | |
---|
176 | eh->ar_size = n; |
---|
177 | |
---|
178 | if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL) |
---|
179 | goto error; |
---|
180 | |
---|
181 | eh->ar_flags = 0; |
---|
182 | |
---|
183 | return (eh); |
---|
184 | |
---|
185 | error: |
---|
186 | if (eh) { |
---|
187 | if (eh->ar_name) |
---|
188 | free(eh->ar_name); |
---|
189 | if (eh->ar_rawname) |
---|
190 | free(eh->ar_rawname); |
---|
191 | free(eh); |
---|
192 | } |
---|
193 | |
---|
194 | e->e_flags &= ~LIBELF_F_AR_HEADER; |
---|
195 | e->e_hdr.e_rawhdr = (char *) arh; |
---|
196 | |
---|
197 | return (NULL); |
---|
198 | } |
---|
199 | |
---|
200 | Elf * |
---|
201 | _libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf) |
---|
202 | { |
---|
203 | Elf *e; |
---|
204 | char *member, *namelen; |
---|
205 | size_t nsz, sz; |
---|
206 | off_t next; |
---|
207 | struct ar_hdr *arh; |
---|
208 | |
---|
209 | assert(elf->e_kind == ELF_K_AR); |
---|
210 | |
---|
211 | next = elf->e_u.e_ar.e_next; |
---|
212 | |
---|
213 | /* |
---|
214 | * `next' is only set to zero by elf_next() when the last |
---|
215 | * member of an archive is processed. |
---|
216 | */ |
---|
217 | if (next == (off_t) 0) |
---|
218 | return (NULL); |
---|
219 | |
---|
220 | assert((next & 1) == 0); |
---|
221 | |
---|
222 | arh = (struct ar_hdr *) (elf->e_rawfile + next); |
---|
223 | |
---|
224 | /* |
---|
225 | * Retrieve the size of the member. |
---|
226 | */ |
---|
227 | if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, |
---|
228 | &sz) == 0) { |
---|
229 | LIBELF_SET_ERROR(ARCHIVE, 0); |
---|
230 | return (NULL); |
---|
231 | } |
---|
232 | |
---|
233 | /* |
---|
234 | * Adjust the size field for members in BSD archives using |
---|
235 | * extended naming. |
---|
236 | */ |
---|
237 | if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { |
---|
238 | namelen = arh->ar_name + |
---|
239 | LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; |
---|
240 | if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - |
---|
241 | LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) { |
---|
242 | LIBELF_SET_ERROR(ARCHIVE, 0); |
---|
243 | return (NULL); |
---|
244 | } |
---|
245 | |
---|
246 | member = (char *) (arh + 1) + nsz; |
---|
247 | sz -= nsz; |
---|
248 | } else |
---|
249 | member = (char *) (arh + 1); |
---|
250 | |
---|
251 | |
---|
252 | if ((e = elf_memory((char *) member, sz)) == NULL) |
---|
253 | return (NULL); |
---|
254 | |
---|
255 | e->e_fd = fd; |
---|
256 | e->e_cmd = c; |
---|
257 | e->e_hdr.e_rawhdr = (char *) arh; |
---|
258 | |
---|
259 | elf->e_u.e_ar.e_nchildren++; |
---|
260 | e->e_parent = elf; |
---|
261 | |
---|
262 | return (e); |
---|
263 | } |
---|
264 | |
---|
265 | /* |
---|
266 | * A BSD-style ar(1) symbol table has the following layout: |
---|
267 | * |
---|
268 | * - A count of bytes used by the following array of 'ranlib' |
---|
269 | * structures, stored as a 'long'. |
---|
270 | * - An array of 'ranlib' structures. Each array element is |
---|
271 | * two 'long's in size. |
---|
272 | * - A count of bytes used for the following symbol table. |
---|
273 | * - The symbol table itself. |
---|
274 | */ |
---|
275 | |
---|
276 | /* |
---|
277 | * A helper macro to read in a 'long' value from the archive. We use |
---|
278 | * memcpy() since the source pointer may be misaligned with respect to |
---|
279 | * the natural alignment for a C 'long'. |
---|
280 | */ |
---|
281 | #define GET_LONG(P, V)do { \ |
---|
282 | memcpy(&(V), (P), sizeof(long)); \ |
---|
283 | (P) += sizeof(long); \ |
---|
284 | } while (0) |
---|
285 | |
---|
286 | Elf_Arsym * |
---|
287 | _libelf_ar_process_bsd_symtab(Elf *e, size_t *count) |
---|
288 | { |
---|
289 | Elf_Arsym *symtab, *sym; |
---|
290 | unsigned char *end, *p, *p0, *s, *s0; |
---|
291 | const unsigned int entrysize = 2 * sizeof(long); |
---|
292 | long arraysize, fileoffset, n, nentries, stroffset, strtabsize; |
---|
293 | |
---|
294 | assert(e != NULL); |
---|
295 | assert(count != NULL); |
---|
296 | assert(e->e_u.e_ar.e_symtab == NULL); |
---|
297 | |
---|
298 | symtab = NULL; |
---|
299 | |
---|
300 | /* |
---|
301 | * The BSD symbol table always contains the count fields even |
---|
302 | * if there are no entries in it. |
---|
303 | */ |
---|
304 | if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long)) |
---|
305 | goto symtaberror; |
---|
306 | |
---|
307 | p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab; |
---|
308 | end = p0 + e->e_u.e_ar.e_rawsymtabsz; |
---|
309 | |
---|
310 | /* |
---|
311 | * Retrieve the size of the array of ranlib descriptors and |
---|
312 | * check it for validity. |
---|
313 | */ |
---|
314 | GET_LONG(p, arraysize); |
---|
315 | |
---|
316 | if (p0 + arraysize >= end || (arraysize % entrysize != 0)) |
---|
317 | goto symtaberror; |
---|
318 | |
---|
319 | /* |
---|
320 | * Check the value of the string table size. |
---|
321 | */ |
---|
322 | s = p + arraysize; |
---|
323 | GET_LONG(s, strtabsize); |
---|
324 | |
---|
325 | s0 = s; /* Start of string table. */ |
---|
326 | if (s0 + strtabsize > end) |
---|
327 | goto symtaberror; |
---|
328 | |
---|
329 | nentries = arraysize / entrysize; |
---|
330 | |
---|
331 | /* |
---|
332 | * Allocate space for the returned Elf_Arsym array. |
---|
333 | */ |
---|
334 | if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) { |
---|
335 | LIBELF_SET_ERROR(RESOURCE, 0); |
---|
336 | return (NULL); |
---|
337 | } |
---|
338 | |
---|
339 | /* Read in symbol table entries. */ |
---|
340 | for (n = 0, sym = symtab; n < nentries; n++, sym++) { |
---|
341 | GET_LONG(p, stroffset); |
---|
342 | GET_LONG(p, fileoffset); |
---|
343 | |
---|
344 | s = s0 + stroffset; |
---|
345 | |
---|
346 | if (s >= end) |
---|
347 | goto symtaberror; |
---|
348 | |
---|
349 | sym->as_off = fileoffset; |
---|
350 | sym->as_hash = elf_hash((char *) s); |
---|
351 | sym->as_name = (char *) s; |
---|
352 | } |
---|
353 | |
---|
354 | /* Fill up the sentinel entry. */ |
---|
355 | sym->as_name = NULL; |
---|
356 | sym->as_hash = ~0UL; |
---|
357 | sym->as_off = (off_t) 0; |
---|
358 | |
---|
359 | /* Remember the processed symbol table. */ |
---|
360 | e->e_u.e_ar.e_symtab = symtab; |
---|
361 | |
---|
362 | *count = e->e_u.e_ar.e_symtabsz = nentries + 1; |
---|
363 | |
---|
364 | return (symtab); |
---|
365 | |
---|
366 | symtaberror: |
---|
367 | if (symtab) |
---|
368 | free(symtab); |
---|
369 | LIBELF_SET_ERROR(ARCHIVE, 0); |
---|
370 | return (NULL); |
---|
371 | } |
---|
372 | |
---|
373 | /* |
---|
374 | * An SVR4-style ar(1) symbol table has the following layout: |
---|
375 | * |
---|
376 | * - The first 4 bytes are a binary count of the number of entries in the |
---|
377 | * symbol table, stored MSB-first. |
---|
378 | * - Then there are 'n' 4-byte binary offsets, also stored MSB first. |
---|
379 | * - Following this, there are 'n' null-terminated strings. |
---|
380 | */ |
---|
381 | |
---|
382 | #define GET_WORD(P, V) do { \ |
---|
383 | (V) = 0; \ |
---|
384 | (V) = (P)[0]; (V) <<= 8; \ |
---|
385 | (V) += (P)[1]; (V) <<= 8; \ |
---|
386 | (V) += (P)[2]; (V) <<= 8; \ |
---|
387 | (V) += (P)[3]; \ |
---|
388 | } while (0) |
---|
389 | |
---|
390 | #define INTSZ 4 |
---|
391 | |
---|
392 | |
---|
393 | Elf_Arsym * |
---|
394 | _libelf_ar_process_svr4_symtab(Elf *e, size_t *count) |
---|
395 | { |
---|
396 | size_t n, nentries, off; |
---|
397 | Elf_Arsym *symtab, *sym; |
---|
398 | unsigned char *p, *s, *end; |
---|
399 | |
---|
400 | assert(e != NULL); |
---|
401 | assert(count != NULL); |
---|
402 | assert(e->e_u.e_ar.e_symtab == NULL); |
---|
403 | |
---|
404 | symtab = NULL; |
---|
405 | |
---|
406 | if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) |
---|
407 | goto symtaberror; |
---|
408 | |
---|
409 | p = (unsigned char *) e->e_u.e_ar.e_rawsymtab; |
---|
410 | end = p + e->e_u.e_ar.e_rawsymtabsz; |
---|
411 | |
---|
412 | GET_WORD(p, nentries); |
---|
413 | p += INTSZ; |
---|
414 | |
---|
415 | if (nentries == 0 || p + nentries * INTSZ >= end) |
---|
416 | goto symtaberror; |
---|
417 | |
---|
418 | /* Allocate space for a nentries + a sentinel. */ |
---|
419 | if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) { |
---|
420 | LIBELF_SET_ERROR(RESOURCE, 0); |
---|
421 | return (NULL); |
---|
422 | } |
---|
423 | |
---|
424 | s = p + (nentries * INTSZ); /* start of the string table. */ |
---|
425 | |
---|
426 | for (n = nentries, sym = symtab; n > 0; n--) { |
---|
427 | |
---|
428 | if (s >= end) |
---|
429 | goto symtaberror; |
---|
430 | |
---|
431 | off = 0; |
---|
432 | |
---|
433 | GET_WORD(p, off); |
---|
434 | |
---|
435 | sym->as_off = off; |
---|
436 | sym->as_hash = elf_hash((char *) s); |
---|
437 | sym->as_name = (char *) s; |
---|
438 | |
---|
439 | p += INTSZ; |
---|
440 | sym++; |
---|
441 | |
---|
442 | for (; s < end && *s++ != '\0';) /* skip to next string */ |
---|
443 | ; |
---|
444 | } |
---|
445 | |
---|
446 | /* Fill up the sentinel entry. */ |
---|
447 | sym->as_name = NULL; |
---|
448 | sym->as_hash = ~0UL; |
---|
449 | sym->as_off = (off_t) 0; |
---|
450 | |
---|
451 | *count = e->e_u.e_ar.e_symtabsz = nentries + 1; |
---|
452 | e->e_u.e_ar.e_symtab = symtab; |
---|
453 | |
---|
454 | return (symtab); |
---|
455 | |
---|
456 | symtaberror: |
---|
457 | if (symtab) |
---|
458 | free(symtab); |
---|
459 | LIBELF_SET_ERROR(ARCHIVE, 0); |
---|
460 | return (NULL); |
---|
461 | } |
---|